rouggy/OpsLog
0
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 52 Wiki Activity

fix: a silent audio source no longer empties the whole recording

Browse Source 
From an operator's log: a Flex with From Radio on DAX RX and Recording mic on
DAX Mic, a full CW QSO recorded, and at log time "snapshot failed: recording
was empty".

The mixer took min(len(A), len(B)) samples. In CW the mic path does not run, so
DAX Mic delivered nothing, min stayed 0, and the drift guard then threw the
radio audio away a second at a time. Two devices configured meant the recording
depended on the quieter one being alive.

A source that has delivered nothing for 1.5 s is now treated as absent and the
other is recorded alone, with one line in the log saying so — half a recording
is worth having, silence is not. Both are mixed again the moment the missing one
comes back.

Neither is written off before it has EVER spoken: at startup both timestamps are
zero, and declaring one dead then would clip the opening of every recording.
That case is tested too.
This commit is contained in:
rouggy
2026-07-30 23:39:54 +02:00
parent a1ceea978b
commit c4c5db3921
3 changed files with 143 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/audio/recorder.go
+72 -6
View File
@@ -42,12 +42,19 @@ type Recorder struct {
prerollSamples int
// Per-source sample queues (guarded by srcMu), drained by the mixer.
srcMu sync.Mutex
bufA []int16 // From Radio
bufB []int16 // mic
twoSrc bool
gainA float64 // From Radio gain (1.0 = unity), guarded by srcMu
gainB float64 // mic gain
srcMu sync.Mutex
bufA []int16 // From Radio
bufB []int16 // mic
// When each source last delivered samples. A configured device that never
// produces anything is not an error anywhere — the capture call just sits
// there — so the only way to notice is to watch the clock.
lastA, lastB time.Time
// deadB (deadA) latches once a source has been declared silent, so the
// warning is logged once rather than 25 times a second.
deadA, deadB bool
twoSrc bool
gainA float64 // From Radio gain (1.0 = unity), guarded by srcMu
gainB float64 // mic gain
// Mixed output state (guarded by mu).
ring []int16 // last prerollSamples of mixed audio
@@ -133,6 +140,7 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
s := bytesToInt16(chunk)
r.srcMu.Lock()
r.bufA = append(r.bufA, s...)
r.lastA = time.Now()
r.srcMu.Unlock()
})
}()
@@ -145,6 +153,7 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
s := bytesToInt16(chunk)
r.srcMu.Lock()
r.bufB = append(r.bufB, s...)
r.lastB = time.Now()
r.srcMu.Unlock()
})
}()
@@ -171,15 +180,66 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
// mixTick drains the source queues, mixes what's available, and appends to the
// ring + active accumulation.
// deadSourceAfter is how long a source may deliver nothing before the recorder
// carries on without it. Long enough not to trip on a scheduling hiccup, short
// enough that almost nothing is lost from the source that IS working.
const deadSourceAfter = 1500 * time.Millisecond
func (r *Recorder) mixTick() {
r.srcMu.Lock()
var mixed []int16
if r.twoSrc {
// A source that has been silent for a while is treated as ABSENT and the
// other one is recorded alone.
//
// Two sources used to mean min(len(A), len(B)) samples: if one device
// delivered nothing, NOTHING was recorded, and the drift guard below
// then threw the live source away a second at a time. That is exactly
// what happened on a Flex in CW — DAX Mic delivers nothing when the mic
// path is not running — and the operator got "recording was empty" after
// a whole QSO. Half a recording is worth having; silence is not.
now := time.Now()
aDry := !r.lastA.IsZero() && now.Sub(r.lastA) > deadSourceAfter
bDry := !r.lastB.IsZero() && now.Sub(r.lastB) > deadSourceAfter
// Never before either source has spoken at all: at startup both are zero
// and neither should be written off.
if bDry && !aDry && len(r.bufA) > 0 {
if !r.deadB {
r.deadB = true
LogSink("recorder: the second audio source is silent — recording the radio alone")
}
mixed = make([]int16, len(r.bufA))
for i, v := range r.bufA {
mixed[i] = scaleSample(v, r.gainA)
}
r.bufA = r.bufA[:0]
r.bufB = r.bufB[:0]
r.srcMu.Unlock()
r.store(mixed)
return
}
if aDry && !bDry && len(r.bufB) > 0 {
if !r.deadA {
r.deadA = true
LogSink("recorder: the radio audio source is silent — recording the microphone alone")
}
mixed = make([]int16, len(r.bufB))
for i, v := range r.bufB {
mixed[i] = scaleSample(v, r.gainB)
}
r.bufA = r.bufA[:0]
r.bufB = r.bufB[:0]
r.srcMu.Unlock()
r.store(mixed)
return
}
n := len(r.bufA)
if len(r.bufB) < n {
n = len(r.bufB)
}
if n > 0 {
// Both alive again after one was written off.
r.deadA, r.deadB = false, false
mixed = make([]int16, n)
for i := 0; i < n; i++ {
mixed[i] = clampSum(scaleSample(r.bufA[i], r.gainA), scaleSample(r.bufB[i], r.gainB))
@@ -203,6 +263,12 @@ func (r *Recorder) mixTick() {
}
r.srcMu.Unlock()
r.store(mixed)
}
// store appends mixed samples to the pre-roll ring and, when a take is running,
// to the take itself.
func (r *Recorder) store(mixed []int16) {
if len(mixed) == 0 {
return
}
internal/audio/recorder_deadsource_test.go
+67
View File
@@ -0,0 +1,67 @@
package audio
import (
"testing"
"time"
)
// A silent second source must not silence the recording.
//
// From a real session: a Flex with "From Radio" on DAX RX and "Recording mic"
// on DAX Mic. In CW the mic path does not run, so DAX Mic delivered nothing —
// and because the mixer took min(len(A), len(B)) samples, nothing at all was
// recorded. The whole QSO ended in "recording was empty".
func TestMixerSurvivesASilentSource(t *testing.T) {
r := &Recorder{twoSrc: true, gainA: 1, gainB: 1, running: true, active: true, prerollSamples: sampleRate}
// The radio has been talking; the mic has not spoken for well over the
// grace period.
r.bufA = make([]int16, 800)
for i := range r.bufA {
r.bufA[i] = 1000
}
r.lastA = time.Now()
r.lastB = time.Now().Add(-5 * time.Second)
r.mixTick()
if len(r.acc) == 0 {
t.Fatal("nothing was recorded — a silent mic must not stop the radio being captured")
}
if r.acc[0] != 1000 {
t.Errorf("sample = %d, want 1000 — the live source must pass through unchanged", r.acc[0])
}
}
// While BOTH sources are alive the two are mixed, as before.
func TestMixerStillMixesBothSources(t *testing.T) {
r := &Recorder{twoSrc: true, gainA: 1, gainB: 1, running: true, active: true, prerollSamples: sampleRate}
r.bufA = []int16{100, 100, 100}
r.bufB = []int16{50, 50, 50}
now := time.Now()
r.lastA, r.lastB = now, now
r.mixTick()
if len(r.acc) != 3 {
t.Fatalf("recorded %d samples, want 3", len(r.acc))
}
if r.acc[0] != 150 {
t.Errorf("sample = %d, want 150 — both sources should be summed", r.acc[0])
}
}
// Before either source has EVER delivered, neither may be written off: at
// startup both timestamps are zero, and declaring one dead then would drop the
// first moments of every recording.
func TestMixerWaitsForBothAtStartup(t *testing.T) {
r := &Recorder{twoSrc: true, gainA: 1, gainB: 1, running: true, active: true, prerollSamples: sampleRate}
r.bufA = []int16{100, 100}
// lastA/lastB both zero — nothing has been heard from either yet.
r.mixTick()
if len(r.acc) != 0 {
t.Errorf("recorded %d samples before the second source was known to be silent", len(r.acc))
}
}