Files
furumi-tui/src/streaming.rs
T

166 lines
4.8 KiB
Rust
Raw Normal View History

2026-07-25 01:23:29 +03:00
use std::fs::File;
use std::io::{self, Read, Seek, SeekFrom};
use std::path::Path;
use std::sync::{Arc, Condvar, Mutex};
#[derive(Debug, Default)]
struct State {
available: u64,
complete: bool,
}
#[derive(Debug, Default)]
struct Shared {
state: Mutex<State>,
changed: Condvar,
}
#[derive(Debug)]
pub struct GrowingFileReader {
file: File,
pos: u64,
shared: Arc<Shared>,
}
#[derive(Debug)]
pub struct GrowingFileWriter {
shared: Arc<Shared>,
}
pub fn growing_file(path: &Path) -> io::Result<(GrowingFileReader, GrowingFileWriter)> {
let file = File::open(path)?;
let shared = Arc::new(Shared::default());
Ok((
GrowingFileReader {
file,
pos: 0,
shared: Arc::clone(&shared),
},
GrowingFileWriter { shared },
))
}
impl GrowingFileWriter {
pub fn add_available(&self, bytes: u64) {
let mut state = self
.shared
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
state.available = state.available.saturating_add(bytes);
self.shared.changed.notify_all();
}
pub fn finish(&self) {
let mut state = self
.shared
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
state.complete = true;
self.shared.changed.notify_all();
}
}
impl Drop for GrowingFileWriter {
fn drop(&mut self) {
self.finish();
}
}
impl Read for GrowingFileReader {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if buf.is_empty() {
return Ok(0);
}
loop {
let mut state = self
.shared
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
while self.pos >= state.available && !state.complete {
state = self
.shared
.changed
.wait(state)
.unwrap_or_else(std::sync::PoisonError::into_inner);
}
if self.pos >= state.available && state.complete {
return Ok(0);
}
let readable = (state.available - self.pos).min(buf.len() as u64) as usize;
drop(state);
let read = self.file.read(&mut buf[..readable])?;
self.pos = self.pos.saturating_add(read as u64);
if read > 0 {
return Ok(read);
}
}
}
}
impl Seek for GrowingFileReader {
2026-08-14 11:42:54 +01:00
fn seek(&mut self, position: SeekFrom) -> io::Result<u64> {
// Random access beyond the downloaded prefix is intentionally not
// exposed, but decoders may inspect and rewind the available header.
let available = self
.shared
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.available;
let target = match position {
SeekFrom::Start(position) => i128::from(position),
SeekFrom::Current(offset) => i128::from(self.pos) + i128::from(offset),
SeekFrom::End(offset) => i128::from(available) + i128::from(offset),
};
if target < 0 || target > i128::from(available) {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"cannot seek outside the downloaded audio prefix",
));
}
let target = target as u64;
self.file.seek(SeekFrom::Start(target))?;
self.pos = target;
Ok(target)
2026-07-25 01:23:29 +03:00
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::{Read, Write};
#[test]
fn growing_reader_reads_available_bytes_then_eof() {
let path =
std::env::temp_dir().join(format!("furumi-growing-reader-{}", std::process::id()));
let _ = std::fs::remove_file(&path);
std::fs::File::create(&path).unwrap();
let (mut reader, writer) = growing_file(&path).unwrap();
let mut output = std::fs::OpenOptions::new().write(true).open(&path).unwrap();
output.write_all(b"fur").unwrap();
writer.add_available(3);
let mut first = [0u8; 3];
reader.read_exact(&mut first).unwrap();
assert_eq!(&first, b"fur");
2026-08-14 11:42:54 +01:00
reader.seek(SeekFrom::Start(0)).unwrap();
let mut rewind = [0u8; 3];
reader.read_exact(&mut rewind).unwrap();
assert_eq!(&rewind, b"fur");
assert!(reader.seek(SeekFrom::Start(4)).is_err());
2026-07-25 01:23:29 +03:00
output.write_all(b"umi").unwrap();
writer.add_available(3);
writer.finish();
let mut rest = Vec::new();
reader.read_to_end(&mut rest).unwrap();
assert_eq!(&rest, b"umi");
drop(output);
let _ = std::fs::remove_file(&path);
}
}