Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
6.1 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use std::collections::VecDeque;

#[derive(Debug, Clone, PartialEq)]
pub struct MixerPacket {
    pub timestamp_us: i64,
    pub samples: Vec<f32>,
}

pub fn timestamp_delta_to_frames(
    base_timestamp_us: i64,
    timestamp_us: i64,
    sample_rate: u32,
) -> usize {
    if sample_rate == 0 {
        return 0;
    }
    let delta_us = timestamp_us.saturating_sub(base_timestamp_us).max(0) as u128;
    ((delta_us * u128::from(sample_rate)) / 1_000_000) as usize
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SessionCandidate {
    pub root_pid: u32,
    pub active: bool,
}

pub fn select_capture_pids(candidates: &[SessionCandidate], recently_active: &[u32]) -> Vec<u32> {
    let mut selected: Vec<u32> = candidates
        .iter()
        .filter(|candidate| candidate.root_pid != 0)
        .filter(|candidate| candidate.active || recently_active.contains(&candidate.root_pid))
        .map(|candidate| candidate.root_pid)
        .collect();
    selected.sort_unstable();
    selected.dedup();
    selected
}

pub const SESSION_INACTIVE_GRACE_US: i64 = 5_000_000;

#[derive(Debug, Default)]
pub struct SessionActivity {
    last_active_us: Vec<(u32, i64)>,
}

impl SessionActivity {
    pub fn clear(&mut self) {
        self.last_active_us.clear();
    }

    pub fn select(&mut self, candidates: &[SessionCandidate], now_us: i64) -> Vec<u32> {
        for candidate in candidates
            .iter()
            .filter(|candidate| candidate.active && candidate.root_pid != 0)
        {
            match self
                .last_active_us
                .iter_mut()
                .find(|(pid, _)| *pid == candidate.root_pid)
            {
                Some(entry) => entry.1 = now_us,
                None => self.last_active_us.push((candidate.root_pid, now_us)),
            }
        }
        self.last_active_us
            .retain(|(_, at_us)| now_us.saturating_sub(*at_us) < SESSION_INACTIVE_GRACE_US);
        let recently_active: Vec<u32> = self.last_active_us.iter().map(|(pid, _)| *pid).collect();
        select_capture_pids(candidates, &recently_active)
    }
}

pub const MIX_TIMELINE_MAX_AHEAD_US: i64 = 500_000;
pub const MIX_TIMELINE_IDLE_RESET_US: i64 = 1_000_000;

#[derive(Debug, Default)]
pub struct MixTimeline {
    origin_us: Option<i64>,
    next_frame: i64,
    last_input_us: i64,
    acc: VecDeque<f32>,
}

fn frame_position(origin_us: i64, timestamp_us: i64, sample_rate: u32) -> i64 {
    if timestamp_us >= origin_us {
        timestamp_delta_to_frames(origin_us, timestamp_us, sample_rate) as i64
    } else {
        -(timestamp_delta_to_frames(timestamp_us, origin_us, sample_rate) as i64)
    }
}

fn frame_timestamp_us(origin_us: i64, frame: i64, sample_rate: u32) -> i64 {
    origin_us
        .saturating_add(((i128::from(frame) * 1_000_000) / i128::from(sample_rate.max(1))) as i64)
}

fn max_ahead_frames(sample_rate: u32) -> i64 {
    timestamp_delta_to_frames(0, MIX_TIMELINE_MAX_AHEAD_US, sample_rate) as i64
}

impl MixTimeline {
    fn reset(&mut self) {
        self.origin_us = None;
        self.next_frame = 0;
        self.acc.clear();
    }

    pub fn push(&mut self, packet: MixerPacket, sample_rate: u32, channels: usize) {
        if sample_rate == 0 || channels == 0 {
            return;
        }
        let packet_frames = (packet.samples.len() / channels) as i64;
        if packet_frames == 0 {
            return;
        }
        let origin_us = *self.origin_us.get_or_insert(packet.timestamp_us);
        self.last_input_us = self.last_input_us.max(packet.timestamp_us);
        let start_frame = frame_position(origin_us, packet.timestamp_us, sample_rate);
        let skip_frames = (self.next_frame - start_frame).max(0);
        if skip_frames >= packet_frames {
            return;
        }
        let offset_frames = (start_frame + skip_frames) - self.next_frame;
        let limit_frames = max_ahead_frames(sample_rate);
        if offset_frames >= limit_frames {
            return;
        }
        let copy_frames = (packet_frames - skip_frames).min(limit_frames - offset_frames);
        let offset = offset_frames as usize * channels;
        let needed = offset + copy_frames as usize * channels;
        if self.acc.len() < needed {
            self.acc.resize(needed, 0.0);
        }
        let source_start = skip_frames as usize * channels;
        let source = &packet.samples[source_start..source_start + copy_frames as usize * channels];
        for (index, sample) in source.iter().copied().enumerate() {
            self.acc[offset + index] += sample;
        }
    }

    pub fn drain_ready(
        &mut self,
        now_us: i64,
        hold_us: i64,
        sample_rate: u32,
        channels: usize,
    ) -> Option<MixerPacket> {
        if sample_rate == 0 || channels == 0 {
            return None;
        }
        let origin_us = self.origin_us?;
        if now_us.saturating_sub(self.last_input_us) > MIX_TIMELINE_IDLE_RESET_US {
            self.reset();
            return None;
        }
        let end_frame = frame_position(origin_us, now_us.saturating_sub(hold_us), sample_rate);
        if end_frame <= self.next_frame {
            return None;
        }
        let limit_frames = max_ahead_frames(sample_rate);
        if end_frame - self.next_frame > limit_frames {
            let dropped_frames = end_frame - limit_frames - self.next_frame;
            let dropped_samples = (dropped_frames as usize * channels).min(self.acc.len());
            self.acc.drain(..dropped_samples);
            self.next_frame += dropped_frames;
        }
        let frames = (end_frame - self.next_frame) as usize;
        let sample_count = frames * channels;
        let available = sample_count.min(self.acc.len());
        let mut samples: Vec<f32> = self
            .acc
            .drain(..available)
            .map(|sample| sample.clamp(-1.0, 1.0))
            .collect();
        samples.resize(sample_count, 0.0);
        let timestamp_us = frame_timestamp_us(origin_us, self.next_frame, sample_rate);
        self.next_frame = end_frame;
        Some(MixerPacket {
            timestamp_us,
            samples,
        })
    }
}