feat #14740: play back calls
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,313 @@
|
||||
//! Mixes the two 16 kHz mono tracks of a call into one mono track for
|
||||
//! playback.
|
||||
//!
|
||||
//! The tracks are summed at full level and passed through a soft clipper,
|
||||
//! so a passage where only one side speaks keeps its original loudness
|
||||
//! while both sides speaking loudly at once never wraps around or clips
|
||||
//! hard. [`mix_wavs`] streams both files in chunks, so even a long call
|
||||
//! never sits in memory.
|
||||
|
||||
use std::fs::{self, File};
|
||||
use std::io::{self, BufReader, ErrorKind};
|
||||
use std::path::Path;
|
||||
|
||||
use hound::{SampleFormat, WavReader, WavSpec, WavWriter};
|
||||
|
||||
use super::wav::SAMPLE_RATE;
|
||||
|
||||
/// Samples read per track and step in [`mix_wavs`] (about one second).
|
||||
const CHUNK_SAMPLES: usize = 16_384;
|
||||
/// Up to this level (half of full scale) the sum passes unchanged; above,
|
||||
/// the soft clipper compresses it towards full scale.
|
||||
const KNEE: f32 = 0.5;
|
||||
|
||||
/// The format of both tracks and of the mixed file.
|
||||
fn spec() -> WavSpec {
|
||||
WavSpec {
|
||||
channels: 1,
|
||||
sample_rate: SAMPLE_RATE,
|
||||
bits_per_sample: 16,
|
||||
sample_format: SampleFormat::Int,
|
||||
}
|
||||
}
|
||||
|
||||
/// Mixes `a` and `b` sample by sample and appends the result to `out`.
|
||||
/// The output is as long as the longer input; the shorter one counts as
|
||||
/// silence after its end. Never clips hard: see [`soft_clip`].
|
||||
pub fn mix_samples(a: &[i16], b: &[i16], out: &mut Vec<i16>) {
|
||||
let len = a.len().max(b.len());
|
||||
out.reserve(len);
|
||||
for i in 0..len {
|
||||
let sum = to_f32(a.get(i).copied().unwrap_or(0)) + to_f32(b.get(i).copied().unwrap_or(0));
|
||||
out.push(to_i16(soft_clip(sum)));
|
||||
}
|
||||
}
|
||||
|
||||
fn to_f32(sample: i16) -> f32 {
|
||||
sample as f32 / i16::MAX as f32
|
||||
}
|
||||
|
||||
fn to_i16(sample: f32) -> i16 {
|
||||
(sample.clamp(-1.0, 1.0) * i16::MAX as f32).round() as i16
|
||||
}
|
||||
|
||||
/// Linear up to [`KNEE`]; above, `tanh` bends the level smoothly (same
|
||||
/// slope at the knee) towards, but never beyond, full scale.
|
||||
fn soft_clip(x: f32) -> f32 {
|
||||
let level = x.abs();
|
||||
if level <= KNEE {
|
||||
return x;
|
||||
}
|
||||
let room = 1.0 - KNEE;
|
||||
x.signum() * (KNEE + room * ((level - KNEE) / room).tanh())
|
||||
}
|
||||
|
||||
/// One source track; `None` if the file is missing or holds no audio.
|
||||
type Track = Option<hound::WavIntoSamples<BufReader<File>, i16>>;
|
||||
|
||||
/// Opens a track for [`mix_wavs`]. A missing or header-only file counts as
|
||||
/// no track; anything else that is not 16 kHz mono 16-bit PCM is an error.
|
||||
fn open_track(path: &Path) -> io::Result<Track> {
|
||||
if path.as_os_str().is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let reader = match WavReader::open(path) {
|
||||
Ok(reader) => reader,
|
||||
Err(hound::Error::IoError(e)) if e.kind() == ErrorKind::NotFound => return Ok(None),
|
||||
Err(e) => return Err(invalid(path, e)),
|
||||
};
|
||||
if reader.spec() != spec() {
|
||||
return Err(invalid(path, "not 16 kHz mono 16-bit PCM"));
|
||||
}
|
||||
if reader.len() == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some(reader.into_samples()))
|
||||
}
|
||||
|
||||
fn invalid(path: &Path, e: impl std::fmt::Display) -> io::Error {
|
||||
io::Error::new(ErrorKind::InvalidData, format!("{}: {e}", path.display()))
|
||||
}
|
||||
|
||||
/// Reads up to [`CHUNK_SAMPLES`] samples of `track` into `buf` (cleared
|
||||
/// first).
|
||||
fn read_chunk(track: &mut Track, buf: &mut Vec<i16>) -> io::Result<()> {
|
||||
buf.clear();
|
||||
let Some(samples) = track else {
|
||||
return Ok(());
|
||||
};
|
||||
for sample in samples.take(CHUNK_SAMPLES) {
|
||||
buf.push(sample.map_err(|e| io::Error::new(ErrorKind::InvalidData, e))?);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Mixes the WAV tracks at `a` and `b` (16 kHz mono 16-bit PCM, as written
|
||||
/// by [`super::TrackWriter`]) into a new WAV at `dest` and returns its
|
||||
/// length in samples. A missing or empty track is left out; with neither
|
||||
/// track holding audio nothing is written and the error is
|
||||
/// [`ErrorKind::NotFound`].
|
||||
///
|
||||
/// Writes `dest` with a `.part` suffix first and renames it at the end, so
|
||||
/// `dest` is never a half-written file.
|
||||
pub fn mix_wavs(a: &Path, b: &Path, dest: &Path) -> io::Result<u64> {
|
||||
let mut track_a = open_track(a)?;
|
||||
let mut track_b = open_track(b)?;
|
||||
if track_a.is_none() && track_b.is_none() {
|
||||
return Err(io::Error::new(
|
||||
ErrorKind::NotFound,
|
||||
"no audio in either track",
|
||||
));
|
||||
}
|
||||
|
||||
let mut part = dest.as_os_str().to_owned();
|
||||
part.push(".part");
|
||||
let part = Path::new(&part);
|
||||
let result = write_mix(&mut track_a, &mut track_b, part);
|
||||
match result {
|
||||
Ok(samples) => {
|
||||
fs::rename(part, dest)?;
|
||||
Ok(samples)
|
||||
}
|
||||
Err(e) => {
|
||||
let _ = fs::remove_file(part);
|
||||
Err(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn write_mix(a: &mut Track, b: &mut Track, path: &Path) -> io::Result<u64> {
|
||||
let mut writer = WavWriter::create(path, spec()).map_err(hound_to_io)?;
|
||||
let (mut buf_a, mut buf_b, mut mixed) = (Vec::new(), Vec::new(), Vec::new());
|
||||
let mut written = 0u64;
|
||||
loop {
|
||||
read_chunk(a, &mut buf_a)?;
|
||||
read_chunk(b, &mut buf_b)?;
|
||||
if buf_a.is_empty() && buf_b.is_empty() {
|
||||
break;
|
||||
}
|
||||
mixed.clear();
|
||||
mix_samples(&buf_a, &buf_b, &mut mixed);
|
||||
for &sample in &mixed {
|
||||
writer.write_sample(sample).map_err(hound_to_io)?;
|
||||
}
|
||||
written += mixed.len() as u64;
|
||||
}
|
||||
writer.finalize().map_err(hound_to_io)?;
|
||||
Ok(written)
|
||||
}
|
||||
|
||||
fn hound_to_io(e: hound::Error) -> io::Error {
|
||||
match e {
|
||||
hound::Error::IoError(e) => e,
|
||||
other => io::Error::other(other),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::audio::TrackWriter;
|
||||
|
||||
fn mix(a: &[i16], b: &[i16]) -> Vec<i16> {
|
||||
let mut out = Vec::new();
|
||||
mix_samples(a, b, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn quiet_samples_of_equal_length_are_summed() {
|
||||
assert_eq!(mix(&[100, -200, 0], &[50, 300, -7]), vec![150, 100, -7]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_longer_track_continues_alone() {
|
||||
assert_eq!(mix(&[1, 2], &[10, 20, 30, 40]), vec![11, 22, 30, 40]);
|
||||
assert_eq!(mix(&[10, 20, 30], &[1]), vec![11, 20, 30]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_empty_track_leaves_the_other_unchanged_up_to_the_knee() {
|
||||
let half = (KNEE * i16::MAX as f32) as i16;
|
||||
let track = [0, 1234, -1234, half, -half, i16::MIN + 1];
|
||||
let mut expected = track.to_vec();
|
||||
// Beyond the knee even a single track is compressed (but stays
|
||||
// loud and keeps its sign).
|
||||
let last = mix(&[], &track)[5];
|
||||
expected[5] = last;
|
||||
assert!(last < -28_000, "{last}");
|
||||
assert_eq!(mix(&[], &track), expected);
|
||||
assert_eq!(mix(&track, &[]), expected);
|
||||
assert_eq!(mix(&[], &[]), Vec::<i16>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_scale_on_both_sides_stays_within_full_scale() {
|
||||
let out = mix(
|
||||
&[i16::MAX, i16::MIN, i16::MAX],
|
||||
&[i16::MAX, i16::MIN, i16::MIN],
|
||||
);
|
||||
// Loud, with the right sign, and softly short of full scale.
|
||||
assert!(out[0] > 30_000 && out[0] < i16::MAX, "{}", out[0]);
|
||||
assert!(out[1] < -30_000 && out[1] > -i16::MAX, "{}", out[1]);
|
||||
// Opposite full-scale samples cancel instead of wrapping around.
|
||||
assert!(out[2].abs() <= 1, "{}", out[2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_soft_clip_is_monotonic_and_bounded() {
|
||||
let mut last = -1.0f32;
|
||||
for step in -400..=400 {
|
||||
let x = step as f32 / 200.0; // -2.0 ..= 2.0
|
||||
let y = soft_clip(x);
|
||||
assert!(y >= last, "not monotonic at {x}");
|
||||
assert!(y.abs() < 1.0, "{x} -> {y}");
|
||||
last = y;
|
||||
}
|
||||
}
|
||||
|
||||
fn write_track(path: &Path, samples: &[f32]) {
|
||||
let mut writer = TrackWriter::create(path).unwrap();
|
||||
writer.write(samples).unwrap();
|
||||
writer.finalize().unwrap();
|
||||
}
|
||||
|
||||
fn read(path: &Path) -> Vec<i16> {
|
||||
WavReader::open(path)
|
||||
.unwrap()
|
||||
.into_samples::<i16>()
|
||||
.map(Result::unwrap)
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_files_are_mixed_across_several_chunks() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (a, b, dest) = (
|
||||
dir.path().join("a.wav"),
|
||||
dir.path().join("b.wav"),
|
||||
dir.path().join("m.wav"),
|
||||
);
|
||||
let long = CHUNK_SAMPLES * 2 + 100;
|
||||
write_track(&a, &vec![0.1; long]);
|
||||
write_track(&b, &vec![0.2; CHUNK_SAMPLES + 7]);
|
||||
|
||||
assert_eq!(mix_wavs(&a, &b, &dest).unwrap(), long as u64);
|
||||
|
||||
let mixed = read(&dest);
|
||||
assert_eq!(mixed.len(), long);
|
||||
let both = to_i16(0.1) + to_i16(0.2);
|
||||
assert!((mixed[0] - both).abs() <= 1);
|
||||
assert!((mixed[CHUNK_SAMPLES + 6] - both).abs() <= 1);
|
||||
assert_eq!(mixed[CHUNK_SAMPLES + 7], to_i16(0.1));
|
||||
assert_eq!(mixed[long - 1], to_i16(0.1));
|
||||
assert!(!dir.path().join("m.wav.part").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_or_empty_file_is_left_out() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (a, empty, dest) = (
|
||||
dir.path().join("a.wav"),
|
||||
dir.path().join("e.wav"),
|
||||
dir.path().join("m.wav"),
|
||||
);
|
||||
write_track(&a, &[0.25; 10]);
|
||||
write_track(&empty, &[]);
|
||||
|
||||
assert_eq!(
|
||||
mix_wavs(&dir.path().join("gone.wav"), &a, &dest).unwrap(),
|
||||
10
|
||||
);
|
||||
assert_eq!(read(&dest), vec![to_i16(0.25); 10]);
|
||||
assert_eq!(mix_wavs(&a, &empty, &dest).unwrap(), 10);
|
||||
assert_eq!(read(&dest), vec![to_i16(0.25); 10]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_audio_in_either_file_nothing_is_written() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (empty, dest) = (dir.path().join("e.wav"), dir.path().join("m.wav"));
|
||||
write_track(&empty, &[]);
|
||||
|
||||
let err = mix_wavs(&empty, &dir.path().join("gone.wav"), &dest).unwrap_err();
|
||||
assert_eq!(err.kind(), ErrorKind::NotFound);
|
||||
assert!(!dest.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_file_that_is_not_a_track_is_an_error() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (a, junk, dest) = (
|
||||
dir.path().join("a.wav"),
|
||||
dir.path().join("j.wav"),
|
||||
dir.path().join("m.wav"),
|
||||
);
|
||||
write_track(&a, &[0.25; 10]);
|
||||
fs::write(&junk, b"not a wav file at all").unwrap();
|
||||
|
||||
let err = mix_wavs(&a, &junk, &dest).unwrap_err();
|
||||
assert_eq!(err.kind(), ErrorKind::InvalidData);
|
||||
assert!(!dest.exists());
|
||||
}
|
||||
}
|
||||
@@ -11,10 +11,12 @@ mod conditioner;
|
||||
mod flac;
|
||||
mod gap;
|
||||
mod level;
|
||||
mod mix;
|
||||
mod wav;
|
||||
|
||||
pub use conditioner::Conditioner;
|
||||
pub use flac::encode_flac;
|
||||
pub use gap::GapFiller;
|
||||
pub use level::rms_level;
|
||||
pub use wav::{repair_wav, TrackWriter};
|
||||
pub use mix::{mix_samples, mix_wavs};
|
||||
pub use wav::{repair_wav, TrackWriter, SAMPLE_RATE};
|
||||
|
||||
@@ -172,6 +172,10 @@ pub struct CallDetail {
|
||||
/// Whether the transcript is being uploaded right now. Set by the app,
|
||||
/// which tracks its uploads; `false` from [`CallDetail::of`].
|
||||
pub uploading: bool,
|
||||
/// Whether the call's audio is still on disk to be played
|
||||
/// ([`crate::playback::audio_available`]). Set by the app; `false` from
|
||||
/// [`CallDetail::of`], which does not look at the files.
|
||||
pub audio_available: bool,
|
||||
}
|
||||
|
||||
impl CallDetail {
|
||||
@@ -209,6 +213,7 @@ impl CallDetail {
|
||||
segments,
|
||||
merges: merge_views(merges, &speaker_names),
|
||||
uploading: false,
|
||||
audio_available: false,
|
||||
speaker_names,
|
||||
}
|
||||
}
|
||||
@@ -646,6 +651,7 @@ mod tests {
|
||||
"into_label": "Sprecher 1",
|
||||
}],
|
||||
"uploading": false,
|
||||
"audio_available": false,
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -14,6 +14,7 @@ pub mod http;
|
||||
pub mod merge;
|
||||
pub mod model;
|
||||
pub mod pipeline;
|
||||
pub mod playback;
|
||||
pub mod recorder;
|
||||
pub mod retention;
|
||||
pub mod secrets;
|
||||
|
||||
@@ -0,0 +1,343 @@
|
||||
//! Playback of a call in the detail view while its audio is still on disk:
|
||||
//! both tracks are mixed into one cached mono WAV
|
||||
//! (`<playback dir>/<id>.wav`), which the UI plays through the webview's
|
||||
//! asset protocol. The cache is rebuilt only when a track is newer than it,
|
||||
//! and removed with the call's audio.
|
||||
|
||||
use std::fs;
|
||||
use std::io::{self, ErrorKind};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::SystemTime;
|
||||
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::audio::{mix_wavs, SAMPLE_RATE};
|
||||
use crate::model::{Call, CallId, CallStatus};
|
||||
|
||||
/// The call's audio was deleted (retention, or the files are gone).
|
||||
pub const AUDIO_GONE: &str = "Audio nicht mehr vorhanden";
|
||||
pub const RECORDING: &str = "Das Gespräch wird gerade aufgenommen";
|
||||
pub const PROCESSING: &str = "Das Gespräch wird gerade verarbeitet – Wiedergabe danach möglich";
|
||||
|
||||
/// A WAV file of this size or less holds no audio (canonical header only).
|
||||
const HEADER_LEN: u64 = 44;
|
||||
|
||||
/// What the UI needs to play a call: the mixed file (turned into an asset
|
||||
/// URL by the UI) and its length.
|
||||
#[derive(Serialize, Clone, Debug, PartialEq)]
|
||||
pub struct PlaybackInfo {
|
||||
pub path: PathBuf,
|
||||
pub duration_secs: f64,
|
||||
}
|
||||
|
||||
/// Why `call` cannot be played, if it cannot: its tracks are still being
|
||||
/// written (recording) or read for transcription (processing), or its
|
||||
/// audio was deleted.
|
||||
pub fn refusal(call: &Call) -> Option<&'static str> {
|
||||
match call.status {
|
||||
CallStatus::Recording => Some(RECORDING),
|
||||
CallStatus::Processing => Some(PROCESSING),
|
||||
_ if call.audio_deleted => Some(AUDIO_GONE),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether `call` still has audio to play: not deleted, and at least one
|
||||
/// track holds more than a bare header.
|
||||
pub fn audio_available(call: &Call) -> bool {
|
||||
!call.audio_deleted
|
||||
&& [&call.mic_path, &call.out_path]
|
||||
.iter()
|
||||
.any(|path| fs::metadata(path).is_ok_and(|m| m.len() > HEADER_LEN))
|
||||
}
|
||||
|
||||
/// Whether a cached mix last written at `cache` can be reused for tracks
|
||||
/// last written at `sources` (`None`: that track does not exist). It can if
|
||||
/// it exists and is newer than every existing track; with no track left
|
||||
/// there is nothing it could still stand for.
|
||||
pub fn is_fresh(cache: Option<SystemTime>, sources: &[Option<SystemTime>]) -> bool {
|
||||
let Some(cache) = cache else {
|
||||
return false;
|
||||
};
|
||||
let mut any = false;
|
||||
for source in sources.iter().flatten() {
|
||||
if *source >= cache {
|
||||
return false;
|
||||
}
|
||||
any = true;
|
||||
}
|
||||
any
|
||||
}
|
||||
|
||||
/// Where call `id`'s mix is cached in the playback directory `dir`.
|
||||
pub fn cache_path(dir: &Path, id: CallId) -> PathBuf {
|
||||
dir.join(format!("{id}.wav"))
|
||||
}
|
||||
|
||||
/// Returns call `call`'s mix in the playback directory `dir`, building it
|
||||
/// first unless a fresh one is cached ([`is_fresh`]). Refused (see
|
||||
/// [`refusal`]) while the call records or is processed and once its audio
|
||||
/// is gone; a cached mix of a call whose audio is gone is removed.
|
||||
pub fn prepare(call: &Call, dir: &Path) -> Result<PlaybackInfo, String> {
|
||||
let path = cache_path(dir, call.id);
|
||||
if let Some(msg) = refusal(call) {
|
||||
if msg == AUDIO_GONE {
|
||||
remove_cached(dir, call.id);
|
||||
}
|
||||
return Err(msg.to_string());
|
||||
}
|
||||
let sources = [modified(&call.mic_path), modified(&call.out_path)];
|
||||
if is_fresh(modified(&path), &sources) {
|
||||
match duration_secs(&path) {
|
||||
Ok(duration_secs) => {
|
||||
return Ok(PlaybackInfo {
|
||||
path,
|
||||
duration_secs,
|
||||
})
|
||||
}
|
||||
Err(e) => log::warn!("call {}: rebuilding unreadable playback file: {e}", call.id),
|
||||
}
|
||||
}
|
||||
|
||||
fs::create_dir_all(dir).map_err(|e| format!("Wiedergabe-Ordner fehlt: {e}"))?;
|
||||
match mix_wavs(&call.mic_path, &call.out_path, &path) {
|
||||
Ok(samples) => Ok(PlaybackInfo {
|
||||
path,
|
||||
duration_secs: samples as f64 / SAMPLE_RATE as f64,
|
||||
}),
|
||||
Err(e) if e.kind() == ErrorKind::NotFound => {
|
||||
remove_cached(dir, call.id);
|
||||
Err(AUDIO_GONE.to_string())
|
||||
}
|
||||
Err(e) => Err(format!("Audio konnte nicht vorbereitet werden: {e}")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes call `id`'s cached mix, if any (with the call or its audio).
|
||||
/// Failures are logged: the playback directory is emptied at every start.
|
||||
pub fn remove_cached(dir: &Path, id: CallId) {
|
||||
let path = cache_path(dir, id);
|
||||
match fs::remove_file(&path) {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == ErrorKind::NotFound => {}
|
||||
Err(e) => log::warn!("could not remove {}: {e}", path.display()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes every cached mix (at startup, so customer audio never lingers
|
||||
/// in the cache).
|
||||
pub fn clear_cache(dir: &Path) -> io::Result<()> {
|
||||
match fs::remove_dir_all(dir) {
|
||||
Err(e) if e.kind() == ErrorKind::NotFound => Ok(()),
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
|
||||
fn modified(path: &Path) -> Option<SystemTime> {
|
||||
fs::metadata(path).and_then(|m| m.modified()).ok()
|
||||
}
|
||||
|
||||
fn duration_secs(path: &Path) -> Result<f64, hound::Error> {
|
||||
let reader = hound::WavReader::open(path)?;
|
||||
Ok(reader.duration() as f64 / reader.spec().sample_rate as f64)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::fs::File;
|
||||
use std::time::Duration;
|
||||
|
||||
use chrono::Local;
|
||||
|
||||
use super::*;
|
||||
use crate::audio::TrackWriter;
|
||||
|
||||
fn call(dir: &Path, status: CallStatus) -> Call {
|
||||
Call {
|
||||
id: 7,
|
||||
app: "Microsoft Teams".to_string(),
|
||||
started_at: Local::now(),
|
||||
ended_at: Some(Local::now()),
|
||||
status,
|
||||
interrupted: false,
|
||||
error: None,
|
||||
mic_path: dir.join("7-mic.wav"),
|
||||
out_path: dir.join("7-out.wav"),
|
||||
transcribed_at: None,
|
||||
audio_deleted: false,
|
||||
title: None,
|
||||
crm_transcript_id: None,
|
||||
crm_base_url: None,
|
||||
uploaded_at: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn write_track(path: &Path, samples: &[f32]) {
|
||||
let mut writer = TrackWriter::create(path).unwrap();
|
||||
writer.write(samples).unwrap();
|
||||
writer.finalize().unwrap();
|
||||
}
|
||||
|
||||
/// A call with one second on the mic and half a second on the output.
|
||||
fn recorded_call(dir: &Path, status: CallStatus) -> Call {
|
||||
let call = call(dir, status);
|
||||
write_track(&call.mic_path, &vec![0.1; 16_000]);
|
||||
write_track(&call.out_path, &vec![0.2; 8_000]);
|
||||
call
|
||||
}
|
||||
|
||||
fn set_modified(path: &Path, time: SystemTime) {
|
||||
File::options()
|
||||
.write(true)
|
||||
.open(path)
|
||||
.unwrap()
|
||||
.set_modified(time)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_cache_newer_than_every_track_is_fresh() {
|
||||
let t = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000);
|
||||
let s = Duration::from_secs(1);
|
||||
assert!(is_fresh(Some(t), &[Some(t - s), Some(t - s)]));
|
||||
assert!(is_fresh(Some(t), &[None, Some(t - s)]));
|
||||
assert!(!is_fresh(Some(t), &[Some(t - s), Some(t + s)]));
|
||||
assert!(!is_fresh(Some(t), &[Some(t), Some(t - s)]), "same time");
|
||||
assert!(!is_fresh(None, &[Some(t - s), Some(t - s)]), "no cache");
|
||||
assert!(!is_fresh(Some(t), &[None, None]), "no tracks");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recording_processing_and_deleted_calls_are_refused() {
|
||||
let dir = Path::new("/nonexistent");
|
||||
assert_eq!(refusal(&call(dir, CallStatus::Recording)), Some(RECORDING));
|
||||
assert_eq!(
|
||||
refusal(&call(dir, CallStatus::Processing)),
|
||||
Some(PROCESSING)
|
||||
);
|
||||
let mut deleted = call(dir, CallStatus::Done);
|
||||
deleted.audio_deleted = true;
|
||||
assert_eq!(refusal(&deleted), Some(AUDIO_GONE));
|
||||
for status in [
|
||||
CallStatus::AwaitingDecision,
|
||||
CallStatus::Done,
|
||||
CallStatus::Failed,
|
||||
] {
|
||||
assert_eq!(refusal(&call(dir, status)), None, "{status:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn audio_is_available_while_a_track_holds_audio() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut c = call(dir.path(), CallStatus::Done);
|
||||
assert!(!audio_available(&c), "no files");
|
||||
write_track(&c.out_path, &[]);
|
||||
assert!(!audio_available(&c), "header only");
|
||||
write_track(&c.mic_path, &[0.1; 10]);
|
||||
assert!(audio_available(&c));
|
||||
c.audio_deleted = true;
|
||||
assert!(!audio_available(&c), "deleted by retention");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_mix_is_built_once_and_reused() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let playback = dir.path().join("playback");
|
||||
let c = recorded_call(dir.path(), CallStatus::Done);
|
||||
|
||||
let info = prepare(&c, &playback).unwrap();
|
||||
assert_eq!(info.path, playback.join("7.wav"));
|
||||
assert!((info.duration_secs - 1.0).abs() < 1e-9);
|
||||
|
||||
// Marked as written long ago: a rebuild would show a new time.
|
||||
let old = SystemTime::now() - Duration::from_secs(60);
|
||||
set_modified(&c.mic_path, old - Duration::from_secs(60));
|
||||
set_modified(&c.out_path, old - Duration::from_secs(60));
|
||||
set_modified(&info.path, old);
|
||||
assert_eq!(prepare(&c, &playback).unwrap(), info);
|
||||
assert_eq!(modified(&info.path), Some(old), "reused, not rebuilt");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_mix_is_rebuilt_when_a_track_is_newer() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let playback = dir.path().join("playback");
|
||||
let c = recorded_call(dir.path(), CallStatus::AwaitingDecision);
|
||||
let first = prepare(&c, &playback).unwrap();
|
||||
let old = SystemTime::now() - Duration::from_secs(60);
|
||||
set_modified(&first.path, old);
|
||||
|
||||
// Two seconds now; the file is newer than the cache.
|
||||
write_track(&c.mic_path, &vec![0.1; 32_000]);
|
||||
let second = prepare(&c, &playback).unwrap();
|
||||
assert!((second.duration_secs - 2.0).abs() < 1e-9);
|
||||
assert_ne!(modified(&second.path), Some(old));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_call_with_one_track_plays_that_track() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let c = call(dir.path(), CallStatus::Failed);
|
||||
write_track(&c.out_path, &vec![0.2; 4_000]);
|
||||
let info = prepare(&c, &dir.path().join("playback")).unwrap();
|
||||
assert!((info.duration_secs - 0.25).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_refused_call_builds_nothing() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let playback = dir.path().join("playback");
|
||||
for status in [CallStatus::Recording, CallStatus::Processing] {
|
||||
let c = recorded_call(dir.path(), status);
|
||||
assert!(prepare(&c, &playback).is_err());
|
||||
assert!(!cache_path(&playback, c.id).exists());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deleted_audio_removes_the_cached_mix() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let playback = dir.path().join("playback");
|
||||
let mut c = recorded_call(dir.path(), CallStatus::Done);
|
||||
let info = prepare(&c, &playback).unwrap();
|
||||
|
||||
// Retention deleted the audio.
|
||||
fs::remove_file(&c.mic_path).unwrap();
|
||||
fs::remove_file(&c.out_path).unwrap();
|
||||
c.audio_deleted = true;
|
||||
assert_eq!(prepare(&c, &playback), Err(AUDIO_GONE.to_string()));
|
||||
assert!(!info.path.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_files_remove_the_cached_mix() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let playback = dir.path().join("playback");
|
||||
let c = recorded_call(dir.path(), CallStatus::Done);
|
||||
let info = prepare(&c, &playback).unwrap();
|
||||
|
||||
fs::remove_file(&c.mic_path).unwrap();
|
||||
fs::remove_file(&c.out_path).unwrap();
|
||||
assert_eq!(prepare(&c, &playback), Err(AUDIO_GONE.to_string()));
|
||||
assert!(!info.path.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_cache_is_removed_per_call_and_cleared_as_a_whole() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let playback = dir.path().join("playback");
|
||||
let c = recorded_call(dir.path(), CallStatus::Done);
|
||||
let info = prepare(&c, &playback).unwrap();
|
||||
fs::write(playback.join("8.wav"), b"other").unwrap();
|
||||
|
||||
remove_cached(&playback, c.id);
|
||||
assert!(!info.path.exists());
|
||||
assert!(playback.join("8.wav").exists());
|
||||
remove_cached(&playback, c.id); // already gone: no error
|
||||
|
||||
clear_cache(&playback).unwrap();
|
||||
assert!(!playback.exists());
|
||||
clear_cache(&playback).unwrap(); // already gone: no error
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user