Struct StreamCapture 

pub(crate) struct StreamCapture {

    pub(crate) reflector: String,
    pub(crate) module: String,
    pub(crate) protocol: String,
    pub(crate) stream_id: u16,
    pub(crate) callsign: String,
    pub(crate) suffix: Option<String>,
    pub(crate) ur_call: Option<String>,
    pub(crate) ambe_frames: Vec<[u8; 9]>,
    slow_data: SlowDataAssembler,
    pub(crate) dstar_text: Option<String>,
    pub(crate) dprs_lat: Option<f64>,
    pub(crate) dprs_lon: Option<f64>,
    pub(crate) started_at: DateTime<Utc>,
}

State for one in-progress voice-stream capture.

Created when a D-STAR VoiceStart event arrives (via Self::new, which extracts header metadata). Frames are added via Self::push_frame as VoiceFrame events arrive. When the stream ends (EOT or timeout), the accumulated state is consumed by the Tier 3 orchestrator to produce an MP3 and persist a database row.

Fields

reflector: String

Reflector callsign this stream was captured from (e.g. "REF030").

module: String

Module letter (A-Z) the stream was received on.

protocol: String

Protocol name: "dplus", "dextra", or "dcs".

stream_id: u16

D-STAR stream ID (non-zero u16 on wire).

callsign: String

Operator callsign (my_call from the header), ASCII-trimmed.

suffix: Option<String>

Operator suffix (my_suffix from the header), if non-empty after trim.

ur_call: Option<String>

Destination callsign (ur_call from the header), if non-empty after trim.

ambe_frames: Vec<[u8; 9]>

AMBE voice frames accumulated in receive order.

Each frame is 9 bytes; 160 PCM samples will be produced per frame by mbelib-rs. The order is load-bearing: the AMBE decoder uses inter-frame delta prediction.

slow_data: SlowDataAssembler

Stateful slow-data reassembler.

Fed one 3-byte fragment per voice frame via SlowDataAssembler::push. Emits SlowDataBlock values when complete blocks arrive; we consume those immediately to update dstar_text and dprs_lat/dprs_lon.

dstar_text: Option<String>

Latest slow-data text message decoded from this stream, if any.

dprs_lat: Option<f64>

DPRS latitude in decimal degrees, if a DPRS sentence was decoded.

dprs_lon: Option<f64>

DPRS longitude in decimal degrees, if a DPRS sentence was decoded.

started_at: DateTime<Utc>

When the voice header arrived (UTC wall-clock time).

Implementations

impl StreamCapture

pub(crate) fn new( reflector: String, module: String, protocol: String, stream_id: StreamId, header: &DStarHeader, ) -> Self

Creates a new capture from the D-STAR voice header.

Extracts my_call, my_suffix, and ur_call from the header, trimming ASCII whitespace and dropping empty strings. The header’s RPT1/RPT2 fields are not persisted — they are routing metadata and are redundant with the reflector/module arguments.

pub(crate) fn push_frame(&mut self, frame: &VoiceFrame)

Appends one voice frame to the capture.

The 9-byte AMBE payload is stored verbatim for later mbelib-rs decoding. The 3-byte slow-data fragment is fed to the assembler, which may emit a complete SlowDataBlock after enough fragments arrive. Text and GPS blocks are retained (last-write-wins if the transmission contains multiple); other block kinds are ignored.

fn consume_slow_data(&mut self, block: SlowDataBlock)

Processes a single assembled slow-data block, updating capture fields.

• Text: store the trimmed text message as dstar_text.
• Gps: parse the DPRS sentence and store lat/lon if valid; DPRS parse failures are non-fatal (real-world slow data often contains malformed GPS payloads from non-GPS-equipped radios).
• All other variants (HeaderRetx, FastData, Squelch, Unknown): ignored — not part of the streams table.

pub(crate) const fn frame_count(&self) -> usize

Returns the number of voice frames captured so far.

Trait Implementations

impl Debug for StreamCapture

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

Formats the value using the given formatter.