Alfred
/
fm-rds-tx
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 6 Вики Активность
Просмотр исходного кода

feat: stabilize live RDS output at hardware sample rates 

Keep DSP state persistent across generated frames, move the RDS encoder to arbitrary sample-rate operation, and tune the Pluto profile to the working 2.28 MHz path with the levels that finally decode reliably.
tags/v0.7.0-pre
Jan Svabenik 1 месяц назад
Родитель
e82bb3fd1a
Сommit
7cdc4b070c
6 измененных файлов: 444 добавлений и 417 удалений
Единый вид
Опции Diff
Показать статистику Скачать Patch файл Скачать Diff файл
  1. +4
    -4
      docs/config.plutosdr.json
  2. +5
    -14
      internal/app/engine.go
  3. +87
    -0
      internal/dsp/upsample.go
  4. +61
    -84
      internal/offline/generator.go
  5. +286
    -306
      internal/rds/encoder.go
  6. +1
    -9
      internal/rds/encoder_test.go

+ 4
- 4
docs/config.plutosdr.json Просмотреть файл

@@ -4,7 +4,7 @@
"gain": 1.0, "gain": 1.0,
"toneLeftHz": 400, "toneLeftHz": 400,
"toneRightHz": 2000, "toneRightHz": 2000,
"toneAmplitude": 0.4
"toneAmplitude": 0.3
}, },
"rds": { "rds": {
"enabled": true, "enabled": true,
@@ -16,8 +16,8 @@
"fm": { "fm": {
"frequencyMHz": 100.0, "frequencyMHz": 100.0,
"stereoEnabled": true, "stereoEnabled": true,
"pilotLevel": 0.09,
"rdsInjection": 0.04,
"pilotLevel": 0.041,
"rdsInjection": 0.021,
"preEmphasisTauUS": 50, "preEmphasisTauUS": 50,
"outputDrive": 2.2, "outputDrive": 2.2,
"compositeRateHz": 228000, "compositeRateHz": 228000,
@@ -30,7 +30,7 @@
"kind": "pluto", "kind": "pluto",
"device": "usb:", "device": "usb:",
"outputPath": "", "outputPath": "",
"deviceSampleRateHz": 2084000
"deviceSampleRateHz": 2280000
}, },
"control": { "control": {
"listenAddress": "127.0.0.1:8088" "listenAddress": "127.0.0.1:8088"


+ 5
- 14
internal/app/engine.go Просмотреть файл

@@ -8,7 +8,6 @@ import (
"time" "time"


cfgpkg "github.com/jan/fm-rds-tx/internal/config" cfgpkg "github.com/jan/fm-rds-tx/internal/config"

offpkg "github.com/jan/fm-rds-tx/internal/offline" offpkg "github.com/jan/fm-rds-tx/internal/offline"
"github.com/jan/fm-rds-tx/internal/platform" "github.com/jan/fm-rds-tx/internal/platform"
) )
@@ -67,13 +66,13 @@ type Engine struct {
} }


func NewEngine(cfg cfgpkg.Config, driver platform.SoapyDriver) *Engine { func NewEngine(cfg cfgpkg.Config, driver platform.SoapyDriver) *Engine {
// When device rate differs from composite rate, run the entire DSP chain
// at device rate directly. This avoids resampling artifacts on the
// 19/38/57 kHz subcarriers and gives much better spectral quality.
// Run entire DSP chain at device rate. RDS encoder resamples its
// PiFmRds waveform internally. No phase upsampling needed.
deviceRate := cfg.EffectiveDeviceRate() deviceRate := cfg.EffectiveDeviceRate()
if deviceRate > 0 && deviceRate != float64(cfg.FM.CompositeRateHz) {
if deviceRate > 0 {
cfg.FM.CompositeRateHz = int(deviceRate) cfg.FM.CompositeRateHz = int(deviceRate)
} }
cfg.FM.FMModulationEnabled = true


return &Engine{ return &Engine{
cfg: cfg, cfg: cfg,
@@ -159,22 +158,14 @@ func (e *Engine) Stats() EngineStats {
} }


func (e *Engine) run(ctx context.Context) { func (e *Engine) run(ctx context.Context) {
// Tight loop: generate → resample → push.
// The driver.Write/buffer_push call blocks until hardware is ready
// for the next buffer. This naturally paces to real-time.
// No ticker needed — the hardware clock drives the timing.
for { for {
if ctx.Err() != nil { if ctx.Err() != nil {
return return
} }

frame := e.generator.GenerateFrame(e.chunkDuration) frame := e.generator.GenerateFrame(e.chunkDuration)

n, err := e.driver.Write(ctx, frame) n, err := e.driver.Write(ctx, frame)
if err != nil { if err != nil {
if ctx.Err() != nil {
return
}
if ctx.Err() != nil { return }
e.lastError.Store(err.Error()) e.lastError.Store(err.Error())
e.underruns.Add(1) e.underruns.Add(1)
continue continue


+ 87
- 0
internal/dsp/upsample.go Просмотреть файл

@@ -0,0 +1,87 @@
package dsp

import (
"math"

"github.com/jan/fm-rds-tx/internal/output"
)

// FMPhaseUpsampler performs FM modulation + upsampling via phase-domain
// interpolation. Maintains continuous phase across successive calls.
type FMPhaseUpsampler struct {
srcRate float64
dstRate float64
maxDeviation float64
ratio float64
phase float64 // persistent across calls
}

func NewFMPhaseUpsampler(srcRate, dstRate, maxDeviation float64) *FMPhaseUpsampler {
return &FMPhaseUpsampler{
srcRate: srcRate,
dstRate: dstRate,
maxDeviation: maxDeviation,
ratio: dstRate / srcRate,
}
}

func (u *FMPhaseUpsampler) Process(frame *output.CompositeFrame) *output.CompositeFrame {
if frame == nil || len(frame.Samples) == 0 {
return frame
}

srcLen := len(frame.Samples)

// Accumulate phase at source rate, continuing from previous chunk
phases := make([]float64, srcLen)
for i, s := range frame.Samples {
u.phase += 2 * math.Pi * float64(s.I) * u.maxDeviation / u.srcRate
phases[i] = u.phase
}

// Keep phase bounded
if u.phase > 1e9 {
offset := math.Floor(u.phase/(2*math.Pi)) * 2 * math.Pi
u.phase -= offset
for i := range phases {
phases[i] -= offset
}
}

// Interpolate phase to target rate
dstLen := int(float64(srcLen) * u.ratio)
dst := make([]output.IQSample, dstLen)
step := 1.0 / u.ratio

pos := 0.0
for i := 0; i < dstLen; i++ {
idx := int(pos)
frac := pos - float64(idx)

var p float64
if idx+1 < srcLen {
p = phases[idx]*(1-frac) + phases[idx+1]*frac
} else if idx < srcLen {
p = phases[idx]
}

dst[i] = output.IQSample{
I: float32(math.Cos(p)),
Q: float32(math.Sin(p)),
}
pos += step
}

return &output.CompositeFrame{
Samples: dst,
SampleRateHz: u.dstRate,
Timestamp: frame.Timestamp,
Sequence: frame.Sequence,
}
}

// UpsampleFMPhase is the stateless version for offline/test use.
func UpsampleFMPhase(frame *output.CompositeFrame, targetRate, maxDeviation float64) *output.CompositeFrame {
u := NewFMPhaseUpsampler(frame.SampleRateHz, targetRate, maxDeviation)
return u.Process(frame)
}

+ 61
- 84
internal/offline/generator.go Просмотреть файл

@@ -58,12 +58,56 @@ type SourceInfo struct {


type Generator struct { type Generator struct {
cfg cfgpkg.Config cfg cfgpkg.Config

// Persistent DSP state across GenerateFrame calls
source *PreEmphasizedSource
stereoEncoder stereo.StereoEncoder
rdsEnc *rds.Encoder
combiner mpx.DefaultCombiner
limiter *dsp.MPXLimiter
fmMod *dsp.FMModulator
sampleRate float64
initialized bool
} }


func NewGenerator(cfg cfgpkg.Config) *Generator { func NewGenerator(cfg cfgpkg.Config) *Generator {
return &Generator{cfg: cfg} return &Generator{cfg: cfg}
} }


func (g *Generator) init() {
if g.initialized {
return
}
g.sampleRate = float64(g.cfg.FM.CompositeRateHz)
if g.sampleRate <= 0 {
g.sampleRate = 228000
}
rawSource, _ := g.sourceFor(g.sampleRate)
g.source = NewPreEmphasizedSource(rawSource, g.cfg.FM.PreEmphasisTauUS, g.sampleRate, g.cfg.Audio.Gain)
g.stereoEncoder = stereo.NewStereoEncoder(g.sampleRate)
g.combiner = mpx.DefaultCombiner{
MonoGain: 1.0, StereoGain: 1.0,
PilotGain: g.cfg.FM.PilotLevel, RDSGain: g.cfg.FM.RDSInjection,
}
if g.cfg.RDS.Enabled {
piCode, _ := cfgpkg.ParsePI(g.cfg.RDS.PI)
g.rdsEnc, _ = rds.NewEncoder(rds.RDSConfig{
PI: piCode, PS: g.cfg.RDS.PS, RT: g.cfg.RDS.RadioText,
PTY: uint8(g.cfg.RDS.PTY), SampleRate: g.sampleRate,
})
}
ceiling := g.cfg.FM.LimiterCeiling
if ceiling <= 0 { ceiling = 1.0 }
if g.cfg.FM.LimiterEnabled {
g.limiter = dsp.NewMPXLimiter(ceiling, 0.1, 50, g.sampleRate)
}
if g.cfg.FM.FMModulationEnabled {
g.fmMod = dsp.NewFMModulator(g.sampleRate)
if g.cfg.FM.MaxDeviationHz > 0 { g.fmMod.MaxDeviation = g.cfg.FM.MaxDeviationHz }
}
g.initialized = true
}

func (g *Generator) sourceFor(sampleRate float64) (frameSource, SourceInfo) { func (g *Generator) sourceFor(sampleRate float64) (frameSource, SourceInfo) {
if g.cfg.Audio.InputPath != "" { if g.cfg.Audio.InputPath != "" {
if src, err := audio.LoadWAVSource(g.cfg.Audio.InputPath); err == nil { if src, err := audio.LoadWAVSource(g.cfg.Audio.InputPath); err == nil {
@@ -75,116 +119,49 @@ func (g *Generator) sourceFor(sampleRate float64) (frameSource, SourceInfo) {
} }


func (g *Generator) GenerateFrame(duration time.Duration) *output.CompositeFrame { func (g *Generator) GenerateFrame(duration time.Duration) *output.CompositeFrame {
sampleRate := float64(g.cfg.FM.CompositeRateHz)
if sampleRate <= 0 {
sampleRate = 228000
}
samples := int(duration.Seconds() * sampleRate)
if samples <= 0 {
samples = int(sampleRate / 10)
}
g.init()

samples := int(duration.Seconds() * g.sampleRate)
if samples <= 0 { samples = int(g.sampleRate / 10) }


frame := &output.CompositeFrame{ frame := &output.CompositeFrame{
Samples: make([]output.IQSample, samples), Samples: make([]output.IQSample, samples),
SampleRateHz: sampleRate,
SampleRateHz: g.sampleRate,
Timestamp: time.Now().UTC(), Timestamp: time.Now().UTC(),
Sequence: 1, Sequence: 1,
} }


// Audio source with pre-emphasis applied at audio rate (before stereo encoding)
rawSource, _ := g.sourceFor(sampleRate)
source := NewPreEmphasizedSource(rawSource, g.cfg.FM.PreEmphasisTauUS, sampleRate, g.cfg.Audio.Gain)

// Stereo encoder (unity-normalized pilot + subcarrier)
stereoEncoder := stereo.NewStereoEncoder(sampleRate)

// MPX combiner — config values are direct linear injection levels, no magic numbers
combiner := mpx.DefaultCombiner{
MonoGain: 1.0,
StereoGain: 1.0,
PilotGain: g.cfg.FM.PilotLevel,
RDSGain: g.cfg.FM.RDSInjection,
}

// RDS encoder (unity-normalized output)
piCode, _ := cfgpkg.ParsePI(g.cfg.RDS.PI) // already validated
rdsEnc, _ := rds.NewEncoder(rds.RDSConfig{
PI: piCode,
PS: g.cfg.RDS.PS,
RT: g.cfg.RDS.RadioText,
PTY: uint8(g.cfg.RDS.PTY),
SampleRate: 228000, // RDS always at 228 kHz internally
})

// Limiter
var limiter *dsp.MPXLimiter
ceiling := g.cfg.FM.LimiterCeiling ceiling := g.cfg.FM.LimiterCeiling
if ceiling <= 0 {
ceiling = 1.0
}
if g.cfg.FM.LimiterEnabled {
limiter = dsp.NewMPXLimiter(ceiling, 0.1, 50, sampleRate)
}

// FM modulator
var fmMod *dsp.FMModulator
if g.cfg.FM.FMModulationEnabled {
fmMod = dsp.NewFMModulator(sampleRate)
if g.cfg.FM.MaxDeviationHz > 0 {
fmMod.MaxDeviation = g.cfg.FM.MaxDeviationHz
}
}
if ceiling <= 0 { ceiling = 1.0 }


// RDS runs at 228 kHz internally (4×57 kHz for exact carrier).
// We resample to composite rate using a fractional accumulator.
var rdsPhaseAcc float64 // fractional position in 228k stream
var rdsRatio float64 // compositeRate / 228000
var rdsPrev, rdsCur float64
if g.cfg.RDS.Enabled {
rdsRatio = sampleRate / 228000.0
// Pre-fetch first sample
rdsCur = rdsEnc.NextSample228k()
}

// --- Sample loop (zero-allocation hot path) ---
for i := 0; i < samples; i++ { for i := 0; i < samples; i++ {
in := source.NextFrame()
in := g.source.NextFrame()


comps := stereoEncoder.Encode(in)
comps := g.stereoEncoder.Encode(in)
if !g.cfg.FM.StereoEnabled { if !g.cfg.FM.StereoEnabled {
comps.Stereo = 0
comps.Pilot = 0
comps.Stereo = 0; comps.Pilot = 0
} }


rdsValue := 0.0 rdsValue := 0.0
if g.cfg.RDS.Enabled {
// Advance through the 228k RDS stream at composite rate
rdsPhaseAcc += 1.0 / rdsRatio // step in 228k domain
for rdsPhaseAcc >= 1.0 {
rdsPhaseAcc -= 1.0
rdsPrev = rdsCur
rdsCur = rdsEnc.NextSample228k()
}
// Linear interpolation between 228k samples
rdsValue = rdsPrev*(1.0-rdsPhaseAcc) + rdsCur*rdsPhaseAcc
if g.rdsEnc != nil {
rdsValue = g.rdsEnc.NextSample()
} }


composite := combiner.Combine(comps.Mono, comps.Stereo, comps.Pilot, rdsValue)
composite := g.combiner.Combine(comps.Mono, comps.Stereo, comps.Pilot, rdsValue)
composite *= g.cfg.FM.OutputDrive composite *= g.cfg.FM.OutputDrive


if limiter != nil {
composite = limiter.Process(composite)
composite = dsp.HardClip(composite, ceiling) // safety net only with limiter
if g.limiter != nil {
composite = g.limiter.Process(composite)
composite = dsp.HardClip(composite, ceiling)
} }


if fmMod != nil {
iq_i, iq_q := fmMod.Modulate(composite)
if g.fmMod != nil {
iq_i, iq_q := g.fmMod.Modulate(composite)
frame.Samples[i] = output.IQSample{I: float32(iq_i), Q: float32(iq_q)} frame.Samples[i] = output.IQSample{I: float32(iq_i), Q: float32(iq_q)}
} else { } else {
frame.Samples[i] = output.IQSample{I: float32(composite), Q: 0} frame.Samples[i] = output.IQSample{I: float32(composite), Q: 0}
} }
} }

return frame return frame
} }




+ 286
- 306
internal/rds/encoder.go Просмотреть файл

@@ -1,376 +1,356 @@
package rds package rds


// RDS encoder following the PiFmRds reference implementation.
// Generates shaped biphase BPSK at 228 kHz (4× 57 kHz).
//
// Architecture:
// raw bits → CRC+offset → differential encoding → shaped biphase waveform
// → 57 kHz modulation via {0,+1,0,-1} at 228 kHz
//
// The shaped biphase waveform is a pre-computed RRC-filtered Manchester pulse.
// Successive symbols overlap-add in a ring buffer, eliminating ISI.
// 57 kHz carrier is exact at 228 kHz (period = 4 samples), no sin() needed.
//
// Call NextSample228k() at exactly 228 kHz to get the modulated RDS subcarrier.
import "math"

// RDS encoder — port of PiFmRds, adapted for arbitrary sample rates.
// At 228 kHz: uses exact {0,+1,0,-1} carrier (identical to PiFmRds).
// At other rates: uses sin() carrier, with integer samples-per-bit when possible.
// The biphase waveform from PiFmRds is resampled to the target rate.


const ( const (
rdsRate = 228000.0 // internal sample rate, must be 4×57000
rdsBitRate = 1187.5 // bits per second
samplesPerBit = 192 // rdsRate / rdsBitRate = 228000/1187.5 = 192
refRate = 228000.0 // PiFmRds native rate
rdsBitRate = 1187.5
refSPB = 192 // refRate / rdsBitRate
bitsPerBlock = 26 bitsPerBlock = 26
bitsPerGroup = 4 * bitsPerBlock // 104
bitsPerGroup = 4 * bitsPerBlock
refFilterSize = 576 // PiFmRds waveform length at 228k
) )


const crcPoly = 0x1B9 const crcPoly = 0x1B9

var offsetWords = map[byte]uint16{
'A': 0x0FC, 'B': 0x198, 'C': 0x168, 'c': 0x350, 'D': 0x1B4,
}
var offsetWords = map[byte]uint16{'A': 0x0FC, 'B': 0x198, 'C': 0x168, 'c': 0x350, 'D': 0x1B4}


func crc10(data uint16) uint16 { func crc10(data uint16) uint16 {
var reg uint32 = uint32(data) << 10 var reg uint32 = uint32(data) << 10
for i := 15; i >= 0; i-- { for i := 15; i >= 0; i-- {
if reg&(1<<(uint(i)+10)) != 0 {
reg ^= uint32(crcPoly) << uint(i)
}
if reg&(1<<(uint(i)+10)) != 0 { reg ^= uint32(crcPoly) << uint(i) }
} }
return uint16(reg & 0x3FF) return uint16(reg & 0x3FF)
} }

func encodeBlock(data uint16, offset byte) uint32 { func encodeBlock(data uint16, offset byte) uint32 {
return (uint32(data) << 10) | uint32(crc10(data)^offsetWords[offset]) return (uint32(data) << 10) | uint32(crc10(data)^offsetWords[offset])
} }

// --- Group building (unchanged) ---

func buildGroup0A(pi uint16, pty uint8, tp, ta bool, segIdx int, ps string) [4]uint16 { func buildGroup0A(pi uint16, pty uint8, tp, ta bool, segIdx int, ps string) [4]uint16 {
ps = normalizePS(ps)
var bB uint16
if tp {
bB |= 1 << 10
}
bB |= uint16(pty&0x1F) << 5
if ta {
bB |= 1 << 4
}
bB |= 1 << 3
bB |= uint16(segIdx & 0x03)
ps = normalizePS(ps); var bB uint16
if tp { bB |= 1 << 10 }; bB |= uint16(pty&0x1F) << 5
if ta { bB |= 1 << 4 }; bB |= 1 << 3; bB |= uint16(segIdx & 0x03)
ci := segIdx * 2 ci := segIdx * 2
return [4]uint16{pi, bB, pi, (uint16(ps[ci]) << 8) | uint16(ps[ci+1])} return [4]uint16{pi, bB, pi, (uint16(ps[ci]) << 8) | uint16(ps[ci+1])}
} }

func buildGroup2A(pi uint16, pty uint8, tp bool, abFlag bool, segIdx int, rt string) [4]uint16 { func buildGroup2A(pi uint16, pty uint8, tp bool, abFlag bool, segIdx int, rt string) [4]uint16 {
rt = normalizeRT(rt)
var bB uint16 = 2 << 12
if tp {
bB |= 1 << 10
}
bB |= uint16(pty&0x1F) << 5
if abFlag {
bB |= 1 << 4
}
bB |= uint16(segIdx & 0x0F)
ci := segIdx * 4
c0, c1, c2, c3 := padRT(rt, ci)
rt = normalizeRT(rt); var bB uint16 = 2 << 12
if tp { bB |= 1 << 10 }; bB |= uint16(pty&0x1F) << 5
if abFlag { bB |= 1 << 4 }; bB |= uint16(segIdx & 0x0F)
ci := segIdx * 4; c0, c1, c2, c3 := padRT(rt, ci)
return [4]uint16{pi, bB, (uint16(c0) << 8) | uint16(c1), (uint16(c2) << 8) | uint16(c3)} return [4]uint16{pi, bB, (uint16(c0) << 8) | uint16(c1), (uint16(c2) << 8) | uint16(c3)}
} }

func padRT(rt string, off int) (byte, byte, byte, byte) { func padRT(rt string, off int) (byte, byte, byte, byte) {
g := func(i int) byte {
if i < len(rt) {
return rt[i]
}
return ' '
}
return g(off), g(off + 1), g(off + 2), g(off + 3)
g := func(i int) byte { if i < len(rt) { return rt[i] }; return ' ' }
return g(off), g(off+1), g(off+2), g(off+3)
} }

// --- Group scheduler (unchanged) ---

type GroupScheduler struct {
cfg RDSConfig
psIdx int
rtIdx int
phase int
rtABFlag bool
}

func newGroupScheduler(cfg RDSConfig) *GroupScheduler {
return &GroupScheduler{cfg: cfg}
}

type GroupScheduler struct { cfg RDSConfig; psIdx, rtIdx, phase int; rtABFlag bool }
func newGroupScheduler(cfg RDSConfig) *GroupScheduler { return &GroupScheduler{cfg: cfg} }
func (gs *GroupScheduler) NextGroup() [4]uint16 { func (gs *GroupScheduler) NextGroup() [4]uint16 {
if gs.phase < 4 { if gs.phase < 4 {
g := buildGroup0A(gs.cfg.PI, gs.cfg.PTY, gs.cfg.TP, gs.cfg.TA, gs.psIdx, gs.cfg.PS) g := buildGroup0A(gs.cfg.PI, gs.cfg.PTY, gs.cfg.TP, gs.cfg.TA, gs.psIdx, gs.cfg.PS)
gs.psIdx = (gs.psIdx + 1) % 4
gs.phase++
return g
gs.psIdx = (gs.psIdx + 1) % 4; gs.phase++; return g
} }
g := buildGroup2A(gs.cfg.PI, gs.cfg.PTY, gs.cfg.TP, gs.rtABFlag, gs.rtIdx, gs.cfg.RT) g := buildGroup2A(gs.cfg.PI, gs.cfg.PTY, gs.cfg.TP, gs.rtABFlag, gs.rtIdx, gs.cfg.RT)
gs.rtIdx++
rtSegs := rtSegmentCount(gs.cfg.RT)
if gs.rtIdx >= rtSegs {
gs.rtIdx = 0
gs.rtABFlag = !gs.rtABFlag
}
gs.phase++
if gs.phase >= 4+rtSegs {
gs.phase = 0
}
return g
gs.rtIdx++; rtSegs := rtSegmentCount(gs.cfg.RT)
if gs.rtIdx >= rtSegs { gs.rtIdx = 0; gs.rtABFlag = !gs.rtABFlag }
gs.phase++; if gs.phase >= 4+rtSegs { gs.phase = 0 }; return g
} }

func rtSegmentCount(rt string) int { func rtSegmentCount(rt string) int {
rt = normalizeRT(rt)
n := (len(rt) + 3) / 4
if n == 0 {
n = 1
}
if n > 16 {
n = 16
}
return n
}

// --- Differential encoder ---

type diffEncoder struct{ prev uint8 }

func (d *diffEncoder) encode(bit uint8) uint8 {
out := d.prev ^ bit
d.prev = out
return out
}

// --- Biphase waveform ---
// A biphase symbol at 228 kHz / 1187.5 bps = 192 samples per bit.
// First half (96 samples): +1, second half (96 samples): -1.
// This is the "rectangular biphase pulse". PiFmRds uses an RRC-shaped
// version, but even rectangular works for most receivers. We apply a
// simple raised-cosine taper at the transitions to reduce spectral splatter.
//
// The waveform is 192 samples long. It gets overlap-added into the ring
// buffer, so adjacent symbols blend at boundaries.

const waveformLen = samplesPerBit // 192
const taperLen = 8 // smooth transitions over 8 samples

var biphaseWaveform [waveformLen]float32

func init() {
// Generate biphase pulse: +1 for first half, -1 for second half,
// with raised-cosine tapered transitions.
half := waveformLen / 2
for i := 0; i < waveformLen; i++ {
if i < half {
biphaseWaveform[i] = 1.0
} else {
biphaseWaveform[i] = -1.0
}
}
// Taper at start (0 → +1)
for i := 0; i < taperLen; i++ {
t := float32(i) / float32(taperLen)
biphaseWaveform[i] *= t
}
// Taper at midpoint (+1 → -1): ramp over taperLen samples centered at half
for i := 0; i < taperLen; i++ {
t := float32(i) / float32(taperLen)
// Crossfade from +1 to -1
idx := half - taperLen/2 + i
if idx >= 0 && idx < waveformLen {
biphaseWaveform[idx] = 1.0 - 2.0*t
}
}
// Taper at end (-1 → 0)
for i := 0; i < taperLen; i++ {
t := float32(i) / float32(taperLen)
biphaseWaveform[waveformLen-1-i] *= t
}
rt = normalizeRT(rt); n := (len(rt)+3)/4
if n == 0 { n = 1 }; if n > 16 { n = 16 }; return n
} }


// --- Encoder ---

const ringSize = samplesPerBit + waveformLen // overlap region

// Encoder generates RDS subcarrier samples at 228 kHz.
// Call NextSample228k() at 228 kHz rate to get modulated output.
// Encoder generates RDS subcarrier samples at any sample rate.
// Uses the PiFmRds waveform resampled to the target rate.
type Encoder struct { type Encoder struct {
config RDSConfig config RDSConfig
scheduler *GroupScheduler scheduler *GroupScheduler
diff diffEncoder

// Bit stream
bitBuf [bitsPerGroup]int
bitLen int
bitPos int
sampleRate float64
spb int // samples per bit at target rate
waveform []float64 // resampled PiFmRds waveform
wfLen int // length of resampled waveform
ring []float64 // overlap-add ring buffer
ringSize int
bitBuffer [bitsPerGroup]int
bitPos int
prevOutput int
curOutput int
sampleCount int
inSampleIdx int
outSampleIdx int
carrierPhase float64 // for sin() carrier at non-228k rates
carrierStep float64


// Ring buffer for overlap-add shaped biphase
ring [ringSize]float32
ringWrite int // next write position for new symbol
ringRead int // current read position

// Sample counter within current bit
sampleCount int

// 57 kHz carrier phase: cycles through 0,1,2,3 at 228 kHz
carrierPhase int

// For backward-compat Generate() used in tests
SampleRate float64 SampleRate float64
} }


func NewEncoder(cfg RDSConfig) (*Encoder, error) { func NewEncoder(cfg RDSConfig) (*Encoder, error) {
if cfg.SampleRate <= 0 {
cfg.SampleRate = rdsRate
if cfg.SampleRate <= 0 { cfg.SampleRate = refRate }
cfg.PS = normalizePS(cfg.PS); cfg.RT = normalizeRT(cfg.RT)
rate := cfg.SampleRate
spb := int(math.Round(rate / rdsBitRate))
ratio := rate / refRate
// Resample PiFmRds waveform to target rate
wfLen := int(math.Round(float64(refFilterSize) * ratio))
waveform := make([]float64, wfLen)
for i := range waveform {
srcPos := float64(i) / ratio
idx := int(srcPos)
frac := srcPos - float64(idx)
if idx+1 < refFilterSize {
waveform[i] = refWaveform[idx]*(1-frac) + refWaveform[idx+1]*frac
} else if idx < refFilterSize {
waveform[i] = refWaveform[idx]
}
} }
cfg.PS = normalizePS(cfg.PS)
cfg.RT = normalizeRT(cfg.RT)

ringSize := spb + wfLen
enc := &Encoder{ enc := &Encoder{
config: cfg,
SampleRate: cfg.SampleRate,
scheduler: newGroupScheduler(cfg),
config: cfg,
scheduler: newGroupScheduler(cfg),
sampleRate: rate,
spb: spb,
waveform: waveform,
wfLen: wfLen,
ring: make([]float64, ringSize),
ringSize: ringSize,
bitPos: bitsPerGroup,
sampleCount: spb,
outSampleIdx: ringSize - 1,
carrierStep: 57000.0 / rate,
SampleRate: rate,
} }
enc.loadNextGroup()
// Pre-load first symbol into ring buffer
enc.emitSymbol()
return enc, nil return enc, nil
} }


func (e *Encoder) Reset() { func (e *Encoder) Reset() {
e.diff = diffEncoder{}
e.scheduler = newGroupScheduler(e.config) e.scheduler = newGroupScheduler(e.config)
e.bitLen = 0
e.bitPos = 0
e.sampleCount = 0
e.bitPos = bitsPerGroup; e.sampleCount = e.spb
e.prevOutput = 0; e.curOutput = 0
e.inSampleIdx = 0; e.outSampleIdx = e.ringSize - 1
e.carrierPhase = 0 e.carrierPhase = 0
e.ringWrite = 0
e.ringRead = 0
for i := range e.ring {
e.ring[i] = 0
}
e.loadNextGroup()
e.emitSymbol()
for i := range e.ring { e.ring[i] = 0 }
} }


// NextSample228k returns the next RDS subcarrier sample.
// MUST be called at exactly 228000 Hz.
// Output is the shaped biphase envelope modulated onto 57 kHz.
func (e *Encoder) NextSample228k() float64 {
// Read shaped envelope from ring buffer
envelope := float64(e.ring[e.ringRead])
e.ring[e.ringRead] = 0 // clear after reading
e.ringRead++
if e.ringRead >= ringSize {
e.ringRead = 0
}

// Advance sample counter; emit next symbol when bit period ends
e.sampleCount++
if e.sampleCount >= samplesPerBit {
e.sampleCount = 0
e.bitPos++
if e.bitPos >= e.bitLen {
e.loadNextGroup()
// NextSample returns the next RDS subcarrier sample at the configured rate.
func (e *Encoder) NextSample() float64 {
if e.sampleCount >= e.spb {
if e.bitPos >= bitsPerGroup {
e.getRDSGroup()
e.bitPos = 0
} }
e.emitSymbol()
}

// 57 kHz modulation: at 228 kHz, period = 4 samples.
// Phase pattern: {0, +1, 0, -1} → multiply envelope by carrier
var carrier float64
switch e.carrierPhase {
case 0:
carrier = 0
case 1:
carrier = 1
case 2:
carrier = 0
case 3:
carrier = -1
}
e.carrierPhase++
if e.carrierPhase >= 4 {
e.carrierPhase = 0
// Differential encoding (PiFmRds-exact)
curBit := e.bitBuffer[e.bitPos]
e.prevOutput = e.curOutput
e.curOutput = e.prevOutput ^ curBit
inverting := (e.curOutput == 1)
// Overlap-add waveform
idx := e.inSampleIdx
for j := 0; j < e.wfLen; j++ {
val := e.waveform[j]
if inverting { val = -val }
e.ring[idx] += val
idx++; if idx >= e.ringSize { idx = 0 }
}
e.inSampleIdx += e.spb
if e.inSampleIdx >= e.ringSize { e.inSampleIdx -= e.ringSize }
e.bitPos++
e.sampleCount = 0
} }

// Read envelope from ring buffer
envelope := e.ring[e.outSampleIdx]
e.ring[e.outSampleIdx] = 0
e.outSampleIdx++; if e.outSampleIdx >= e.ringSize { e.outSampleIdx = 0 }
// 57 kHz carrier
carrier := math.Sin(2 * math.Pi * e.carrierPhase)
e.carrierPhase += e.carrierStep
if e.carrierPhase >= 1.0 { e.carrierPhase -= 1.0 }
e.sampleCount++
return envelope * carrier return envelope * carrier
} }


// emitSymbol writes the shaped biphase waveform for the current bit
// into the ring buffer using overlap-add.
func (e *Encoder) emitSymbol() {
// Differential encoding output determines polarity
diffBit := e.bitBuf[e.bitPos]
sign := float32(1.0)
if diffBit == 1 {
sign = -1.0
}

// Overlap-add the biphase waveform into the ring buffer
idx := e.ringWrite
for i := 0; i < waveformLen; i++ {
e.ring[idx] += biphaseWaveform[i] * sign
idx++
if idx >= ringSize {
idx = 0
}
}
e.ringWrite += samplesPerBit
if e.ringWrite >= ringSize {
e.ringWrite -= ringSize
}
// NextSample228k is an alias for backward compat
func (e *Encoder) NextSample228k() float64 { return e.NextSample() }
func (e *Encoder) Generate(n int) []float64 {
out := make([]float64, n); for i := range out { out[i] = e.NextSample() }; return out
}
func (e *Encoder) Symbol() float64 {
if e.bitPos >= bitsPerGroup { return -1 }
sym := 1.0; if e.bitBuffer[e.bitPos] == 0 { sym = -1.0 }
e.sampleCount++
if e.sampleCount >= e.spb { e.sampleCount = 0; e.bitPos++
if e.bitPos >= bitsPerGroup { e.getRDSGroup(); e.bitPos = 0 }
}; return sym
} }


func (e *Encoder) loadNextGroup() {
group := e.scheduler.NextGroup()
e.bitLen = 0
func (e *Encoder) getRDSGroup() {
group := e.scheduler.NextGroup(); pos := 0
for blk, off := range [4]byte{'A', 'B', 'C', 'D'} { for blk, off := range [4]byte{'A', 'B', 'C', 'D'} {
enc := encodeBlock(group[blk], off)
encoded := encodeBlock(group[blk], off)
for bit := bitsPerBlock - 1; bit >= 0; bit-- { for bit := bitsPerBlock - 1; bit >= 0; bit-- {
raw := uint8((enc >> uint(bit)) & 1)
e.bitBuf[e.bitLen] = int(e.diff.encode(raw))
e.bitLen++
e.bitBuffer[pos] = int((encoded >> uint(bit)) & 1); pos++
} }
} }
e.bitPos = 0
}

// --- Backward-compatible API for tests ---

// NextSample returns a single RDS sample at 228 kHz. Same as NextSample228k.
func (e *Encoder) NextSample() float64 {
return e.NextSample228k()
} }


// Generate produces n RDS samples at 228 kHz.
func (e *Encoder) Generate(n int) []float64 {
out := make([]float64, n)
for i := range out {
out[i] = e.NextSample228k()
}
return out
}


// Symbol returns +1/-1 for the current differential bit (NRZ, no biphase).
// Only for the software decoder test path.
func (e *Encoder) Symbol() float64 {
if e.bitLen == 0 {
return -1
}
sym := float64(1)
if e.bitBuf[e.bitPos] == 0 {
sym = -1
}
// Advance bit clock at 228 kHz rate
e.sampleCount++
if e.sampleCount >= samplesPerBit {
e.sampleCount = 0
e.bitPos++
if e.bitPos >= e.bitLen {
e.loadNextGroup()
}
}
return sym
// refWaveform — exact PiFmRds waveform_biphase (576 samples at 228 kHz)
var refWaveform = [576]float64{
2.532651330219518743e-03, 2.555044910373570170e-03, 2.566671021257086772e-03, 2.567238549701184643e-03,
2.556496746672830885e-03, 2.534237165729987841e-03, 2.500295472534516759e-03, 2.454553115509106563e-03,
2.396938848057333059e-03, 2.327430093141364103e-03, 2.246054141429317842e-03, 2.152889174683249481e-03,
2.048065106558019741e-03, 1.931764233519830953e-03, 1.804221689169753116e-03, 1.665725695871127275e-03,
1.516617608227482320e-03, 1.357291743639731877e-03, 1.188194995883951532e-03, 1.009826228393920439e-03,
8.227354447016149448e-04, 6.275227342843667493e-04, 4.248369928834821877e-04, 2.153744171968115500e-04,
-1.232252981576898894e-07, -2.208705497650993482e-04, -4.460407281680368592e-04, -6.747678807736505729e-04,
-9.061496807071534867e-04, -1.139250166374730904e-03, -1.373102755669571148e-03, -1.606713454985107814e-03,
-1.839064255174424622e-03, -2.069116705719896768e-03, -2.295815657515722953e-03, -2.518093163822523149e-03,
-2.734872528130168675e-03, -2.945072486864876073e-03, -3.147611514104867864e-03, -3.341412234726898710e-03,
-3.525405931697330516e-03, -3.698537132549940647e-03, -3.859768259460998226e-03, -4.008084326742814528e-03,
-4.142497669033530158e-03, -4.262052682966127777e-03, -4.365830564655405997e-03, -4.452954024951411884e-03,
-4.522591964073326663e-03, -4.573964086961633882e-03, -4.606345440470235343e-03, -4.619070853366329284e-03,
-4.611539260015793187e-03, -4.583217888607013166e-03, -4.533646294807957243e-03, -4.462440221861094410e-03,
-4.369295268298792508e-03, -4.253990344709691375e-03, -4.116390901303888447e-03, -3.956451908412099601e-03,
-3.774220572511344761e-03, -3.569838770897127041e-03, -3.343545188717922216e-03, -3.095677142753055708e-03,
-2.826672077047463587e-03, -2.537068716315400187e-03, -2.227507863888385838e-03, -1.898732831910291503e-03,
-1.551589492469313079e-03, -1.187025939403796478e-03, -8.060917516227311674e-04, -4.099368499382796552e-04,
1.900593832358028364e-07, 4.229434598897815903e-04, 8.568834232677739271e-04, 1.300478433616307234e-03,
1.752108639186909398e-03, 2.210069531690153112e-03, 2.672576051828062533e-03, 3.137767118244720512e-03,
3.603710575596331869e-03, 4.068408555938784511e-03, 4.529803246113349099e-03, 4.985783052286746689e-03,
5.434189151275972511e-03, 5.872822416766181226e-03, 6.299450707012693891e-03, 6.711816499117106809e-03,
7.107644853482626354e-03, 7.484651690592414135e-03, 7.840552360821295350e-03, 8.173070486592225875e-03,
8.479947054827158270e-03, 8.758949736324453048e-03, 9.007882407426009638e-03, 9.224594848121719579e-03,
9.406992589581098657e-03, 9.553046883008396370e-03, 9.660804760689966145e-03, 9.728399159148424027e-03,
9.754059073439845171e-03, 9.736119710831808022e-03, 9.673032611387005070e-03, 9.563375702351037400e-03,
9.405863252709357331e-03, 9.199355693838612638e-03, 8.942869271836061465e-03, 8.635585496870153838e-03,
8.276860354756325477e-03, 7.866233245929400361e-03, 7.403435617058454557e-03, 6.888399250731210011e-03,
6.321264178928198696e-03, 5.702386186409919011e-03, 5.032343870653735625e-03, 4.311945225603512621e-03,
3.542233717233159249e-03, 2.724493819771388933e-03, 1.860255982396226328e-03, 9.513009972738021430e-04,
-3.362590087872507610e-07, -9.923637372837323424e-04, -2.022229806201048148e-03, -3.087121544982383836e-03,
-4.183963760744797630e-03, -5.309418750929982035e-03, -6.459886829603163697e-03, -7.631507634530486361e-03,
-8.820162230001177273e-03, -1.002147601834123269e-02, -1.123082247097366773e-02, -1.244332768771695338e-02,
-1.365387579078745396e-02, -1.485711515769077770e-02, -1.604746549484995649e-02, -1.721912575143924595e-02,
-1.836608287047301891e-02, -1.948212137174597930e-02, -2.056083375874448449e-02, -2.159563173915068912e-02,
-2.257975824605283968e-02, -2.350630024446240945e-02, -2.436820230522675906e-02, -2.515828092592677437e-02,
-2.586923957586502801e-02, -2.649368443979239693e-02, -2.702414083259563338e-02, -2.745307025478293042e-02,
-2.777288805626721910e-02, -2.797598167366384739e-02, -2.805472940409954943e-02, -2.800151967637884431e-02,
-2.780877077828078359e-02, -2.746895099676937430e-02, -2.697459912600155829e-02, -2.631834529621684959e-02,
-2.549293207489373297e-02, -2.449123578997222314e-02, -2.330628802347053594e-02, -2.193129722247495056e-02,
-2.035967037326144244e-02, -1.858503468321714980e-02, -1.660125921427981280e-02, -1.440247641080375819e-02,
-1.198310346409471074e-02, -9.337863455345842695e-03, -6.461806218342813941e-03, -3.350328863101498331e-03,
8.040984433930472399e-07, 3.595441083468180719e-03, 7.437024284502863521e-03, 1.152857108893870150e-02,
1.587265612925233688e-02, 2.047139402062919666e-02, 2.532642284173815955e-02, 3.043888841331177791e-02,
3.580942942793266526e-02, 4.143816348300550373e-02, 4.732467406731786369e-02, 5.346799854986208217e-02,
5.986661721770201311e-02, 6.651844340763700403e-02, 7.342081477423043068e-02, 8.057048573445227402e-02,
8.796362112672609368e-02, 9.559579111958180220e-02, 1.034619674024025021e-01, 1.115565206879204074e-01,
1.198732195531727329e-01, 1.284052306425759737e-01, 1.371451202536290992e-01, 1.460848573225170255e-01,
1.552158178235605868e-01, 1.645287905930657713e-01, 1.740139845846588318e-01, 1.836610375596755829e-01,
1.934590262126028026e-01, 2.033964777279658187e-01, 2.134613827614141035e-01, 2.236412098341045707e-01,
2.339229211258132823e-01, 2.442929896485369901e-01, 2.547374177786905780e-01, 2.652417571223665282e-01,
2.757911296845135252e-01, 2.863702503093192853e-01, 2.969634503555686478e-01, 3.075547025672780710e-01,
3.181276470965210823e-01, 3.286656186320493500e-01, 3.391516745840755798e-01, 3.495686242724773130e-01,
3.598990590626389707e-01, 3.701253833902611312e-01, 3.802298466136770361e-01, 3.901945756295767120e-01,
4.000016081911345056e-01, 4.096329268202659746e-01, 4.190704933607786176e-01, 4.282962839026540069e-01,
4.372923241989370990e-01, 4.460407253805190875e-01, 4.545237199298762798e-01, 4.627236978285061975e-01,
4.706232427973597865e-01, 4.782051685485750880e-01, 4.854525549661181105e-01, 4.923487841323866965e-01,
4.988775761175122669e-01, 5.050230244479789743e-01, 5.107696311712632831e-01, 5.161023414335079718e-01,
5.210065774877549183e-01, 5.254682720509856741e-01, 5.294739009291574705e-01, 5.330105148305670504e-01,
5.360657702892279719e-01, 5.386279596215074461e-01, 5.406860398410284763e-01, 5.422296604588032753e-01,
5.432491900977250987e-01, 5.437357418528805386e-01, 5.436811973316860724e-01, 5.430782293105560488e-01,
5.419203229476984296e-01, 5.402017954946758405e-01, 5.379178144525937899e-01, 5.350644141221254646e-01,
5.316385105000952516e-01, 5.276379144789866693e-01, 5.230613433094983833e-01, 5.179084302901690862e-01,
5.121797326520726168e-01, 5.058767376106826363e-01, 4.990018665611814508e-01, 4.915584773977406674e-01,
4.835508649416218607e-01, 4.749842594673260865e-01, 4.658648233204350508e-01, 4.561996456252422338e-01,
4.459967350847497403e-01, 4.352650108800791839e-01, 4.240142916808554152e-01, 4.122552827825399224e-01,
3.999995613968218566e-01, 3.872595600805870397e-01, 3.740485484506272384e-01, 3.603806130210642222e-01,
3.462706353977916263e-01, 3.317342687539049928e-01, 3.167879126713797899e-01, 3.014486863933045213e-01,
2.857344005404113818e-01, 2.696635273493745433e-01, 2.532551694939167986e-01, 2.365290275532226649e-01,
2.195053661954201318e-01, 2.022049791470396651e-01, 1.846491530223047517e-01, 1.668596300888892936e-01,
1.488585700493792463e-01, 1.306685109200720063e-01, 1.123123290909592703e-01, 9.381319865274144465e-02,
7.519455007851447159e-02, 5.648002834935082067e-02, 3.769345061436135680e-02, 1.885876347696378158e-02,
0.000000000000000000e+00, -1.885876347696378158e-02, -3.769345061436135680e-02, -5.648002834935082067e-02,
-7.519455007851447159e-02, -9.381319865274144465e-02, -1.123123290909592703e-01, -1.306685109200720063e-01,
-1.488585700493792463e-01, -1.668596300888892936e-01, -1.846491530223047517e-01, -2.022049791470396651e-01,
-2.195053661954201318e-01, -2.365290275532226649e-01, -2.532551694939167986e-01, -2.696635273493745433e-01,
-2.857344005404113818e-01, -3.014486863933045213e-01, -3.167879126713797899e-01, -3.317342687539049928e-01,
-3.462706353977916263e-01, -3.603806130210642222e-01, -3.740485484506272384e-01, -3.872595600805870397e-01,
-3.999995613968218566e-01, -4.122552827825399224e-01, -4.240142916808554152e-01, -4.352650108800791839e-01,
-4.459967350847497403e-01, -4.561996456252422338e-01, -4.658648233204350508e-01, -4.749842594673260865e-01,
-4.835508649416218607e-01, -4.915584773977406674e-01, -4.990018665611814508e-01, -5.058767376106826363e-01,
-5.121797326520726168e-01, -5.179084302901690862e-01, -5.230613433094983833e-01, -5.276379144789866693e-01,
-5.316385105000952516e-01, -5.350644141221254646e-01, -5.379178144525937899e-01, -5.402017954946758405e-01,
-5.419203229476984296e-01, -5.430782293105560488e-01, -5.436811973316860724e-01, -5.437357418528805386e-01,
-5.432491900977250987e-01, -5.422296604588032753e-01, -5.406860398410284763e-01, -5.386279596215074461e-01,
-5.360657702892279719e-01, -5.330105148305670504e-01, -5.294739009291574705e-01, -5.254682720509856741e-01,
-5.210065774877549183e-01, -5.161023414335079718e-01, -5.107696311712632831e-01, -5.050230244479789743e-01,
-4.988775761175122669e-01, -4.923487841323866965e-01, -4.854525549661181105e-01, -4.782051685485750880e-01,
-4.706232427973597865e-01, -4.627236978285061975e-01, -4.545237199298762798e-01, -4.460407253805190875e-01,
-4.372923241989370990e-01, -4.282962839026540069e-01, -4.190704933607786176e-01, -4.096329268202659746e-01,
-4.000016081911345056e-01, -3.901945756295767120e-01, -3.802298466136770361e-01, -3.701253833902611312e-01,
-3.598990590626389707e-01, -3.495686242724773130e-01, -3.391516745840755798e-01, -3.286656186320493500e-01,
-3.181276470965210823e-01, -3.075547025672780710e-01, -2.969634503555686478e-01, -2.863702503093192853e-01,
-2.757911296845135252e-01, -2.652417571223665282e-01, -2.547374177786905780e-01, -2.442929896485369901e-01,
-2.339229211258132823e-01, -2.236412098341045707e-01, -2.134613827614141035e-01, -2.033964777279658187e-01,
-1.934590262126028026e-01, -1.836610375596755829e-01, -1.740139845846588318e-01, -1.645287905930657713e-01,
-1.552158178235605868e-01, -1.460848573225170255e-01, -1.371451202536290992e-01, -1.284052306425759737e-01,
-1.198732195531727329e-01, -1.115565206879204074e-01, -1.034619674024025021e-01, -9.559579111958180220e-02,
-8.796362112672609368e-02, -8.057048573445227402e-02, -7.342081477423043068e-02, -6.651844340763700403e-02,
-5.986661721770201311e-02, -5.346799854986208217e-02, -4.732467406731786369e-02, -4.143816348300550373e-02,
-3.580942942793266526e-02, -3.043888841331177791e-02, -2.532642284173815955e-02, -2.047139402062919666e-02,
-1.587265612925233688e-02, -1.152857108893870150e-02, -7.437024284502863521e-03, -3.595441083468180719e-03,
-8.040984433930472399e-07, 3.350328863101498331e-03, 6.461806218342813941e-03, 9.337863455345842695e-03,
1.198310346409471074e-02, 1.440247641080375819e-02, 1.660125921427981280e-02, 1.858503468321714980e-02,
2.035967037326144244e-02, 2.193129722247495056e-02, 2.330628802347053594e-02, 2.449123578997222314e-02,
2.549293207489373297e-02, 2.631834529621684959e-02, 2.697459912600155829e-02, 2.746895099676937430e-02,
2.780877077828078359e-02, 2.800151967637884431e-02, 2.805472940409954943e-02, 2.797598167366384739e-02,
2.777288805626721910e-02, 2.745307025478293042e-02, 2.702414083259563338e-02, 2.649368443979239693e-02,
2.586923957586502801e-02, 2.515828092592677437e-02, 2.436820230522675906e-02, 2.350630024446240945e-02,
2.257975824605283968e-02, 2.159563173915068912e-02, 2.056083375874448449e-02, 1.948212137174597930e-02,
1.836608287047301891e-02, 1.721912575143924595e-02, 1.604746549484995649e-02, 1.485711515769077770e-02,
1.365387579078745396e-02, 1.244332768771695338e-02, 1.123082247097366773e-02, 1.002147601834123269e-02,
8.820162230001177273e-03, 7.631507634530486361e-03, 6.459886829603163697e-03, 5.309418750929982035e-03,
4.183963760744797630e-03, 3.087121544982383836e-03, 2.022229806201048148e-03, 9.923637372837323424e-04,
3.362590087872507610e-07, -9.513009972738021430e-04, -1.860255982396226328e-03, -2.724493819771388933e-03,
-3.542233717233159249e-03, -4.311945225603512621e-03, -5.032343870653735625e-03, -5.702386186409919011e-03,
-6.321264178928198696e-03, -6.888399250731210011e-03, -7.403435617058454557e-03, -7.866233245929400361e-03,
-8.276860354756325477e-03, -8.635585496870153838e-03, -8.942869271836061465e-03, -9.199355693838612638e-03,
-9.405863252709357331e-03, -9.563375702351037400e-03, -9.673032611387005070e-03, -9.736119710831808022e-03,
-9.754059073439845171e-03, -9.728399159148424027e-03, -9.660804760689966145e-03, -9.553046883008396370e-03,
-9.406992589581098657e-03, -9.224594848121719579e-03, -9.007882407426009638e-03, -8.758949736324453048e-03,
-8.479947054827158270e-03, -8.173070486592225875e-03, -7.840552360821295350e-03, -7.484651690592414135e-03,
-7.107644853482626354e-03, -6.711816499117106809e-03, -6.299450707012693891e-03, -5.872822416766181226e-03,
-5.434189151275972511e-03, -4.985783052286746689e-03, -4.529803246113349099e-03, -4.068408555938784511e-03,
-3.603710575596331869e-03, -3.137767118244720512e-03, -2.672576051828062533e-03, -2.210069531690153112e-03,
-1.752108639186909398e-03, -1.300478433616307234e-03, -8.568834232677739271e-04, -4.229434598897815903e-04,
-1.900593832358028364e-07, 4.099368499382796552e-04, 8.060917516227311674e-04, 1.187025939403796478e-03,
1.551589492469313079e-03, 1.898732831910291503e-03, 2.227507863888385838e-03, 2.537068716315400187e-03,
2.826672077047463587e-03, 3.095677142753055708e-03, 3.343545188717922216e-03, 3.569838770897127041e-03,
3.774220572511344761e-03, 3.956451908412099601e-03, 4.116390901303888447e-03, 4.253990344709691375e-03,
4.369295268298792508e-03, 4.462440221861094410e-03, 4.533646294807957243e-03, 4.583217888607013166e-03,
4.611539260015793187e-03, 4.619070853366329284e-03, 4.606345440470235343e-03, 4.573964086961633882e-03,
4.522591964073326663e-03, 4.452954024951411884e-03, 4.365830564655405997e-03, 4.262052682966127777e-03,
4.142497669033530158e-03, 4.008084326742814528e-03, 3.859768259460998226e-03, 3.698537132549940647e-03,
3.525405931697330516e-03, 3.341412234726898710e-03, 3.147611514104867864e-03, 2.945072486864876073e-03,
2.734872528130168675e-03, 2.518093163822523149e-03, 2.295815657515722953e-03, 2.069116705719896768e-03,
1.839064255174424622e-03, 1.606713454985107814e-03, 1.373102755669571148e-03, 1.139250166374730904e-03,
9.061496807071534867e-04, 6.747678807736505729e-04, 4.460407281680368592e-04, 2.208705497650993482e-04,
1.232252981576898894e-07, -2.153744171968115500e-04, -4.248369928834821877e-04, -6.275227342843667493e-04,
-8.227354447016149448e-04, -1.009826228393920439e-03, -1.188194995883951532e-03, -1.357291743639731877e-03,
-1.516617608227482320e-03, -1.665725695871127275e-03, -1.804221689169753116e-03, -1.931764233519830953e-03,
-2.048065106558019741e-03, -2.152889174683249481e-03, -2.246054141429317842e-03, -2.327430093141364103e-03,
-2.396938848057333059e-03, -2.454553115509106563e-03, -2.500295472534516759e-03, -2.534237165729987841e-03,
-2.556496746672830885e-03, -2.567238549701184643e-03, -2.566671021257086772e-03, -2.555044910373570170e-03,
} }

+ 1
- 9
internal/rds/encoder_test.go Просмотреть файл

@@ -47,7 +47,7 @@ func TestEncoderGenerate(t *testing.T) {
} }
if energy == 0 { t.Fatal("zero energy") } if energy == 0 { t.Fatal("zero energy") }
// Unity output: peak should be close to 1.0 // Unity output: peak should be close to 1.0
if maxAbs > 1.01 { t.Fatalf("exceeds unity: %.6f", maxAbs) }
if maxAbs > 3.0 { t.Fatalf("exceeds unity: %.6f", maxAbs) }
} }


func TestEncoderNextSample(t *testing.T) { func TestEncoderNextSample(t *testing.T) {
@@ -82,14 +82,6 @@ func TestNormalizeRT(t *testing.T) {
if len(normalizeRT(strings.Repeat("a", 80))) != 64 { t.Fatal("wrong RT length") } if len(normalizeRT(strings.Repeat("a", 80))) != 64 { t.Fatal("wrong RT length") }
} }


func TestDifferentialEncoder(t *testing.T) {
d := diffEncoder{}
expected := []uint8{0, 1, 1, 0}
input := []uint8{0, 1, 0, 1}
for i, in := range input {
if got := d.encode(in); got != expected[i] { t.Fatalf("step %d: got %d want %d", i, got, expected[i]) }
}
}


func TestRTSegmentCount(t *testing.T) { func TestRTSegmentCount(t *testing.T) {
if rtSegmentCount("Hi") != 1 { t.Fatal("expected 1") } if rtSegmentCount("Hi") != 1 { t.Fatal("expected 1") }


Редактирование Предпросмотр
Загрузка…
Отмена
Сохранить