GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Source-file auditioning. Playback is presentation state: it never edits the project.

use std::sync::{Arc, Mutex};

use filmcraft_engine::clip_ops::source_view;
use filmcraft_project::{ItemId, ItemKind};
use filmcraft_render::SourceProvider;
use filmcraft_time::Tick;
use serde_json::json;

use crate::{AUDIO_RETRY_S, AUDIO_STALL_S, FilmcraftApp, Playback, shuttle};

#[derive(Default)]
pub struct SourcePlayback {
    pub clock: Playback,
    item: Option<ItemId>,
    shown: Tick,
    range_start: Option<Tick>,
    failure: Arc<Mutex<Option<String>>>,
}

impl FilmcraftApp {
    pub fn toggle_source_play(&mut self) -> Result<(), String> {
        if self.source_playback.clock.playing {
            self.stop_source();
            Ok(())
        } else {
            self.play_source()
        }
    }

    pub fn play_source(&mut self) -> Result<(), String> {
        self.start_source_playback(None, None, 1.0)
    }

    /// J / K / L in the Source monitor: play at `speed` × real time (negative = backward) from the
    /// Source playhead. Sound plays at normal forward speed only, as in the Program monitor.
    pub fn shuttle_source(&mut self, speed: f64) -> Result<(), String> {
        if !speed.is_finite() || speed == 0.0 {
            return Err("Source shuttle speed must be a non-zero number".into());
        }
        self.start_source_playback(None, None, speed.clamp(-8.0, 8.0))
    }

    pub fn play_source_range(&mut self, from_playhead: bool, preroll: bool) -> Result<(), String> {
        let item = self.session.state.source_item.ok_or("Open a Source clip first")?;
        let view = source_view(&self.session, item).ok_or("Source item is unavailable")?;
        let range = view.selected_range();
        if range.duration.0 <= 0 {
            return Err("Source marked range is empty".into());
        }
        let seconds = |v: f64| Tick::from_seconds_f64(if v.is_finite() { v.clamp(0.0, 3600.0) } else { 0.0 });
        let start = if from_playhead {
            self.session.state.source_playhead
        } else if preroll {
            Tick(range.start.0.saturating_sub(seconds(self.session.prefs.playback.preroll_seconds).0)).max(view.start)
        } else {
            range.start
        };
        let stop =
            if preroll { Tick(range.end().0.saturating_add(seconds(self.session.prefs.playback.postroll_seconds).0)).min(view.end) } else { range.end() };
        if start >= stop {
            return Err("Source playhead is at or beyond the Out point".into());
        }
        self.start_source_playback(Some(start), Some(stop), 1.0)
    }

    fn start_source_playback(&mut self, start: Option<Tick>, stop: Option<Tick>, speed: f64) -> Result<(), String> {
        let item = self.session.state.source_item.ok_or("Open a media file in the Source monitor first")?;
        let view = source_view(&self.session, item).ok_or("Source item is unavailable")?;
        let pi = self.session.project.item(view.media).ok_or("Source playback currently supports media files, subclips and sequences")?;
        match &pi.kind {
            ItemKind::Media(media) => {
                if media.offline {
                    return Err("Source media is offline: use Link Media first".into());
                }
            }
            ItemKind::Sequence(_) => {}
            _ => return Err("Source playback currently supports media files, subclips and sequences".into()),
        }
        if view.end <= view.start {
            return Err("Source clip has no playable duration".into());
        }
        let looping = self.source_playback.clock.looping;
        let range = view.selected_range();
        if looping && range.duration.0 <= 0 {
            return Err("Source marked range is empty".into());
        }
        let first = if looping { range.start } else { view.start };
        let end = stop.unwrap_or(if looping { range.end() } else { view.end });
        self.stop();
        self.stop_source();
        let mut time = start.unwrap_or(self.session.state.source_playhead);
        // forward from the end (or before a looped range) starts over; backward runs from where it is
        if start.is_none() && speed > 0.0 && (time < first || time >= view.rate.snap(Tick(end.0.saturating_sub(view.rate.frame_duration().0))).max(first)) {
            time = first;
        }
        self.session.execute("source.setPlayhead", json!({"time": time.0})).map_err(|e| e.to_string())?;
        let time = self.session.state.source_playhead;
        self.source_playback.range_start = start;
        self.source_playback.item = Some(item);
        self.source_playback.shown = time;
        self.source_playback.clock = Playback { playing: true, speed, anchor_time: -1.0, anchor_tick: time, looping, stop_at: stop, ..Default::default() };
        self.source_playback.clock.meter.start(speed);
        self.start_source_audio(0.0);
        Ok(())
    }

    pub fn stop_source(&mut self) {
        if !self.source_playback.clock.playing {
            return;
        }
        self.source_playback.clock.playing = false;
        self.source_playback.clock.audio_clock = false;
        self.source_playback.clock.meter.finish();
        self.frames.stop_prefetch();
        if let Some(audio) = self.audio.as_mut() {
            audio.stop();
        }
    }

    fn start_source_audio(&mut self, now: f64) {
        self.source_playback.clock.audio_clock = false;
        if (self.source_playback.clock.speed - 1.0).abs() > 1e-9 {
            if let Some(audio) = self.audio.as_mut() {
                audio.stop();
            }
            self.source_playback.clock.audio_retry_at = 0.0;
            return;
        }
        let Some(item) = self.source_playback.item else { return };
        let Some(view) = source_view(&self.session, item) else { return };
        let Some(audio) = self.audio.as_mut() else { return };

        let sr = audio.sample_rate();
        if sr == 0 || audio.channels() == 0 {
            self.ui.status = "Source audio output has an invalid sample rate or channel count".into();
            return;
        }
        let Some(pi) = self.session.project.item(view.media) else { return };
        let fill: Box<dyn FnMut(&mut [f32], usize) + Send> = match &pi.kind {
            ItemKind::Media(media) => {
                if !media.info.has_audio() {
                    audio.stop();
                    self.source_playback.clock.audio_retry_at = 0.0;
                    return;
                }
                let project = self.session.project.clone();
                let provider = self.session.media.provider(project, self.session.services.clone());
                let Some(source) = provider.source(view.media) else {
                    self.ui.status = "Source audio is unavailable: check Link Media".into();
                    return;
                };
                let channels = media.interpret.audio_channels.as_ref().and_then(|m| m.clips.first()).cloned().unwrap_or_default();
                let map = [self.session.prefs.audio_hardware.map_left, self.session.prefs.audio_hardware.map_right];
                let mixdown = filmcraft_audio_dsp::channels::Mixdown::from_id(&self.session.prefs.audio.mixdown_type).unwrap_or_default();
                // A seek gets its own failure slot: a late callback from the old stream cannot stop it.
                self.source_playback.failure = Arc::new(Mutex::new(None));
                let failure = self.source_playback.failure.clone();
                let end = self
                    .source_playback
                    .clock
                    .stop_at
                    .unwrap_or_else(|| if self.source_playback.clock.looping { view.selected_range().end() } else { view.end })
                    .to_units_floor(i64::from(sr));
                let mix = move |cursor: i64, buf: &mut [f32], ch: usize| {
                    buf.fill(0.0);
                    if ch == 0 || cursor >= end {
                        return;
                    }
                    let frames = (buf.len() / ch).min(usize::try_from(end.saturating_sub(cursor)).unwrap_or(0));
                    match source.audio(cursor, frames, sr) {
                        Ok(mut sound) => {
                            if !channels.is_empty() {
                                sound.channels = channels.iter().filter_map(|c| sound.channels.get(usize::from(*c)).cloned()).collect();
                            }
                            let sound = filmcraft_render::audio::to_layout(sound, filmcraft_audio_dsp::channels::Layout::Stereo, mixdown);
                            let Some(left) = sound.channels.first() else { return };
                            let right = sound.channels.get(1).unwrap_or(left);
                            filmcraft_engine::settings::map_output(left, right, buf, ch, map);
                        }
                        Err(e) => {
                            *failure.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(format!("Source audio decoding failed: {e}"));
                        }
                    }
                };

                let cursor = self.session.state.source_playhead.to_units_floor(i64::from(sr));

                audio.stop();
                #[cfg(not(target_arch = "wasm32"))]
                let fill = crate::play_ahead::spawn(mix, cursor, sr, audio.channels(), self.source_playback.clock.audio_stats.clone());
                #[cfg(target_arch = "wasm32")]
                let fill = {
                    let (mix, mut cursor) = (mix, cursor);
                    Box::new(move |buf: &mut [f32], ch: usize| {
                        mix(cursor, buf, ch);
                        cursor = cursor.saturating_add(i64::try_from(buf.len() / ch.max(1)).unwrap_or(0));
                    })
                };
                fill
            }
            ItemKind::Sequence(seq) => {
                if seq.audio_tracks.iter().all(|t| t.items.is_empty()) {
                    audio.stop();
                    self.source_playback.clock.audio_retry_at = 0.0;
                    return;
                }
                let Some((mix_rate, mix)) = shuttle::mix(&self.session, item, sr, self.source_playback.clock.speed) else {
                    audio.stop();
                    self.source_playback.clock.audio_retry_at = 0.0;
                    return;
                };
                let cursor = self.session.state.source_playhead.to_units_floor(i64::from(mix_rate));

                audio.stop();
                #[cfg(not(target_arch = "wasm32"))]
                let fill = crate::play_ahead::spawn(mix, cursor, sr, audio.channels(), self.source_playback.clock.audio_stats.clone());
                #[cfg(target_arch = "wasm32")]
                let fill = {
                    let (mut mix, mut cursor) = (mix, cursor);
                    Box::new(move |buf: &mut [f32], ch: usize| {
                        mix(cursor, buf, ch);
                        cursor = cursor.saturating_add(i64::try_from(buf.len() / ch.max(1)).unwrap_or(0));
                    })
                };
                fill
            }
            _ => return,
        };
        match audio.start(fill) {
            Ok(_) => {
                self.source_playback.clock.audio_clock = true;
                self.source_playback.clock.audio_retry_at = 0.0;
            }
            Err(e) => {
                self.ui.status = format!("Source audio output failed: {e}");
                self.source_playback.clock.audio_retry_at = now + AUDIO_RETRY_S;
            }
        }
    }

    /// Advance Source audition playback while playing; stop on a missing or unavailable item or a failure, and re-anchor when the Source playhead is moved
    /// externally.
    pub(crate) fn advance_source_playback(&mut self, ctx: &egui::Context) {
        if !self.source_playback.clock.playing {
            return;
        }
        let item = self.source_playback.item;
        let Some(view) = item.filter(|i| Some(*i) == self.session.state.source_item).and_then(|i| source_view(&self.session, i)) else {
            self.stop_source();
            return;
        };
        let error = self.source_playback.failure.lock().unwrap_or_else(std::sync::PoisonError::into_inner).take();
        if let Some(error) = error {
            self.stop_source();
            self.ui.status = error;
            return;
        }
        let now = self.now();
        let time = self.session.state.source_playhead;
        if time != self.source_playback.shown {
            self.source_playback.clock.anchor_tick = time;
            self.source_playback.clock.anchor_time = now;
            self.source_playback.clock.audio_seen = (0, now);
            self.start_source_audio(now);
        }
        if !self.source_playback.clock.audio_clock && self.source_playback.clock.audio_retry_at > 0.0 && now >= self.source_playback.clock.audio_retry_at {
            // The output failed mid-play: open it again where the wall clock got to, so a
            // recovering device brings the sound back without a pause/play.
            self.source_playback.clock.audio_retry_at = now + AUDIO_RETRY_S;
            self.source_playback.clock.anchor_tick = time;
            self.source_playback.clock.anchor_time = now;
            self.source_playback.clock.audio_seen = (0, now);
            self.start_source_audio(now);
        }
        if self.source_playback.clock.audio_clock
            && let Some(audio) = self.audio.as_mut()
        {
            audio.recover();
        }
        let clock = &mut self.source_playback.clock;
        if clock.anchor_time < 0.0 {
            clock.anchor_time = now;
            clock.audio_seen = (0, now);
        }
        let reading = if clock.audio_clock { self.audio.as_ref().and_then(|a| a.played_frames().map(|n| (n, a.sample_rate()))) } else { None };
        if let Some((frames, _)) = reading
            && frames != clock.audio_seen.0
        {
            clock.audio_seen = (frames, now);
        }
        if clock.audio_clock && (reading.is_none() || now - clock.audio_seen.1 >= AUDIO_STALL_S) {
            clock.anchor_tick = time;
            clock.anchor_time = now;
            clock.audio_clock = false;
            // A dead stream is reopened on a timer; a stalled one keeps the wall clock (#136).
            if reading.is_none() {
                clock.audio_retry_at = now + AUDIO_RETRY_S;
            }
            if let Some(audio) = self.audio.as_mut() {
                audio.stop();
            }
            self.ui.status = "Source audio output stopped responding: playing without sound (check Settings > Audio Hardware)".into();
        }
        let elapsed = match reading {
            Some((frames, sr)) if clock.audio_clock && sr > 0 => frames as f64 / f64::from(sr),
            _ => (now - clock.anchor_time).max(0.0),
        };
        let next = Tick(clock.anchor_tick.0.saturating_add(Tick::from_seconds_f64(elapsed * clock.speed).0));
        if clock.speed < 0.0 {
            // backward: stops on the first frame (as the Program monitor stops at the start)
            let ended = next <= view.start;
            match self.session.execute("source.setPlayhead", json!({"time": next.max(view.start).0})) {
                Ok(_) => self.source_playback.shown = self.session.state.source_playhead,
                Err(e) => {
                    self.stop_source();
                    self.ui.status = e.to_string();
                    return;
                }
            }
            if ended {
                self.stop_source();
            }
            ctx.request_repaint();
            return;
        }
        let range = view.selected_range();
        let end = clock.stop_at.unwrap_or_else(|| if clock.looping { range.end() } else { view.end }).min(view.end);
        let ended = next >= end;
        if ended && clock.looping {
            let start = self.source_playback.range_start.unwrap_or(range.start).max(view.start);
            if let Err(e) = self.session.execute("source.setPlayhead", json!({"time":start.0})) {
                self.stop_source();
                self.ui.status = e.to_string();
                return;
            }
            let time = self.session.state.source_playhead;
            self.source_playback.shown = time;
            self.source_playback.clock.anchor_tick = time;
            self.source_playback.clock.anchor_time = now;
            self.source_playback.clock.audio_seen = (0, now);
            self.start_source_audio(now);
            ctx.request_repaint();
            return;
        }
        let next = if ended { Tick(end.0.saturating_sub(view.rate.frame_duration().0)).max(view.start) } else { next.max(view.start) };
        match self.session.execute("source.setPlayhead", json!({"time": next.0})) {
            Ok(_) => self.source_playback.shown = self.session.state.source_playhead,
            Err(e) => {
                self.stop_source();
                self.ui.status = e.to_string();
                return;
            }
        }
        if ended {
            self.stop_source();
        }
        ctx.request_repaint();
    }
}