Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

31.4 KB
Raw Blame
use crate::SegmentAudioTimingRepair;
use cap_audio::{
    AudioData, AudioRendererTrack, AudioSampleSource, AudioSampleWindow, AudioWindowRead,
    ProgressiveAudio, VOICE_PROFILE_SAMPLES, VOICE_WINDOW_PADDING_SAMPLES, VoiceEnhancer,
    VoiceProfile, VoiceSource,
};
use cap_project::ProjectConfiguration;
use std::{ops::Range, sync::Arc};

const RATE: f64 = AudioData::SAMPLE_RATE as f64;
const MAX_FRAME: usize = 1 << 40;
const MAX_CHUNK_FRAMES: usize = 65_536;

#[derive(Clone)]
pub(crate) struct PreparingAudioSources {
    pub(crate) project: Arc<ProjectConfiguration>,
    pub(crate) tracks: Vec<[Option<ProgressiveAudio>; 2]>,
    pub(crate) required: Vec<[bool; 2]>,
    pub(crate) repairs: Vec<SegmentAudioTimingRepair>,
}

struct ClipLayout {
    start: usize,
    end: usize,
    offsets: [isize; 2],
}

impl PreparingAudioSources {
    pub(crate) fn validate(&self) -> Result<(), String> {
        self.layout().map(drop)
    }

    pub(crate) fn total_duration(&self) -> f64 {
        self.project.timeline.as_ref().map_or(0.0, |timeline| {
            timeline.segments.iter().map(|segment| segment.end).sum()
        })
    }

    fn layout(&self) -> Result<Vec<ClipLayout>, String> {
        let timeline = self
            .project
            .timeline
            .as_ref()
            .ok_or("Preparing audio timeline is absent")?;
        let count = self.tracks.len();
        if count == 0
            || count > 1024
            || self.required.len() != count
            || self.repairs.len() != count
            || timeline.segments.len() != count
            || self.project.clips.len() != count
            || !timeline.transitions.is_empty()
            || !timeline.audio_segments.is_empty()
            || !timeline.hold_windows().is_empty()
            || !self.project.audio.mic_volume_db.is_finite()
            || !self.project.audio.system_volume_db.is_finite()
        {
            return Err("Preparing audio layout is unsupported".into());
        }
        let mut offsets = vec![None; count];
        for clip in &self.project.clips {
            let slot = offsets
                .get_mut(clip.index as usize)
                .ok_or("Preparing audio clip index is invalid")?;
            if slot.replace(clip.offsets).is_some() {
                return Err("Preparing audio clip index is duplicated".into());
            }
        }
        let mut duration = 0.0;
        let mut start = 0;
        let mut clips = Vec::with_capacity(count);
        for (index, segment) in timeline.segments.iter().enumerate() {
            if segment.recording_clip as usize != index
                || segment.start != 0.0
                || segment.timescale != 1.0
                || segment.speed_audio_mode.is_some()
                || segment.volume() != 1.0
                || !segment.end.is_finite()
                || segment.end <= 0.0
            {
                return Err("Preparing audio requires the stopped 1x timeline".into());
            }
            duration += segment.end;
            if !duration.is_finite() || duration * RATE > MAX_FRAME as f64 {
                return Err("Preparing audio timeline exceeds sample limits".into());
            }
            let end = (duration * RATE).round() as usize;
            if end <= start {
                return Err("Preparing audio clip has no sample frames".into());
            }
            let offset = offsets[index].ok_or("Preparing audio clip offsets are absent")?;
            let repair = self.repairs[index];
            let mut samples = [0; 2];
            for (track, (base, repair)) in [
                (offset.mic, repair.mic_offset_secs),
                (offset.system_audio, repair.system_audio_offset_secs),
            ]
            .into_iter()
            .enumerate()
            {
                let sum = base + repair;
                let rounded = (sum * AudioData::SAMPLE_RATE as f32).round();
                if !base.is_finite()
                    || !repair.is_finite()
                    || !rounded.is_finite()
                    || rounded.abs() > MAX_FRAME as f32
                    || (!self.required[index][track] && self.tracks[index][track].is_some())
                {
                    return Err("Preparing audio track timing or presence is invalid".into());
                }
                samples[track] = rounded as isize;
            }
            clips.push(ClipLayout {
                start,
                end,
                offsets: samples,
            });
            start = end;
        }
        Ok(clips)
    }

    fn check_terminal(&self) -> Result<(), String> {
        for loader in self.tracks.iter().flatten().flatten() {
            let progress = loader.progress();
            if let Some(error) = progress.error {
                return Err(error);
            }
            if progress.ready_frames > MAX_FRAME
                || progress
                    .channels
                    .is_some_and(|channels| !matches!(channels, 1 | 2))
            {
                return Err("Preparing audio sample layout is invalid".into());
            }
        }
        Ok(())
    }

    pub(crate) fn playable_prefix(&self) -> Result<f64, String> {
        let clips = self.layout()?;
        self.check_terminal()?;
        for (index, clip) in clips.iter().enumerate() {
            let frames = clip.end - clip.start;
            let mut available = frames;
            for (track, required) in self.required[index].iter().enumerate() {
                if !required {
                    continue;
                }
                let Some(loader) = &self.tracks[index][track] else {
                    available = 0;
                    continue;
                };
                let progress = loader.progress();
                let end = progress.ready_frames;
                let improve = track == 0
                    && self.project.audio.improve
                    && !self.project.audio.mute
                    && self.project.audio.mic_volume_db > -30.0;
                let covered = match loader.try_window(end.saturating_sub(1)..end)? {
                    AudioWindowRead::Ready(Some(window)) => {
                        if window.complete_sample_count().is_some() {
                            frames
                        } else if progress.channels.is_some() && window.available_range().end >= end
                        {
                            let end = if improve {
                                if end < VOICE_PROFILE_SAMPLES {
                                    0
                                } else {
                                    end.saturating_sub(VOICE_WINDOW_PADDING_SAMPLES)
                                }
                            } else {
                                end
                            };
                            (end as i128 - clip.offsets[track] as i128).clamp(0, frames as i128)
                                as usize
                        } else {
                            0
                        }
                    }
                    AudioWindowRead::Pending | AudioWindowRead::Ready(None) => 0,
                };
                available = available.min(covered);
            }
            if available < frames {
                return Ok(((clip.start + available) as f64 / RATE).min(self.total_duration()));
            }
        }
        self.check_terminal()?;
        Ok(self.total_duration())
    }
}

pub(crate) enum PreparingAudioRead {
    Samples {
        start_frame: usize,
        frames: usize,
        samples: Vec<f32>,
    },
    Pending {
        loader: Option<ProgressiveAudio>,
        range: Range<usize>,
    },
    Eof,
}

pub(crate) struct PreparingAudioMixer {
    sources: PreparingAudioSources,
    clips: Vec<ClipLayout>,
    position: usize,
    voice_profiles: Vec<Option<VoiceProfile>>,
    voice_enhancer: Option<(usize, VoiceEnhancer)>,
}

struct PreparedSpan {
    clip: usize,
    local: usize,
    output: usize,
    frames: usize,
    windows: [Option<AudioSampleWindow>; 2],
}

impl PreparingAudioMixer {
    pub(crate) fn new(sources: PreparingAudioSources, start_seconds: f64) -> Result<Self, String> {
        let clips = sources.layout()?;
        if !start_seconds.is_finite()
            || start_seconds < 0.0
            || start_seconds > sources.total_duration()
        {
            return Err("Preparing audio start is outside the timeline".into());
        }
        let position = (start_seconds * RATE).round() as usize;
        Ok(Self {
            voice_profiles: vec![None; clips.len()],
            voice_enhancer: None,
            sources,
            clips,
            position,
        })
    }

    pub(crate) fn next(&mut self, requested_frames: usize) -> Result<PreparingAudioRead, String> {
        if requested_frames == 0 || requested_frames > MAX_CHUNK_FRAMES {
            return Err("Preparing audio chunk size is invalid".into());
        }
        self.sources.check_terminal()?;
        let total = self
            .clips
            .last()
            .ok_or("Preparing audio timeline is empty")?
            .end;
        if self.position >= total {
            return Ok(PreparingAudioRead::Eof);
        }
        let end = self.position + requested_frames.min(total - self.position);
        let mut spans = Vec::new();
        let mut pending = None;
        let improve = self.sources.project.audio.improve
            && !self.sources.project.audio.mute
            && self.sources.project.audio.mic_volume_db > -30.0;
        for (index, clip) in self.clips.iter().enumerate() {
            let start = self.position.max(clip.start);
            let until = end.min(clip.end);
            if start >= until {
                continue;
            }
            let local = start - clip.start;
            let frames = until - start;
            if improve
                && self.sources.required[index][0]
                && self.voice_profiles[index].is_none()
                && let Some(loader) = &self.sources.tracks[index][0]
            {
                self.voice_profiles[index] = loader.try_voice_profile()?;
                if self.voice_profiles[index].is_none() {
                    pending.get_or_insert_with(|| PreparingAudioRead::Pending {
                        loader: Some(loader.clone()),
                        range: 0..VOICE_PROFILE_SAMPLES,
                    });
                }
            }
            let mut windows = [None, None];
            for (track, slot) in windows.iter_mut().enumerate() {
                if !self.sources.required[index][track] {
                    continue;
                }
                let first = local as i128 + clip.offsets[track] as i128;
                let mut range = first.max(0) as usize..(first + frames as i128).max(0) as usize;
                if improve && track == 0 && !range.is_empty() {
                    range = VoiceEnhancer::initial_source_range(range.start, range.len());
                }
                let Some(loader) = &self.sources.tracks[index][track] else {
                    pending.get_or_insert(PreparingAudioRead::Pending {
                        loader: None,
                        range,
                    });
                    continue;
                };
                match loader.try_window(range.clone())? {
                    AudioWindowRead::Pending => {
                        pending.get_or_insert_with(|| PreparingAudioRead::Pending {
                            loader: Some(loader.clone()),
                            range,
                        });
                    }
                    AudioWindowRead::Ready(None) => {
                        pending.get_or_insert(PreparingAudioRead::Pending {
                            loader: None,
                            range,
                        });
                    }
                    AudioWindowRead::Ready(Some(window)) => {
                        let covered = window.available_range();
                        let required = match window.complete_sample_count() {
                            Some(total) => range.start.min(total)..range.end.min(total),
                            None => range,
                        };
                        if !matches!(window.channels(), 1 | 2)
                            || (required.start < required.end
                                && (required.start < covered.start || required.end > covered.end))
                        {
                            return Err("Preparing audio window does not cover its samples".into());
                        }
                        *slot = Some(window);
                    }
                }
            }
            spans.push(PreparedSpan {
                clip: index,
                local,
                output: start - self.position,
                frames,
                windows,
            });
        }
        self.sources.check_terminal()?;
        if let Some(pending) = pending {
            return Ok(pending);
        }
        let frames = end - self.position;
        let mut samples = vec![0.0; frames * 2];
        for span in spans {
            let enhanced =
                if improve {
                    span.windows[0].as_ref().and_then(|window| {
                        let first = span.local as i128 + self.clips[span.clip].offsets[0] as i128;
                        let start = first.max(0) as usize;
                        let end = (first + span.frames as i128).max(0) as usize;
                        if start == end || start >= window.sample_count() {
                            return None;
                        }
                        if self
                            .voice_enhancer
                            .as_ref()
                            .is_none_or(|(clip, _)| *clip != span.clip)
                        {
                            self.voice_enhancer = Some((
                                span.clip,
                                VoiceEnhancer::with_settings(
                                    window.channels(),
                                    self.sources.project.audio.isolation.strength(),
                                    self.voice_profiles[span.clip].unwrap_or_default(),
                                ),
                            ));
                        }
                        Some(self.voice_enhancer.as_mut().unwrap().1.render(
                            window,
                            start,
                            end - start,
                        ))
                    })
                } else {
                    None
                };
            let sources = span
                .windows
                .iter()
                .enumerate()
                .map(|(track, window)| {
                    window.as_ref().map(|window| {
                        if track == 0 {
                            enhanced
                                .as_ref()
                                .map_or(VoiceSource::Original(window), VoiceSource::Enhanced)
                        } else {
                            VoiceSource::Original(window)
                        }
                    })
                })
                .collect::<Vec<_>>();
            let tracks = sources
                .iter()
                .enumerate()
                .filter_map(|(track, window)| {
                    let data = window.as_ref()?;
                    let audio = &self.sources.project.audio;
                    let gain = if track == 0 {
                        audio.mic_volume_db
                    } else {
                        audio.system_volume_db
                    };
                    Some(AudioRendererTrack {
                        data,
                        gain: if audio.mute || gain < -30.0 {
                            f32::NEG_INFINITY
                        } else {
                            gain
                        },
                        stereo_mode: if track == 0 {
                            match audio.mic_stereo_mode {
                                cap_project::StereoMode::Stereo => cap_audio::StereoMode::Stereo,
                                cap_project::StereoMode::MonoL => cap_audio::StereoMode::MonoL,
                                cap_project::StereoMode::MonoR => cap_audio::StereoMode::MonoR,
                            }
                        } else {
                            cap_audio::StereoMode::Stereo
                        },
                        offset: self.clips[span.clip].offsets[track],
                    })
                })
                .collect::<Vec<_>>();
            cap_audio::render_audio(
                &tracks,
                span.local,
                span.frames,
                span.output * 2,
                &mut samples,
            );
        }
        self.sources.check_terminal()?;
        let start_frame = self.position;
        self.position = end;
        Ok(PreparingAudioRead::Samples {
            start_frame,
            frames,
            samples,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use cap_audio::{AudioChunk, DecodedAudio, ProgressiveAudioTestProducer};
    use cap_project::{ClipConfiguration, TimelineConfiguration, TimelineSegment};

    fn audio(frames: usize, channels: u16, seed: usize) -> Arc<AudioData> {
        Arc::new(AudioData::from_raw_f32(
            (0..frames * usize::from(channels))
                .map(|index| ((index * 97 + seed) % 127) as f32 / 90.0 - 0.7)
                .collect(),
            channels,
        ))
    }

    fn append(producer: &ProgressiveAudioTestProducer, audio: &AudioData, range: Range<usize>) {
        let channels = usize::from(audio.channels());
        producer
            .append(AudioChunk {
                source_start_sample: range.start as u64,
                channels: audio.channels(),
                samples: audio.samples()[range.start * channels..range.end * channels].to_vec(),
            })
            .unwrap();
    }

    fn sources(
        durations: &[f64],
        tracks: Vec<[Option<ProgressiveAudio>; 2]>,
    ) -> PreparingAudioSources {
        let count = durations.len();
        PreparingAudioSources {
            project: Arc::new(ProjectConfiguration {
                timeline: Some(TimelineConfiguration {
                    segments: durations
                        .iter()
                        .enumerate()
                        .map(|(index, &end)| TimelineSegment {
                            recording_clip: index as u32,
                            start: 0.0,
                            end,
                            timescale: 1.0,
                            ..Default::default()
                        })
                        .collect(),
                    transitions: Vec::new(),
                    zoom_segments: Vec::new(),
                    scene_segments: Vec::new(),
                    mask_segments: Vec::new(),
                    text_segments: Vec::new(),
                    caption_segments: Vec::new(),
                    keyboard_segments: Vec::new(),
                    audio_segments: Vec::new(),
                    style_segments: Vec::new(),
                    image_segments: Vec::new(),
                    camera3d_segments: Vec::new(),
                }),
                clips: (0..count)
                    .map(|index| ClipConfiguration {
                        index: index as u32,
                        ..Default::default()
                    })
                    .collect(),
                ..Default::default()
            }),
            required: tracks
                .iter()
                .map(|tracks| tracks.each_ref().map(Option::is_some))
                .collect(),
            tracks,
            repairs: vec![SegmentAudioTimingRepair::default(); count],
        }
    }

    fn reference(
        sources: &PreparingAudioSources,
        audio: Vec<[Option<Arc<AudioData>>; 2]>,
        start: f64,
        frames: usize,
    ) -> (usize, Vec<f32>) {
        let segments = audio
            .into_iter()
            .zip(&sources.repairs)
            .map(|([mic, system], &repair)| {
                let decoded = |audio: Arc<AudioData>| Arc::new(DecodedAudio::from(audio));
                crate::audio_segment_from_decoded(mic.map(decoded), system.map(decoded), repair)
            })
            .collect();
        let mut renderer = crate::AudioRenderer::new(segments);
        renderer.set_playhead(start, &sources.project);
        renderer.render_frame_raw(frames, &sources.project).unwrap()
    }

    fn assert_samples(
        actual: PreparingAudioRead,
        expected_start: usize,
        expected: (usize, Vec<f32>),
    ) {
        let PreparingAudioRead::Samples {
            start_frame,
            frames,
            samples,
        } = actual
        else {
            panic!("Expected real mixed audio samples");
        };
        assert_eq!(start_frame, expected_start);
        assert_eq!(frames, expected.0);
        assert_eq!(samples.len(), frames * 2);
        assert_eq!(samples.len(), expected.1.len());
        for (index, (actual, expected)) in samples.iter().zip(&expected.1).enumerate() {
            assert_eq!(actual.to_bits(), expected.to_bits(), "sample {index}");
        }
    }

    #[test]
    fn studio_sound_pending_and_completed_audio_match_all_tiers() {
        ffmpeg::init().unwrap();
        for isolation in [
            cap_project::VoiceIsolation::Light,
            cap_project::VoiceIsolation::Balanced,
            cap_project::VoiceIsolation::Strong,
        ] {
            let mic = audio(VOICE_PROFILE_SAMPLES + 32_768, 1, 17);
            let (loader, producer) = ProgressiveAudioTestProducer::new();
            append(&producer, &mic, 0..32_768);
            let mut sources = sources(
                &[mic.sample_count() as f64 / RATE],
                vec![[Some(loader), None]],
            );
            let project = Arc::make_mut(&mut sources.project);
            project.audio.improve = true;
            project.audio.isolation = isolation;
            let mut mixer = PreparingAudioMixer::new(sources.clone(), 0.0).unwrap();
            assert_eq!(sources.playable_prefix().unwrap(), 0.0);
            assert!(matches!(
                mixer.next(4096).unwrap(),
                PreparingAudioRead::Pending { .. }
            ));
            let ready = VOICE_PROFILE_SAMPLES.div_ceil(32_768) * 32_768;
            for start in (32_768..ready).step_by(32_768) {
                append(&producer, &mic, start..start + 32_768);
            }
            let expected = reference(&sources, vec![[Some(mic.clone()), None]], 0.0, 8192);
            let first = mixer.next(4096).unwrap();
            assert_samples(first, 0, (4096, expected.1[..8192].to_vec()));
            append(&producer, &mic, ready..mic.sample_count());
            producer.finish().unwrap();
            assert_samples(
                mixer.next(4096).unwrap(),
                4096,
                (4096, expected.1[8192..].to_vec()),
            );
        }
    }

    #[test]
    fn pending_blocks_match_ordinary_offset_gain_stereo_and_mute_mixing() {
        for channels in [1, 2] {
            for mode in [
                cap_project::StereoMode::Stereo,
                cap_project::StereoMode::MonoL,
                cap_project::StereoMode::MonoR,
            ] {
                for mute in [false, true] {
                    let mic = audio(65_536, channels, 17);
                    let system = audio(65_536, 2, 53);
                    let (mic_loader, mic_producer) = ProgressiveAudioTestProducer::new();
                    let (system_loader, system_producer) = ProgressiveAudioTestProducer::new();
                    append(&mic_producer, &mic, 0..32_768);
                    append(&system_producer, &system, 0..32_768);
                    let mut sources =
                        sources(&[1.25], vec![[Some(mic_loader), Some(system_loader)]]);
                    let project = Arc::make_mut(&mut sources.project);
                    project.audio.mute = mute;
                    project.audio.mic_stereo_mode = mode.clone();
                    project.audio.mic_volume_db = -3.0;
                    project.audio.system_volume_db = if mute { -31.0 } else { 1.0 };
                    project.clips[0].offsets.mic = 13.25 / RATE as f32;
                    project.clips[0].offsets.system_audio = -11.75 / RATE as f32;
                    sources.repairs[0] = SegmentAudioTimingRepair {
                        mic_offset_secs: -30.5 / RATE as f32,
                        system_audio_offset_secs: 28.25 / RATE as f32,
                    };
                    let expected = reference(&sources, vec![[Some(mic), Some(system)]], 0.0, 4096);
                    let mut mixer = PreparingAudioMixer::new(sources.clone(), 0.0).unwrap();
                    assert!(sources.playable_prefix().unwrap() < sources.total_duration());
                    assert_samples(mixer.next(4096).unwrap(), 0, expected);
                    assert!(!sources.tracks[0][0].as_ref().unwrap().progress().complete);
                }
            }
        }
    }

    #[test]
    fn cross_clip_pending_preflights_the_entire_chunk_without_advancing() {
        let first = audio(1500, 1, 7);
        let second = audio(40_000, 2, 71);
        let (loader, producer) = ProgressiveAudioTestProducer::new();
        let sources = sources(
            &[1000.0 / RATE, 40_000.0 / RATE],
            vec![
                [Some(ProgressiveAudio::ready(Some(first.clone()))), None],
                [Some(loader), None],
            ],
        );
        let start = 950.0 / RATE;
        let expected = reference(
            &sources,
            vec![[Some(first), None], [Some(second.clone()), None]],
            start,
            1024,
        );
        let mut mixer = PreparingAudioMixer::new(sources.clone(), start).unwrap();
        assert_eq!(sources.playable_prefix().unwrap(), 1000.0 / RATE);
        for _ in 0..2 {
            let PreparingAudioRead::Pending {
                loader: Some(_),
                range,
            } = mixer.next(1024).unwrap()
            else {
                panic!("Expected the second clip's actual pending loader");
            };
            assert_eq!(range, 0..974);
        }
        append(&producer, &second, 0..32_768);
        assert_eq!(sources.playable_prefix().unwrap(), 33_768.0 / RATE);
        assert_samples(mixer.next(1024).unwrap(), 950, expected);
        append(&producer, &second, 32_768..40_000);
        producer.finish().unwrap();
        assert_eq!(sources.playable_prefix().unwrap(), sources.total_duration());
    }

    #[test]
    fn clip_boundaries_use_ordinary_accumulated_rounding() {
        let first = audio(1100, 2, 5);
        let second = audio(1100, 1, 11);
        let sources = sources(
            &[1000.49 / RATE, 800.49 / RATE],
            vec![
                [Some(ProgressiveAudio::ready(Some(first.clone()))), None],
                [Some(ProgressiveAudio::ready(Some(second.clone()))), None],
            ],
        );
        let expected = reference(
            &sources,
            vec![[Some(first), None], [Some(second), None]],
            0.0,
            2048,
        );
        assert_eq!(expected.0, 1801);
        let mut mixer = PreparingAudioMixer::new(sources, 0.0).unwrap();
        assert_samples(mixer.next(2048).unwrap(), 0, expected);
        assert!(matches!(mixer.next(1024).unwrap(), PreparingAudioRead::Eof));
    }

    #[test]
    fn only_true_eof_admits_the_silent_tail() {
        let data = audio(64, 1, 3);
        let (loader, producer) = ProgressiveAudioTestProducer::new();
        append(&producer, &data, 0..64);
        let sources = sources(&[1000.0 / RATE], vec![[Some(loader), None]]);
        let expected = reference(&sources, vec![[Some(data), None]], 0.0, 1024);
        let mut mixer = PreparingAudioMixer::new(sources.clone(), 0.0).unwrap();
        assert_eq!(sources.playable_prefix().unwrap(), 64.0 / RATE);
        assert!(matches!(
            mixer.next(1024).unwrap(),
            PreparingAudioRead::Pending { .. }
        ));
        producer.finish().unwrap();
        assert_eq!(sources.playable_prefix().unwrap(), sources.total_duration());
        assert_samples(mixer.next(1024).unwrap(), 0, expected);
        assert!(matches!(mixer.next(1).unwrap(), PreparingAudioRead::Eof));
    }

    #[test]
    fn absent_audio_is_silence_but_declared_missing_or_empty_audio_is_pending() {
        let mut sources = sources(&[1.0], vec![[None, None]]);
        assert_eq!(sources.playable_prefix().unwrap(), 1.0);
        let mut mixer = PreparingAudioMixer::new(sources.clone(), 0.0).unwrap();
        assert_samples(mixer.next(1024).unwrap(), 0, (1024, vec![0.0; 2048]));
        sources.required[0][0] = true;
        for empty in [None, Some(ProgressiveAudio::none())] {
            sources.tracks[0][0] = empty;
            assert_eq!(sources.playable_prefix().unwrap(), 0.0);
            let mut mixer = PreparingAudioMixer::new(sources.clone(), 0.0).unwrap();
            assert!(matches!(
                mixer.next(1024).unwrap(),
                PreparingAudioRead::Pending { loader: None, .. }
            ));
        }
    }

    #[test]
    fn late_failure_is_terminal_even_when_muted_or_beyond_a_blocked_clip() {
        let data = audio(32_768, 2, 41);
        let (loader, producer) = ProgressiveAudioTestProducer::new();
        append(&producer, &data, 0..32_768);
        let mut sources = sources(&[1.0], vec![[Some(loader.clone()), None]]);
        Arc::make_mut(&mut sources.project).audio.mute = true;
        let mut mixer = PreparingAudioMixer::new(sources.clone(), 0.0).unwrap();
        assert_samples(mixer.next(1024).unwrap(), 0, (1024, vec![0.0; 2048]));
        producer.fail("corrupt tail".into());
        assert_eq!(sources.playable_prefix().unwrap_err(), "corrupt tail");
        assert_eq!(mixer.next(1024).err().unwrap(), "corrupt tail");
        let mut later = self::sources(&[1.0, 1.0], vec![[None, None], [Some(loader), None]]);
        later.required[0][0] = true;
        assert_eq!(later.playable_prefix().unwrap_err(), "corrupt tail");
    }

    #[test]
    fn validation_rejects_unbounded_or_changed_audio_layout() {
        let original = sources(&[1.0], vec![[None, None]]);
        original.validate().unwrap();
        let cases: [fn(&mut PreparingAudioSources); 7] = [
            |sources| sources.required.clear(),
            |sources| sources.repairs[0].mic_offset_secs = f32::NAN,
            |sources| Arc::make_mut(&mut sources.project).clips[0].index = 1,
            |sources| Arc::make_mut(&mut sources.project).audio.mic_volume_db = f32::INFINITY,
            |sources| {
                Arc::make_mut(&mut sources.project)
                    .timeline
                    .as_mut()
                    .unwrap()
                    .segments[0]
                    .end = f64::INFINITY
            },
            |sources| {
                Arc::make_mut(&mut sources.project)
                    .timeline
                    .as_mut()
                    .unwrap()
                    .segments[0]
                    .timescale = 2.0
            },
            |sources| {
                Arc::make_mut(&mut sources.project)
                    .timeline
                    .as_mut()
                    .unwrap()
                    .segments[0]
                    .end = MAX_FRAME as f64
            },
        ];
        for change in cases {
            let mut invalid = original.clone();
            change(&mut invalid);
            assert!(invalid.validate().is_err());
        }
        assert!(PreparingAudioMixer::new(original.clone(), f64::NAN).is_err());
        let mut mixer = PreparingAudioMixer::new(original, 0.0).unwrap();
        assert!(mixer.next(0).is_err());
        assert!(mixer.next(MAX_CHUNK_FRAMES + 1).is_err());
    }
}