rouggy
9b8168370f
A real SunSDR answers format=3 where this expected 0 — and 0 was read from the documentation, which is exactly the kind of detail a memory of a document gets wrong. The stream was refused outright: 'format=3, expected float32', zero frames, silence. Swapping one magic number for another would only move the guess, so the width is now MEASURED: the header says how many samples the payload holds, and dividing gives the bytes per sample. Four is float32, two is 16-bit PCM scaled to the same -1..1 the rest of the audio path uses, and anything else is reported rather than mangled. That stays true whatever number the format field carries on the next firmware.
294 lines
9.4 KiB
Go
294 lines
9.4 KiB
Go
//go:build windows
|
|
|
|
package cat
|
|
|
|
// TCI audio — receiving the radio's audio over the same WebSocket that carries
|
|
// the commands, so a SunSDR needs no virtual audio cable.
|
|
//
|
|
// TCI mixes two kinds of frame on one socket: TEXT frames are the commands
|
|
// ("trx:0,true;"), BINARY frames are streams. A binary frame is a fixed header
|
|
// followed by float32 samples:
|
|
//
|
|
// uint32 receiver which receiver the stream belongs to
|
|
// uint32 sampleRate Hz
|
|
// uint32 format 0 = float32
|
|
// uint32 codec 0 = uncompressed
|
|
// uint32 crc unused in practice
|
|
// uint32 length samples in the payload
|
|
// uint32 type which stream this is (see tciStream*)
|
|
// uint32 reserved[9]
|
|
// float32 payload[…] stereo, interleaved
|
|
//
|
|
// The stream is asked for with "audio_samplerate:" then "audio_start:<rx>;",
|
|
// and stopped with "audio_stop:<rx>;".
|
|
//
|
|
// NOTHING HERE IS CONFIRMED ON A RADIO YET. The layout above is read from the
|
|
// TCI documentation, and the stream-type numbers in particular are the sort of
|
|
// detail a document gets right and a memory of it does not — so every header is
|
|
// logged for the first few seconds of a session, and the numbers the radio
|
|
// actually sends will settle it. Same discipline as the Yaesu meters and the
|
|
// Flex spot feed: measure on the real thing, then write the constant down.
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
)
|
|
|
|
// TCI stream types. RX audio is the one this file consumes; the others are
|
|
// named so a log line says what arrived rather than "type 3".
|
|
const (
|
|
tciStreamIQ = 0
|
|
tciStreamRXAudio = 1
|
|
tciStreamTXAudio = 2
|
|
tciStreamTXChrono = 3
|
|
)
|
|
|
|
// tciHeaderWords is the header length in uint32 words (7 named + 9 reserved).
|
|
const tciHeaderWords = 16
|
|
|
|
// tciHeaderBytes is the same in bytes.
|
|
const tciHeaderBytes = tciHeaderWords * 4
|
|
|
|
// tciAudioProbeMax bounds the header logging. Enough frames to see the shape
|
|
// and the rate; few enough that an evening of listening does not fill the log.
|
|
const tciAudioProbeMax = 40
|
|
|
|
// TCIAudioStatus is what the panel polls while testing the stream.
|
|
type TCIAudioStatus struct {
|
|
Running bool `json:"running"`
|
|
SampleRate int `json:"sample_rate"`
|
|
Frames int64 `json:"frames"` // binary frames accepted
|
|
Samples int64 `json:"samples"` // audio samples decoded
|
|
// PeakDB is the loudest sample of the last second, in dBFS: the one number
|
|
// that says "audio is really arriving" rather than "a socket is open".
|
|
PeakDB float64 `json:"peak_db"`
|
|
LastErr string `json:"last_err,omitempty"`
|
|
}
|
|
|
|
// tciAudio is the receive-side state, kept on the backend so it lives exactly
|
|
// as long as the connection does.
|
|
type tciAudio struct {
|
|
mu sync.Mutex
|
|
want bool // the host asked for audio
|
|
rx int // which receiver
|
|
rate int
|
|
frames int64
|
|
samples int64
|
|
peak float64
|
|
peakAt time.Time
|
|
probe int
|
|
lastErr string
|
|
// widthLogged keeps the one-line note about the sample width to once a
|
|
// session — it is a fact about the radio, not an event.
|
|
widthLogged bool
|
|
|
|
// OnSamples receives decoded MONO samples (the two channels averaged) at
|
|
// the negotiated rate. Mono because everything downstream — the QSO
|
|
// recorder, the CW decoder — works on one channel, and a receiver's two
|
|
// channels carry the same audio.
|
|
OnSamples func(rate int, samples []float32)
|
|
}
|
|
|
|
// StartTCIAudio asks the radio to stream receiver rx's audio.
|
|
func (t *TCI) StartTCIAudio(rx, rate int) error {
|
|
if rate <= 0 {
|
|
rate = 48000
|
|
}
|
|
t.audio.mu.Lock()
|
|
t.audio.want = true
|
|
t.audio.rx = rx
|
|
t.audio.rate = rate
|
|
t.audio.frames, t.audio.samples, t.audio.peak = 0, 0, 0
|
|
t.audio.probe = 0
|
|
t.audio.lastErr = ""
|
|
t.audio.mu.Unlock()
|
|
|
|
// Sample rate first: the radio applies it to the stream it is about to
|
|
// open, and asking afterwards restarts the stream on some firmware.
|
|
if err := t.send(fmt.Sprintf("audio_samplerate:%d;", rate)); err != nil {
|
|
return err
|
|
}
|
|
return t.send(fmt.Sprintf("audio_start:%d;", rx))
|
|
}
|
|
|
|
// StopTCIAudio closes the stream.
|
|
func (t *TCI) StopTCIAudio() error {
|
|
t.audio.mu.Lock()
|
|
t.audio.want = false
|
|
rx := t.audio.rx
|
|
t.audio.mu.Unlock()
|
|
return t.send(fmt.Sprintf("audio_stop:%d;", rx))
|
|
}
|
|
|
|
// TCIAudioStatus reports what has arrived.
|
|
func (t *TCI) TCIAudioStatus() TCIAudioStatus {
|
|
t.audio.mu.Lock()
|
|
defer t.audio.mu.Unlock()
|
|
st := TCIAudioStatus{
|
|
Running: t.audio.want,
|
|
SampleRate: t.audio.rate,
|
|
Frames: t.audio.frames,
|
|
Samples: t.audio.samples,
|
|
LastErr: t.audio.lastErr,
|
|
}
|
|
// A peak older than a second is not a level, it is a memory. Reported as
|
|
// silence rather than left standing, so a stream that has stopped arriving
|
|
// looks stopped.
|
|
if time.Since(t.audio.peakAt) < time.Second && t.audio.peak > 0 {
|
|
st.PeakDB = 20 * math.Log10(t.audio.peak)
|
|
} else {
|
|
st.PeakDB = -99
|
|
}
|
|
return st
|
|
}
|
|
|
|
// handleBinary decodes one binary WebSocket frame.
|
|
//
|
|
// Called from the reader goroutine. Anything malformed is counted and dropped:
|
|
// a stream frame is not worth breaking the command connection over, and the
|
|
// command connection is what keeps the radio usable.
|
|
func (t *TCI) handleBinary(data []byte) {
|
|
if len(data) < tciHeaderBytes {
|
|
t.audioErr(fmt.Sprintf("binary frame of %d bytes is shorter than a header", len(data)))
|
|
return
|
|
}
|
|
le := binary.LittleEndian
|
|
receiver := int(le.Uint32(data[0:]))
|
|
rate := int(le.Uint32(data[4:]))
|
|
format := le.Uint32(data[8:])
|
|
codec := le.Uint32(data[12:])
|
|
length := int(le.Uint32(data[20:]))
|
|
stype := int(le.Uint32(data[24:]))
|
|
|
|
t.audio.mu.Lock()
|
|
probe := t.audio.probe
|
|
if probe < tciAudioProbeMax {
|
|
t.audio.probe++
|
|
}
|
|
t.audio.mu.Unlock()
|
|
if probe < tciAudioProbeMax {
|
|
debugLog.Printf("TCI: binary frame — rx=%d rate=%d format=%d codec=%d length=%d type=%d payload=%d bytes",
|
|
receiver, rate, format, codec, length, stype, len(data)-tciHeaderBytes)
|
|
}
|
|
|
|
if stype != tciStreamRXAudio {
|
|
return // IQ, TX audio echo, chrono: not this file's business yet
|
|
}
|
|
if codec != 0 {
|
|
t.audioErr(fmt.Sprintf("stream is codec=%d, and nothing here decodes a compressed stream", codec))
|
|
return
|
|
}
|
|
|
|
// The FORMAT number is decided by measurement, not by the number itself.
|
|
//
|
|
// A real SunSDR answered format=3, where the code expected 0 — and 0 was a
|
|
// guess from reading the documentation, which is exactly the kind of detail
|
|
// a memory of a document gets wrong. Rather than swap one magic number for
|
|
// another, the sample width is derived from what arrived: the header says
|
|
// how many samples the payload holds, so the bytes per sample follow from
|
|
// dividing. That is true whatever number the format field carries, on this
|
|
// firmware and the next.
|
|
payload := data[tciHeaderBytes:]
|
|
if len(payload) == 0 || length <= 0 {
|
|
return
|
|
}
|
|
width := len(payload) / length
|
|
var n int
|
|
switch width {
|
|
case 4:
|
|
n = len(payload) / 4 // float32
|
|
case 2:
|
|
n = len(payload) / 2 // 16-bit PCM
|
|
default:
|
|
t.audioErr(fmt.Sprintf("frame carries %d bytes for %d samples (format=%d) — not a width this reads",
|
|
len(payload), length, format))
|
|
return
|
|
}
|
|
if n == 0 {
|
|
return
|
|
}
|
|
// Under the lock like the rest of the counters: the reader is the only
|
|
// writer today, but a fact about the radio that is read from another
|
|
// goroutine has no business being the one field left unguarded.
|
|
t.audio.mu.Lock()
|
|
first := !t.audio.widthLogged
|
|
t.audio.widthLogged = true
|
|
t.audio.mu.Unlock()
|
|
if first {
|
|
debugLog.Printf("TCI: audio is %d bytes per sample at %d Hz (format field says %d)", width, rate, format)
|
|
}
|
|
// Stereo interleaved → mono. Both channels of a receiver carry the same
|
|
// audio, and everything downstream works on one.
|
|
mono := make([]float32, 0, n/2+1)
|
|
var peak float64
|
|
sample := func(i int) float32 {
|
|
if width == 2 {
|
|
// 16-bit PCM, scaled to the same -1…1 the rest of the audio path
|
|
// works in, so a change of format cannot change what a level means.
|
|
return float32(int16(le.Uint16(payload[i*2:]))) / 32768
|
|
}
|
|
return math.Float32frombits(le.Uint32(payload[i*4:]))
|
|
}
|
|
for i := 0; i+1 < n; i += 2 {
|
|
v := (sample(i) + sample(i+1)) / 2
|
|
if a := math.Abs(float64(v)); a > peak {
|
|
peak = a
|
|
}
|
|
mono = append(mono, v)
|
|
}
|
|
|
|
t.audio.mu.Lock()
|
|
t.audio.frames++
|
|
t.audio.samples += int64(len(mono))
|
|
if rate > 0 {
|
|
t.audio.rate = rate
|
|
}
|
|
if peak > t.audio.peak || time.Since(t.audio.peakAt) > time.Second {
|
|
t.audio.peak = peak
|
|
t.audio.peakAt = time.Now()
|
|
}
|
|
cb := t.audio.OnSamples
|
|
t.audio.mu.Unlock()
|
|
|
|
if cb != nil {
|
|
cb(rate, mono)
|
|
}
|
|
}
|
|
|
|
// audioErr records a decoding complaint, once, so the panel can show it without
|
|
// the log filling with the same line at fifty frames a second.
|
|
func (t *TCI) audioErr(msg string) {
|
|
t.audio.mu.Lock()
|
|
first := t.audio.lastErr != msg
|
|
t.audio.lastErr = msg
|
|
t.audio.mu.Unlock()
|
|
if first {
|
|
debugLog.Printf("TCI: audio: %s", msg)
|
|
}
|
|
}
|
|
|
|
// resumeAudio re-opens the stream after a reconnect, if the host had asked for
|
|
// it. A dropped WebSocket takes the audio with it, and an operator who switched
|
|
// recording on does not expect to switch it on again.
|
|
func (t *TCI) resumeAudio() {
|
|
t.audio.mu.Lock()
|
|
want, rx, rate := t.audio.want, t.audio.rx, t.audio.rate
|
|
t.audio.mu.Unlock()
|
|
if !want {
|
|
return
|
|
}
|
|
if err := t.StartTCIAudio(rx, rate); err != nil {
|
|
debugLog.Printf("TCI: re-opening the audio stream failed: %v", err)
|
|
}
|
|
}
|
|
|
|
// wsMessageIsBinary keeps the type test in one place — the reader used to
|
|
// ignore the message type entirely and split every frame on ';', which would
|
|
// have fed audio bytes to the command parser the moment a stream was opened.
|
|
func wsMessageIsBinary(mt int) bool { return mt == websocket.BinaryMessage }
|