Struct WavWriter 

pub struct WavWriter<W: Write + Seek> { /* private fields */ }

Implementations

impl<W: Write + Seek> WavWriter<W>

pub fn new(sink: W, sample_rate: u32) -> Result<Self>

Begin a file, writing a provisional header.

Errors

If the provisional header cannot be written.

pub fn new_trimming_tail(sink: W, sample_rate: u32) -> Result<Self>

As WavWriter::new, but drops the model’s end-of-utterance noise burst.

See trailing_noise_samples for what is removed and why it is safe. The cost is that the last quarter second is held in memory until WavWriter::finish, so this is for file output only; a raw PCM stream must keep its latency and stays untrimmed.

Errors

If the provisional header cannot be written.

Examples found in repository

examples/tail_writer_probe.rs (line 26)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: tail_writer_probe <wav>");
    let bytes = std::fs::read(&path).expect("readable wav");
    let pcm: Vec<f32> = bytes[44..]
        .as_chunks::<2>()
        .0
        .iter()
        .map(|pair| f32::from(i16::from_le_bytes(*pair)) / 32_767.0)
        .collect();

    let offline = ftts_core::audio::trailing_noise_samples(&pcm, 24_000);
    let level = ftts_core::audio::speech_level(&pcm, 24_000);
    println!("input samples      : {}", pcm.len());
    println!("offline detector   : {offline} samples");
    println!("utterance level    : {level:.5}");

    // Exactly the CLI's packetization.
    let mut writer =
        ftts_core::audio::WavWriter::new_trimming_tail(Cursor::new(Vec::new()), 24_000)
            .expect("header");
    for packet in pcm.chunks(1_920) {
        writer.write_samples(packet).expect("write");
    }
    let out = writer.finish().expect("finish").into_inner();
    let written = (out.len() - 44) / 2;
    println!(
        "writer wrote       : {written} samples (trimmed {})",
        pcm.len() - written
    );

    // What the detector sees when handed only the tail, which is the writer's situation.
    let hold = 24_000 * 250 / 1000;
    let tail = &pcm[pcm.len().saturating_sub(hold)..];
    println!(
        "tail-only relative : {} samples (tail len {})",
        ftts_core::audio::trailing_noise_samples_relative_to(tail, 24_000, level),
        tail.len()
    );
}

pub fn write_samples(&mut self, pcm: &[f32]) -> Result<()>

Append one packet of decoded f32 samples.

Errors

If the sink rejects the write. The count of samples already accepted stays accurate, so a later WavWriter::finish still describes the file truthfully.

Examples found in repository

examples/tail_writer_probe.rs (line 29)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: tail_writer_probe <wav>");
    let bytes = std::fs::read(&path).expect("readable wav");
    let pcm: Vec<f32> = bytes[44..]
        .as_chunks::<2>()
        .0
        .iter()
        .map(|pair| f32::from(i16::from_le_bytes(*pair)) / 32_767.0)
        .collect();

    let offline = ftts_core::audio::trailing_noise_samples(&pcm, 24_000);
    let level = ftts_core::audio::speech_level(&pcm, 24_000);
    println!("input samples      : {}", pcm.len());
    println!("offline detector   : {offline} samples");
    println!("utterance level    : {level:.5}");

    // Exactly the CLI's packetization.
    let mut writer =
        ftts_core::audio::WavWriter::new_trimming_tail(Cursor::new(Vec::new()), 24_000)
            .expect("header");
    for packet in pcm.chunks(1_920) {
        writer.write_samples(packet).expect("write");
    }
    let out = writer.finish().expect("finish").into_inner();
    let written = (out.len() - 44) / 2;
    println!(
        "writer wrote       : {written} samples (trimmed {})",
        pcm.len() - written
    );

    // What the detector sees when handed only the tail, which is the writer's situation.
    let hold = 24_000 * 250 / 1000;
    let tail = &pcm[pcm.len().saturating_sub(hold)..];
    println!(
        "tail-only relative : {} samples (tail len {})",
        ftts_core::audio::trailing_noise_samples_relative_to(tail, 24_000, level),
        tail.len()
    );
}

pub const fn samples_written(&self) -> usize

Samples accepted so far.

pub const fn duration_millis(&self) -> u64

Duration of the audio written so far, in milliseconds.

pub fn finish(self) -> Result<W>

Patch the header to the real length and flush.

Errors

If seeking back to the header, rewriting it, or flushing fails.

Examples found in repository

examples/tail_writer_probe.rs (line 31)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: tail_writer_probe <wav>");
    let bytes = std::fs::read(&path).expect("readable wav");
    let pcm: Vec<f32> = bytes[44..]
        .as_chunks::<2>()
        .0
        .iter()
        .map(|pair| f32::from(i16::from_le_bytes(*pair)) / 32_767.0)
        .collect();

    let offline = ftts_core::audio::trailing_noise_samples(&pcm, 24_000);
    let level = ftts_core::audio::speech_level(&pcm, 24_000);
    println!("input samples      : {}", pcm.len());
    println!("offline detector   : {offline} samples");
    println!("utterance level    : {level:.5}");

    // Exactly the CLI's packetization.
    let mut writer =
        ftts_core::audio::WavWriter::new_trimming_tail(Cursor::new(Vec::new()), 24_000)
            .expect("header");
    for packet in pcm.chunks(1_920) {
        writer.write_samples(packet).expect("write");
    }
    let out = writer.finish().expect("finish").into_inner();
    let written = (out.len() - 44) / 2;
    println!(
        "writer wrote       : {written} samples (trimmed {})",
        pcm.len() - written
    );

    // What the detector sees when handed only the tail, which is the writer's situation.
    let hold = 24_000 * 250 / 1000;
    let tail = &pcm[pcm.len().saturating_sub(hold)..];
    println!(
        "tail-only relative : {} samples (tail len {})",
        ftts_core::audio::trailing_noise_samples_relative_to(tail, 24_000, level),
        tail.len()
    );
}

pub fn finish_reporting(self) -> Result<(W, usize)>

As WavWriter::finish, also reporting how many samples the file actually contains.

Callers that publish a sample count need this rather than their own tally: tail trimming (and any short write) makes “samples handed to the writer” differ from “samples in the file”, and a reported count that describes audio the file does not hold is a false number in a machine-readable stream.

Errors

If flushing the held tail, seeking back to the header, rewriting it, or flushing fails.

Trait Implementations

impl<W: Write + Seek> Drop for WavWriter<W>

fn drop(&mut self)

Best-effort finalisation for a writer dropped without WavWriter::finish.

A dropped writer means an abnormal end — a panic, an early return, a cancelled run. Leaving the provisional zero-length header would make the file claim it contains no audio while holding a megabyte of it. The error is deliberately swallowed because Drop cannot report, which is exactly why finish exists and should be called explicitly.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.