Skip to content

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

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

#![allow(dead_code)]

use std::collections::VecDeque;

use crate::audio_contract::{
    self, DIRECT_CAPTURE_CHANNELS, DIRECT_CAPTURE_MAX_SAMPLES, DIRECT_CAPTURE_SAMPLE_RATE,
};
pub struct CapturedFrame {
    pub samples: Vec<f32>,
    pub sample_rate: u32,
    pub channels: u32,
    pub timestamp_us: i64,
}

pub struct DirectReadMeta {
    pub sample_rate: u32,
    pub channels: u32,
    pub timestamp_us: i64,
}

pub struct DirectAudioBuffer {
    samples: VecDeque<f32>,
    queue_start_us: i64,
    sample_rate: u32,
    channels: u32,
}

impl DirectAudioBuffer {
    pub fn new(sample_rate: u32, channels: u32) -> Self {
        Self {
            samples: VecDeque::with_capacity(DIRECT_CAPTURE_MAX_SAMPLES),
            queue_start_us: 0,
            sample_rate: sample_rate.max(1),
            channels: channels.max(1),
        }
    }

    pub fn default_format() -> Self {
        Self::new(DIRECT_CAPTURE_SAMPLE_RATE, DIRECT_CAPTURE_CHANNELS)
    }

    pub fn set_format(&mut self, sample_rate: u32, channels: u32) {
        let sample_rate = sample_rate.max(1);
        let channels = channels.max(1);
        if self.sample_rate != sample_rate || self.channels != channels {
            self.clear();
        }
        self.sample_rate = sample_rate;
        self.channels = channels;
    }

    pub fn clear(&mut self) {
        self.samples.clear();
        self.queue_start_us = 0;
    }

    pub fn push(&mut self, input: &[f32], end_timestamp_us: i64) {
        let whole = audio_contract::whole_frame_sample_count(input.len(), self.channels);
        if whole == 0 {
            return;
        }
        let mut frame = &input[..whole];
        if frame.len() > DIRECT_CAPTURE_MAX_SAMPLES {
            let keep =
                audio_contract::whole_frame_sample_count(DIRECT_CAPTURE_MAX_SAMPLES, self.channels);
            frame = &frame[frame.len() - keep..];
            self.clear();
        }
        if self.samples.is_empty() {
            let duration_us = audio_contract::duration_us_for_sample_count(
                frame.len(),
                self.sample_rate,
                self.channels,
            );
            self.queue_start_us = end_timestamp_us.saturating_sub(duration_us);
        }
        self.drop_for_incoming(frame.len());
        self.samples.extend(frame.iter().copied());
    }

    pub fn read(&mut self) -> Option<CapturedFrame> {
        let mut out = Vec::with_capacity(audio_contract::DIRECT_CAPTURE_MAX_READ_SAMPLES);
        let meta = self.read_into(&mut out)?;
        Some(CapturedFrame {
            samples: out,
            sample_rate: meta.sample_rate,
            channels: meta.channels,
            timestamp_us: meta.timestamp_us,
        })
    }

    pub fn read_into(&mut self, out: &mut Vec<f32>) -> Option<DirectReadMeta> {
        assert!(self.sample_rate >= 1);
        assert!(self.channels >= 1);
        out.clear();
        if self.samples.is_empty() {
            return None;
        }
        let take = audio_contract::bounded_direct_read_sample_count_for_format(
            self.samples.len(),
            self.sample_rate,
            self.channels,
        );
        if take == 0 {
            return None;
        }
        assert!(take <= self.samples.len());
        assert!(take.is_multiple_of(self.channels as usize));
        let timestamp_us = self.queue_start_us.max(0);
        let (front, back) = self.samples.as_slices();
        let front_take = take.min(front.len());
        out.extend_from_slice(&front[..front_take]);
        out.extend_from_slice(&back[..take - front_take]);
        self.samples.drain(..take);
        self.queue_start_us =
            self.queue_start_us
                .saturating_add(audio_contract::duration_us_for_sample_count(
                    take,
                    self.sample_rate,
                    self.channels,
                ));
        if self.samples.is_empty() {
            self.queue_start_us = 0;
        }
        Some(DirectReadMeta {
            sample_rate: self.sample_rate,
            channels: self.channels,
            timestamp_us,
        })
    }

    fn drop_for_incoming(&mut self, incoming: usize) {
        assert!(incoming >= 1);
        assert!(incoming <= DIRECT_CAPTURE_MAX_SAMPLES);
        assert!(self.channels >= 1);
        let total = self.samples.len() + incoming;
        if total <= DIRECT_CAPTURE_MAX_SAMPLES {
            return;
        }
        let overflow = total - DIRECT_CAPTURE_MAX_SAMPLES;
        let channels = self.channels as usize;
        let remainder = overflow % channels;
        let drop = if remainder == 0 {
            overflow
        } else {
            overflow + (channels - remainder)
        }
        .min(self.samples.len());
        self.samples.drain(..drop);
        self.queue_start_us =
            self.queue_start_us
                .saturating_add(audio_contract::duration_us_for_sample_count(
                    drop,
                    self.sample_rate,
                    self.channels,
                ));
    }
}