Struct StreamingWang 

pub struct StreamingWang { /* private fields */ }

Streaming Wang fingerprinter — fully incremental.

Maintains a rolling spectrogram window (2·neighborhood_t + 1 rows), detects peaks frame-by-frame as they ripen, accumulates per-second candidate buckets, finalises buckets via the per-second adaptive threshold, and grows per-anchor target heaps until each anchor’s target zone is fully observed. Per-push CPU cost is proportional to the number of new frames (not the total stream length).

For whole-second (and many other) clip lengths, the legacy StreamingFingerprinter::flush hash multiset matches Wang::extract — verified by the streaming_offline_* tests. At certain fractional-second remainders (audit F01) legacy flush may emit fewer hashes; use flush_complete when you need offline parity.

The pipeline itself is shared with StreamingPanako via the crate-internal streaming core; this wrapper supplies only the Wang-specific hash emission.

Example

use audiofp::{SampleRate, StreamingFingerprinter};
use audiofp::classical::StreamingWang;

let mut s = StreamingWang::default();
// Feed 4 seconds of silence in two chunks; nothing should be emitted.
let zeros = vec![0.0_f32; 8_000 * 2];
assert!(s.push(&zeros).unwrap().is_empty());
assert!(s.push(&zeros).unwrap().is_empty());
assert!(s.flush().unwrap().is_empty());

Implementations

impl StreamingWang

pub fn new(cfg: WangConfig) -> Self

Build a streaming Wang extractor with the given config.

Clamps target_zone_t to a minimum of 1 and fan_out to a minimum of 1 to prevent underflows/empty output from degenerate configurations. Caps target_zone_t at 512 and fan_out at 64 to prevent OOM from extreme values.

pub fn config(&self) -> &WangConfig

Borrow the configuration this stream was built with.

pub fn reset(&mut self)

Reset all internal state. The stream behaves as if freshly constructed: no buffered audio, no pending peaks or anchors. Call between independent streams sharing one instance so stale data from a previous stream doesn’t bleed into the first emitted hash.

pub fn flush_complete(&mut self) -> Result<Vec<(TimestampMs, WangHash)>>

Corrected end-of-stream finalisation matching offline Wang::extract.

The default StreamingFingerprinter::flush is legacy: it may emit fewer hashes than offline extraction at certain clip lengths (notably fractional-second remainders such as 18 000 samples at 8 kHz) because anchors are drained before later target buckets are finalised. Call this opt-in API when you need offline parity; keep using flush only when byte-identical legacy streaming output is required.

Idempotent with respect to anchor emission: a second call with no intervening push returns nothing. Safe after push following an earlier flush_complete (pending anchors/targets are empty).

pub fn flush_complete_with<F>(&mut self, callback: F) -> Result<usize>

where F: FnMut(TimestampMs, &WangHash),

Callback variant of flush_complete.

Trait Implementations

impl Default for StreamingWang

fn default() -> Self

Returns the “default value” for a type.

impl StreamingFingerprinter for StreamingWang

type Frame = WangHash

One unit of fingerprint material the stream emits.

fn required_sample_rate(&self) -> u32

Sample rate, in hertz, the stream expects its input at.

fn push(&mut self, samples: &[f32]) -> Result<Vec<(TimestampMs, Self::Frame)>>

Feed PCM samples and return any fingerprints that became available during this push.

fn push_with<F>(&mut self, samples: &[f32], callback: F) -> Result<usize>

where F: FnMut(TimestampMs, &Self::Frame),

Feed PCM samples and invoke callback for each fingerprint frame that became available during this push.

fn flush(&mut self) -> Result<Vec<(TimestampMs, Self::Frame)>>

Drain any pending fingerprint material at end-of-stream.

fn flush_with<F>(&mut self, callback: F) -> Result<usize>

where F: FnMut(TimestampMs, &Self::Frame),

Drain any pending fingerprint material at end-of-stream, invoking callback for each frame.

fn latency_ms(&self) -> u32

Conservative upper bound on emission latency: from the time a sample enters push to the time the fingerprint covering it is returned.

fn push_strict( &mut self, samples: &[f32], ) -> Result<Vec<(TimestampMs, Self::Frame)>>

Like push, but fail fast on non-finite input instead of sanitizing it to 0.0.

impl ZeroAllocStreaming for StreamingWang