Crate kizzasi_io 

kizzasi-io

Physical world connectors for Kizzasi - MQTT, Audio, Video, and comprehensive sensor streams with state-of-the-art signal processing capabilities.

Core Features

Stream Sources

• MQTT: IoT/industrial sensor integration with TLS, QoS, and reconnection
• Audio: Multi-channel audio I/O via cpal (ASIO, JACK support)
• Video: Frame capture with FFmpeg and camera input (v4l2/DirectShow/AVFoundation)
• Network: WebSocket, TCP/UDP sockets, serial ports
• Protocols: OSC, ZeroMQ, ROS2 (when available)
• Files: WAV, CSV, HDF5 reading/writing

Signal Processing

Basic Filters

• FIR: Sinc lowpass/highpass, moving average, differentiator
• IIR: Butterworth lowpass/highpass, notch filters

Advanced Adaptive Filtering

• Kalman Filter: Optimal linear state estimation with prediction/update cycles
• Particle Filter: Non-Gaussian/nonlinear Bayesian estimation
• LMS/NLMS: Least Mean Squares adaptive filtering
• RLS: Recursive Least Squares for rapid adaptation

Cepstral Analysis

• Real Cepstrum: Pitch detection and formant analysis
• Complex Cepstrum: Homomorphic deconvolution
• Formant Tracking: Speech resonance detection
• Liftering: Quefrency domain filtering
• Cepstral Distance: Speech quality assessment

Time-Frequency Analysis

• Gabor Transform: Optimal time-frequency resolution with Gaussian windows
• S-Transform: Frequency-dependent resolution (Stockwell transform)
• Wigner-Ville: High-resolution quadratic distribution
• Choi-Williams: Cross-term suppression for multi-component signals
• Reassigned Spectrogram: Enhanced resolution through energy reassignment

Spectral Analysis

• STFT: Short-Time Fourier Transform with multiple window functions
• Spectrograms: Time-frequency magnitude/phase representations
• MFCC: Mel-frequency cepstral coefficients extraction
• Power Spectrum: Optimized FFT for power-of-2 sizes

Wavelets

• DWT/IDWT: Discrete Wavelet Transform (Haar, Daubechies, Symlet, Coiflet)
• SWT: Stationary Wavelet Transform
• Denoising: Wavelet-based noise reduction

Resampling

• Polyphase: Efficient integer-ratio resampling
• Linear/Cubic: Interpolation-based resampling
• Streaming: Real-time sinc-based resampling

Performance Optimization

• Zero-copy buffers: SharedSignalBuffer, ZeroCopyBuffer, BufferPool
• Lock-free queues: Thread-safe concurrent data structures
• Ring buffers: Real-time circular buffering with statistics
• SIMD: Vectorized signal operations (when enabled)
• Async streams: Tokio-based asynchronous stream processing

Stream Processing

• Pipelines: Composable signal transformations
• Synchronization: Multi-stream time alignment with PLL
• Multiplexing: Round-robin, time-ordered, weighted merging
• Adaptive buffering: Dynamic buffer sizing
• Rate control: Adaptive rate limiting

Diagnostics & Monitoring

• Health monitoring: Stream status, latency, throughput
• Signal quality: SNR, clipping detection, crest factor
• Latency tracking: Percentile-based latency statistics
• Buffer tracking: Underrun/overrun detection

Data Processing

• Compression: RLE, Delta, DPCM, Quantization with adaptive selection
• Calibration: Multi-point, non-linear, temperature compensation
• Batch processing: Windowed, parallel batch operations
• Recording/Playback: Binary, JSON, CSV stream capture

Video Processing

• Optical Flow: Lucas-Kanade, Dense Gradient, Block Matching
• Filters: Gaussian/Box blur, Sobel/Laplacian edges, morphology
• Frame operations: Format conversion, normalization, buffering

Examples

Basic Signal Generation and Filtering

use kizzasi_io::{SineGenerator, SignalGenerator, FirFilter};
use scirs2_core::ndarray::Array1;

// Generate a sine wave
let mut generator = SineGenerator::new(440.0, 1.0, 44100.0);
let signal = generator.generate(1024);

// Apply lowpass filter
let mut filter = FirFilter::sinc_lowpass(0.25, 31).unwrap();
let filtered = filter.process(&signal);

Adaptive Filtering with Kalman Filter

use kizzasi_io::KalmanFilter;
use scirs2_core::ndarray::{arr1, Array2};

// 1D position tracking
let initial_state = arr1(&[0.0]);
let initial_cov = Array2::eye(1);
let transition = Array2::eye(1);
let observation = Array2::eye(1);
let process_noise = Array2::eye(1) * 0.01;
let measurement_noise = Array2::eye(1) * 0.1;

let mut kf = KalmanFilter::new(
    initial_state, initial_cov, transition,
    observation, process_noise, measurement_noise
).unwrap();

// Update with measurement
kf.predict();
kf.update(&arr1(&[1.5])).unwrap();
println!("State estimate: {:?}", kf.state());

Time-Frequency Analysis

use kizzasi_io::{GaborTransform, SineGenerator, SignalGenerator};

let mut gen = SineGenerator::new(440.0, 1.0, 16000.0);
let signal = gen.generate(1024);

let mut gabor = GaborTransform::new(16000.0);
let result = gabor.compute(&signal, 256, 128, 32.0).unwrap();

println!("Time-frequency representation: {} × {} bins",
         result.num_frames, result.num_bins);

COOLJAPAN Ecosystem

This crate uses scirs2-core for all array operations following KIZZASI_POLICY.md.

Structs

AdaptiveBeamformer

Adaptive beamformer using LMS algorithm

AdaptiveBuffer

Adaptive buffer that adjusts size based on usage patterns

AdaptiveBufferStats

Statistics about adaptive buffer performance

AdaptiveCompressor

Adaptive compressor that selects best method

AdaptiveConfig

Configuration for adaptive buffer

AdaptiveRateController

Adaptive rate controller that adjusts based on buffer levels

AggregateHealth

Aggregate statistics for multiple streams

ArbitrarySrcResampler

Arbitrary sample rate converter using adaptive filtering

AsyncMemoryStream

Async in-memory signal stream for testing

AsyncMultiplexer

Async multiplexer using channels

AudioConfig

Configuration for audio I/O

AudioInput

Audio input stream

AudioOutput

Audio output stream (playback)

AutoCalibrator

Auto-calibration using known reference signal

BatchAccumulator

Batch accumulator for collecting samples

BatchConfig

Batch configuration

BatchProcessor

Batch processor for applying operations to batches

BatchStats

Statistics accumulator for batch processing

BufferLevelTracker

Buffer level tracker

BufferPool

Pool of reusable buffers to reduce allocation overhead

CalibrationCurve

Calibration curve for non-linear sensor response

CalibrationManager

Calibration manager for multiple sensors

CalibrationParams

Calibration parameters for a sensor

CepstralDistance

Cepstral distance measure for speech quality assessment

ChannelSplitter

Channel-based stream splitter

ChannelStream

Async channel-based stream adapter

ChirpGenerator

Chirp (frequency sweep) generator

ChoiWilliams

Choi-Williams distribution

ClipTransform

Clipping transform (limit values to range)

ComplexCepstrum

Complex cepstrum analyzer

CompressedSignal

Compressed signal data

CompressionMetadata

Metadata needed for decompression

CubicResampler

Cubic interpolation resampler (better quality than linear)

DOAEstimator

Direction of Arrival (DOA) estimation

DecimateTransform

Decimation transform (downsample by factor)

DelayAndSum

Delay-and-Sum beamformer

DerivativeTransform

Derivative transform (compute differences)

DwtMultiLevel

Multi-level DWT result

DwtResult

Discrete Wavelet Transform (DWT) result

EmdConfig

Configuration for EMD algorithm

EmdResult

Result of EMD decomposition

EmpiricalModeDecomposition

Empirical Mode Decomposition (EMD) implementation

EnsembleEmd

Ensemble EMD (EEMD) for noise-assisted decomposition

FarrowResampler

Farrow structure for fractional delay and arbitrary sample rate conversion

FastICA

FastICA algorithm for Independent Component Analysis

FirFilter

FIR (Finite Impulse Response) filter

FormantTracker

Formant tracker for speech analysis

GaborResult

Gabor transform result

GaborTransform

Gabor transform analyzer

HealthMonitor

Stream health monitor

IirFilter

IIR (Infinite Impulse Response) filter

ImpulseGenerator

Impulse generator (single spike)

IntrinsicModeFunction

Intrinsic Mode Function with its properties

KalmanFilter

Kalman Filter for optimal linear state estimation

LatencyStats

Latency statistics

LatencyTracker

Latency tracker with start/stop timing

LinearResampler

Simple linear interpolation resampler

LmsFilter

LMS (Least Mean Squares) Adaptive Filter

LockFreeQueue

Lock-free SPSC (Single Producer Single Consumer) queue

LockFreeRingBuffer

Lock-free ring buffer with overwrite semantics

MVDR

Minimum Variance Distortionless Response (MVDR) beamformer

MemoryStream

In-memory signal stream for testing

MicrophoneArray

Microphone array configuration

MosPredictor

MOS (Mean Opinion Score) predictor

MovingAverageTransform

Moving average transform (smooth signal)

MqttClient

MQTT client for receiving sensor data

MqttConfig

Configuration for MQTT connection

MqttMessage

MQTT message

MqttStream

Synchronous wrapper for MqttClient as SignalStream

MultiPointCalibrator

Multi-point calibration using least squares

MultiToneGenerator

Multi-tone generator (sum of multiple sine waves)

MultiplexConfig

Multiplexer configuration

NMF

Non-negative Matrix Factorization

NlmsFilter

NLMS (Normalized LMS) Adaptive Filter

NormalizeTransform

Normalization transform (scale to [0, 1] or [-1, 1])

OffsetTransform

Offset transform (add constant)

PCA

Principal Component Analysis

ParallelBatchProcessor

Parallel batch processor using multiple threads

ParallelPipeline

Parallel pipeline - process multiple pipelines in parallel and combine results

ParticleFilter

Particle Filter for non-Gaussian/nonlinear state estimation

PesqCalculator

PESQ-inspired perceptual quality metric Simplified version of ITU-T P.862

PhaseLockLoop

Phase-locked loop for maintaining stream synchronization

PinkNoiseGenerator

Pink noise generator (1/f spectrum)

Pipeline

A pipeline of stream transformations

PolqaCalculator

POLQA-inspired metric (Perceptual Objective Listening Quality Assessment)

QualityMetrics

Comprehensive quality metrics

QuefrencyFilter

Quefrency domain filter

RateLimiter

Rate limiter for controlling data flow

RealCepstrum

Real cepstrum analyzer

ReassignedResult

Reassigned spectrogram result

ReassignedSpectrogram

Reassigned spectrogram

RecordedFrame

Recorded frame with optional timestamp

RecorderConfig

Recorder configuration

Resampler

Resampler using polyphase filter implementation

RingBuffer

Ring buffer for real-time signal processing

RingBufferIter

Ring buffer iterator

RlsFilter

RLS (Recursive Least Squares) Adaptive Filter

STransform

S-transform (Stockwell transform)

STransformResult

S-transform result

SawtoothGenerator

Sawtooth wave generator

ScaleTransform

Scaling transform (multiply by constant)

SharedSignalBuffer

Zero-copy signal buffer using Arc for shared ownership

SignalCompressor

Signal compressor

SignalProcessor

Signal processor for pre-processing sensor data

SignalQuality

Signal quality metrics

SignalQueue

Lock-free signal queue for audio/sensor data

SignalRingBuffer

Float ring buffer with signal processing operations

SincStreamingResampler

High-quality streaming resampler using Sinc interpolation

SineGenerator

Sine wave generator

SnrCalculator

Signal-to-Noise Ratio calculator

Spectrogram

Spectrogram data structure

SquareGenerator

Square wave generator

StepGenerator

Step function generator

StoiCalculator

Short-Time Objective Intelligibility (STOI) metric Measures speech intelligibility in noisy conditions

StreamConfig

Configuration for signal streams

StreamDemultiplexer

Stream demultiplexer - splits one stream into multiple outputs

StreamHealth

Stream health metrics

StreamMultiplexer

Stream multiplexer - combines multiple streams into one

StreamPlayer

Stream player for playback

StreamRecorder

Stream recorder

StreamSynchronizer

Multi-stream synchronizer

StreamingResampler

Real-time streaming resampler for audio processing

SyncConfig

Configuration for stream synchronizer

TemporalDecorrelation

Temporal decorrelation for source separation

TimeSynchronizer

Time synchronizer using NTP-like algorithm

TimeVaryingResampler

Time-varying resampler for dynamic sample rate conversion

TimestampedSample

Timestamped data sample

TlsConfig

TLS/SSL configuration

TriangleGenerator

Triangle wave generator

UnboundedQueue

Lock-free unbounded MPMC (Multi Producer Multi Consumer) queue

WaveletAnalyzer

Wavelet analyzer for performing wavelet transforms

WhiteNoiseGenerator

White noise generator using a simple LCG for reproducibility

WignerVille

Wigner-Ville distribution

WignerVilleResult

Wigner-Ville distribution result

WindowedBatchProcessor

Windowed batch processor for sliding window operations

ZeroCopyBuffer

Zero-copy byte buffer for raw data streams

ZeroCopyBufferMut

Mutable zero-copy buffer builder

Enums

AdaptiveStrategy

Strategy for adapting buffer size

AudioBackend

Audio backend selection

CombineStrategy

CompressionMethod

Compression method for signal data

Filter

Filter types for signal processing

HealthStatus

Health status of a stream

InterpolationMethod

IoError

Errors that can occur in the IO module

MultiplexStrategy

Strategy for multiplexing multiple streams

Nonlinearity

Nonlinearity function for ICA

QosLevel

MQTT Quality of Service level

RatioModulation

Type of ratio modulation

RecorderFormat

Recording format

WaveletType

Wavelet types for wavelet transforms

WindowType

Window function types for spectral analysis

Traits

AsyncSignalStream

Async trait for signal streams

SignalGenerator

Signal generator trait

SignalStream

Trait for signal streams

StreamTransform

Trait for stream transformations that can be chained

Type Aliases

Array1

one-dimensional array

IoResult

Result type alias for IO operations

Timestamp

Timestamp type (microseconds since epoch)