Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use crate::preparing_audio::PreparingAudioOutputHandle;
use crate::{CompletedAudioHandoff, PreparingPlaybackSnapshot, PreparingPlaybackStopHandle};
use std::sync::{Arc, Mutex, Weak};
use std::time::Instant;
use tokio::sync::watch;
pub(crate) fn presentation_frame(snapshot: &PreparingPlaybackSnapshot, fps: u32) -> u32 {
let requested = (snapshot.playback.playhead_seconds * f64::from(fps)).floor() as u32;
snapshot
.progress
.total_duration
.map_or(requested, |duration| {
requested.min(((duration * f64::from(fps)).ceil() as u32).saturating_sub(1))
})
}
pub(crate) type CompletedTrackIdentity = Vec<[Option<Weak<cap_audio::DecodedAudio>>; 2]>;
pub(crate) fn completed_track_identity(
tracks: &[crate::completed_audio::CompletedAudioSegment],
) -> CompletedTrackIdentity {
tracks
.iter()
.map(|track| {
[
track.mic.as_ref().map(Arc::downgrade),
track.system_audio.as_ref().map(Arc::downgrade),
]
})
.collect()
}
fn same_completed_tracks(left: &CompletedTrackIdentity, right: &CompletedTrackIdentity) -> bool {
left.len() == right.len()
&& left.iter().zip(right).all(|(left, right)| {
left.iter()
.zip(right)
.all(|(left, right)| match (left, right) {
(None, None) => true,
(Some(left), Some(right)) => Weak::ptr_eq(left, right),
_ => false,
})
})
}
#[derive(Default)]
struct HandoffDecision {
revision: u64,
owner: u64,
pending_commands: usize,
stopped: bool,
}
pub(crate) struct HandoffState {
snapshot: Mutex<Option<(PreparingPlaybackSnapshot, Instant, f64)>>,
audio: Mutex<Option<PreparingAudioOutputHandle>>,
identity: Mutex<Option<(CompletedTrackIdentity, Weak<crate::AudioOutput>)>>,
pub(crate) completed_audio: Arc<Mutex<Option<CompletedAudioHandoff>>>,
ready: watch::Sender<Result<bool, String>>,
changed: watch::Sender<u64>,
decision: Mutex<HandoffDecision>,
}
impl HandoffState {
pub(crate) fn new() -> Arc<Self> {
Arc::new(Self {
snapshot: Mutex::new(None),
audio: Mutex::new(None),
identity: Mutex::new(None),
completed_audio: Arc::default(),
ready: watch::channel(Ok(false)).0,
changed: watch::channel(0).0,
decision: Mutex::default(),
})
}
pub(crate) fn publish(&self, snapshot: PreparingPlaybackSnapshot, position: f64) {
let _decision = self
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
*self
.snapshot
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner) =
Some((snapshot, Instant::now(), position));
}
pub(crate) fn set_audio(&self, audio: Option<PreparingAudioOutputHandle>) {
*self
.audio
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner) = audio;
}
pub(crate) fn ready(&self) -> bool {
matches!(*self.ready.borrow(), Ok(true))
}
pub(crate) fn set_completed_identity(
&self,
tracks: &[crate::completed_audio::CompletedAudioSegment],
output: &Arc<crate::AudioOutput>,
) {
*self
.identity
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner) =
Some((completed_track_identity(tracks), Arc::downgrade(output)));
}
pub(crate) fn complete(&self, audio: CompletedAudioHandoff) {
let decision = self
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if !self.ready() && !decision.stopped {
*self
.completed_audio
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner) = Some(audio);
let _ = self.ready.send_replace(Ok(true));
}
}
pub(crate) fn cancel_adoption(&self) {
self.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.stopped = true;
self.changed
.send_modify(|revision| *revision = revision.wrapping_add(1));
}
pub(crate) fn finish(&self, error: Option<String>) {
self.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.stopped = true;
if let Some(error) = error {
let _ = self.ready.send_replace(Err(error));
} else if !self.ready() {
let _ = self
.ready
.send_replace(Err("Preparing playback ended before audio completed".into()));
}
self.changed
.send_modify(|revision| *revision = revision.wrapping_add(1));
}
pub(crate) fn begin_command(self: &Arc<Self>) -> Result<PreparingPlaybackIntent, String> {
let mut decision = self
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if decision.owner != 0 {
return Err("Preparing playback has been adopted".into());
}
if decision.stopped {
return Err("Preparing playback has ended".into());
}
decision.revision = decision.revision.wrapping_add(1).max(1);
decision.pending_commands += 1;
Ok(PreparingPlaybackIntent(self.clone()))
}
pub(crate) fn committed(&self) -> bool {
self.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.owner
!= 0
}
fn snapshot(&self, now: Instant) -> Option<PreparingPlaybackSnapshot> {
let (mut snapshot, sampled, position) = self
.snapshot
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone()?;
if let Some(audio) = self
.audio
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.as_ref()
{
let status = audio.status(now);
snapshot.playback.playhead_seconds = status.playhead_seconds;
snapshot.playback.buffering = status.buffering;
if status.ended || status.error.is_some() {
snapshot.playback.playing = false;
}
if status.error.is_some() {
snapshot.progress.phase = crate::PreparingEditorPhase::Unavailable;
}
} else if snapshot.playback.playing && !snapshot.playback.buffering {
snapshot.playback.playhead_seconds = (position
+ now.saturating_duration_since(sampled).as_secs_f64())
.min(snapshot.progress.playable_until);
}
Some(snapshot)
}
}
pub struct PreparingPlaybackIntent(Arc<HandoffState>);
impl Drop for PreparingPlaybackIntent {
fn drop(&mut self) {
let mut decision = self
.0
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
decision.pending_commands = decision.pending_commands.saturating_sub(1);
self.0
.changed
.send_modify(|revision| *revision = revision.wrapping_add(1));
}
}
struct HandoffOwner {
state: Arc<HandoffState>,
stop: PreparingPlaybackStopHandle,
}
impl Drop for HandoffOwner {
fn drop(&mut self) {
self.stop.cancel();
}
}
#[derive(Clone)]
pub struct PreparingPlaybackHandoff(Arc<HandoffOwner>);
impl PreparingPlaybackHandoff {
pub(crate) fn new(state: Arc<HandoffState>, stop: PreparingPlaybackStopHandle) -> Self {
let stop = stop.with_handoff(&state);
Self(Arc::new(HandoffOwner { state, stop }))
}
pub async fn take_completed_audio(&self) -> Result<CompletedAudioHandoff, String> {
let mut ready = self.0.state.ready.subscribe();
let mut changed = self.0.state.changed.subscribe();
loop {
let status = ready.borrow_and_update().clone()?;
if self
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.stopped
{
return Err("Preparing playback has ended".into());
}
if status {
return self
.0
.state
.completed_audio
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.take()
.ok_or_else(|| "Preparing audio was already transferred".into());
}
tokio::select! {
result = ready.changed() => result.map_err(|_| "Preparing audio owner ended".to_string())?,
result = changed.changed() => result.map_err(|_| "Preparing audio owner ended".to_string())?,
}
}
}
pub fn reserve_command(&self) -> Result<PreparingPlaybackIntent, String> {
self.0.state.begin_command()
}
pub fn snapshot(&self) -> Option<PreparingPlaybackSnapshot> {
self.0.state.snapshot(Instant::now())
}
pub fn prepare_adoption(&self) -> Result<PreparingPlaybackAdoption, String> {
let mut decision = self
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if !self.0.state.ready()
|| decision.stopped
|| decision.owner != 0
|| decision.pending_commands != 0
{
return Err("Preparing playback cannot be adopted".into());
}
decision.revision = decision.revision.wrapping_add(1).max(1);
let revision = decision.revision;
Ok(PreparingPlaybackAdoption {
handoff: self.clone(),
revision,
})
}
pub(crate) fn matches_completed_audio(
&self,
identity: &CompletedTrackIdentity,
output: &Arc<crate::AudioOutput>,
) -> bool {
self.0
.state
.identity
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.as_ref()
.is_some_and(|(expected, expected_output)| {
same_completed_tracks(identity, expected)
&& Weak::ptr_eq(expected_output, &Arc::downgrade(output))
})
}
pub(crate) async fn prepare_when_settled(&self) -> Result<PreparingPlaybackAdoption, String> {
let mut changed = self.0.state.changed.subscribe();
loop {
{
let decision = self
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if decision.stopped || decision.owner != 0 {
return Err("Preparing playback cannot retry adoption".into());
}
if decision.pending_commands == 0 {
break;
}
}
changed
.changed()
.await
.map_err(|_| "Preparing playback ended".to_string())?;
}
self.prepare_adoption()
}
pub fn committed(&self) -> bool {
self.0.state.committed()
}
pub async fn wait_committed(&self) -> bool {
let mut changed = self.0.state.changed.subscribe();
while !self.committed()
&& !self
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.stopped
{
if changed.changed().await.is_err() {
break;
}
}
self.committed()
}
pub fn cancel(&self) {
self.0.stop.cancel();
}
pub async fn stop_and_wait(&self) -> crate::PreparingPlaybackExit {
self.0.stop.stop_and_wait().await
}
}
#[derive(Clone)]
pub struct PreparingPlaybackAdoption {
handoff: PreparingPlaybackHandoff,
revision: u64,
}
impl PreparingPlaybackAdoption {
pub async fn retry(&self) -> Result<Self, String> {
self.handoff.prepare_when_settled().await
}
pub fn snapshot(&self) -> Option<PreparingPlaybackSnapshot> {
let decision = self
.handoff
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if decision.stopped || decision.revision != self.revision {
return None;
}
self.handoff.snapshot()
}
pub fn frame_number(&self, fps: u32) -> Option<u32> {
self.snapshot()
.map(|snapshot| presentation_frame(&snapshot, fps))
}
pub fn invalidated(&self) -> bool {
let decision = self
.handoff
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
decision.stopped || decision.revision != self.revision
}
pub fn try_commit(&self, frame: u32, fps: u32) -> bool {
let mut decision = self
.handoff
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if fps == 0
|| decision.stopped
|| decision.revision != self.revision
|| decision.pending_commands != 0
{
return false;
}
let Some(snapshot) = self.handoff.snapshot() else {
return false;
};
if snapshot.progress.phase == crate::PreparingEditorPhase::Unavailable {
return false;
}
let current = presentation_frame(&snapshot, fps);
if frame < current.saturating_sub(2) || frame > current.saturating_add(1) {
return false;
}
if decision.owner != 0 {
return decision.owner == self.revision;
}
decision.owner = self.revision;
self.handoff.0.state.changed.send_replace(self.revision);
true
}
pub fn is_owner(&self) -> bool {
self.handoff
.0
.state
.decision
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.owner
== self.revision
}
pub fn cancel(&self) {
if self.is_owner() {
self.handoff.cancel();
}
}
pub async fn stop_and_wait(&self) -> Option<crate::PreparingPlaybackExit> {
if self.is_owner() {
Some(self.handoff.stop_and_wait().await)
} else {
None
}
}
}
#[cfg(test)]
#[path = "preparing_handoff_tests.rs"]
mod tests;