fm-rds-tx/internal/config/config.go

package config

import (
	"encoding/json"
	"fmt"
	"os"
)

type Config struct {
	Audio   AudioConfig   `json:"audio"`
	RDS     RDSConfig     `json:"rds"`
	FM      FMConfig      `json:"fm"`
	Backend BackendConfig `json:"backend"`
	Control ControlConfig `json:"control"`
}

type AudioConfig struct {
	InputPath     string  `json:"inputPath"`
	SampleRate    int     `json:"sampleRate"`
	Gain          float64 `json:"gain"`
	ToneLeftHz    float64 `json:"toneLeftHz"`
	ToneRightHz   float64 `json:"toneRightHz"`
	ToneAmplitude float64 `json:"toneAmplitude"`
}

type RDSConfig struct {
	Enabled   bool   `json:"enabled"`
	PI        string `json:"pi"`
	PS        string `json:"ps"`
	RadioText string `json:"radioText"`
	PTY       int    `json:"pty"`
}

type FMConfig struct {
	FrequencyMHz      float64 `json:"frequencyMHz"`
	StereoEnabled     bool    `json:"stereoEnabled"`
	PilotLevel        float64 `json:"pilotLevel"`
	RDSInjection      float64 `json:"rdsInjection"`
	PreEmphasisUS     float64 `json:"preEmphasisUS"`     // time constant in µs: 50 (EU) or 75 (US), 0=off
	OutputDrive       float64 `json:"outputDrive"`
	CompositeRateHz   int     `json:"compositeRateHz"`
	MaxDeviationHz    float64 `json:"maxDeviationHz"`    // FM deviation in Hz, default 75000
	LimiterEnabled    bool    `json:"limiterEnabled"`
	LimiterCeiling    float64 `json:"limiterCeiling"`    // composite ceiling, default 1.0
	FMModulationEnabled bool  `json:"fmModulationEnabled"` // true = output FM IQ, false = raw composite
}

type BackendConfig struct {
	Kind       string `json:"kind"`
	Device     string `json:"device"`
	OutputPath string `json:"outputPath"`
}

type ControlConfig struct {
	ListenAddress string `json:"listenAddress"`
}

func Default() Config {
	return Config{
		Audio: AudioConfig{SampleRate: 48000, Gain: 1.0, ToneLeftHz: 1000, ToneRightHz: 1600, ToneAmplitude: 0.4},
		RDS:   RDSConfig{Enabled: true, PI: "1234", PS: "FMRTX", RadioText: "fm-rds-tx", PTY: 0},
		FM: FMConfig{
			FrequencyMHz:        100.0,
			StereoEnabled:       true,
			PilotLevel:          0.1,
			RDSInjection:        0.05,
			PreEmphasisUS:       50, // European default
			OutputDrive:         0.5,
			CompositeRateHz:     228000,
			MaxDeviationHz:      75000,
			LimiterEnabled:      true,
			LimiterCeiling:      1.0,
			FMModulationEnabled: true,
		},
		Backend: BackendConfig{Kind: "file", OutputPath: "build/out/composite.f32"},
		Control: ControlConfig{ListenAddress: "127.0.0.1:8088"},
	}
}

func Load(path string) (Config, error) {
	cfg := Default()
	if path == "" {
		return cfg, cfg.Validate()
	}
	data, err := os.ReadFile(path)
	if err != nil {
		return Config{}, err
	}
	if err := json.Unmarshal(data, &cfg); err != nil {
		return Config{}, err
	}
	return cfg, cfg.Validate()
}

func (c Config) Validate() error {
	if c.Audio.SampleRate < 8000 || c.Audio.SampleRate > 384000 {
		return fmt.Errorf("audio.sampleRate out of range")
	}
	if c.Audio.Gain < 0 || c.Audio.Gain > 4 {
		return fmt.Errorf("audio.gain out of range")
	}
	if c.Audio.ToneLeftHz <= 0 || c.Audio.ToneRightHz <= 0 {
		return fmt.Errorf("audio tone frequencies must be positive")
	}
	if c.Audio.ToneAmplitude < 0 || c.Audio.ToneAmplitude > 1 {
		return fmt.Errorf("audio.toneAmplitude out of range")
	}
	if c.FM.FrequencyMHz < 65 || c.FM.FrequencyMHz > 110 {
		return fmt.Errorf("fm.frequencyMHz out of range")
	}
	if c.FM.PilotLevel < 0 || c.FM.PilotLevel > 0.2 {
		return fmt.Errorf("fm.pilotLevel out of range")
	}
	if c.FM.RDSInjection < 0 || c.FM.RDSInjection > 0.15 {
		return fmt.Errorf("fm.rdsInjection out of range")
	}
	if c.FM.OutputDrive < 0 || c.FM.OutputDrive > 1 {
		return fmt.Errorf("fm.outputDrive out of range")
	}
	if c.FM.CompositeRateHz < 96000 || c.FM.CompositeRateHz > 1520000 {
		return fmt.Errorf("fm.compositeRateHz out of range")
	}
	if c.FM.PreEmphasisUS < 0 || c.FM.PreEmphasisUS > 100 {
		return fmt.Errorf("fm.preEmphasisUS out of range (0=off, 50=EU, 75=US)")
	}
	if c.FM.MaxDeviationHz < 0 || c.FM.MaxDeviationHz > 150000 {
		return fmt.Errorf("fm.maxDeviationHz out of range")
	}
	if c.FM.LimiterCeiling < 0 || c.FM.LimiterCeiling > 2 {
		return fmt.Errorf("fm.limiterCeiling out of range")
	}
	if c.Backend.Kind == "" {
		return fmt.Errorf("backend.kind is required")
	}
	if c.Control.ListenAddress == "" {
		return fmt.Errorf("control.listenAddress is required")
	}
	return nil
}