Enum DataFrame 

pub enum DataFrame {
    InputAudio {
        bytes: Arc<[u8]>,
        sample_rate: u32,
        num_channels: u16,
    },
    Transcript(Arc<str>),
    Audio(AudioChunk),
    Custom(Arc<dyn CustomFrame>),
}

Data frames: media payload flowing downstream (source → sink).

Immutable: don’t try to make mutable frames. Instead, aggregate frames and produce a new one when you’re ready.

Variants

InputAudio

Input audio from a transport source. Survives an interrupt flush so that a barge-in utterance is not clipped; see DataFrame::survives_flush.

Fields

bytes: Arc<[u8]>

Raw PCM bytes.

sample_rate: u32

Samples per second (e.g. 16 000 for 16 kHz).

num_channels: u16

Number of audio channels (1 = mono, 2 = stereo).

Transcript(Arc<str>)

A text transcript segment (ASR output or TTS input).

Audio(AudioChunk)

A chunk of f32 PCM audio carrying its own AudioFormat.

Custom(Arc<dyn CustomFrame>)

Application-defined payload; see CustomFrame.

Implementations

impl DataFrame

pub fn survives_flush(&self) -> bool

True for frames that must survive an interrupt’s data-queue flush — input-from-transport media, since a barge-in utterance must not be clipped. False for everything else.

use std::sync::Arc;
use pipecrab_core::{AudioChunk, AudioFormat, DataFrame};

let input = DataFrame::InputAudio {
    bytes: Arc::from(&[0u8; 4][..]),
    sample_rate: 16_000,
    num_channels: 1,
};
assert!(input.survives_flush());

assert!(!DataFrame::Transcript("hi".into()).survives_flush());

let audio = AudioChunk::new(Arc::from(&[0.0f32][..]), AudioFormat::new(48_000, 1));
assert!(!DataFrame::Audio(audio).survives_flush());

Trait Implementations

impl Clone for DataFrame

fn clone(&self) -> DataFrame

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataFrame

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.