feat: added record qso dvk

internal/audio/manager.go

@@ -0,0 +1,137 @@
+//go:build windows
+
+package audio
+
+import (
+	"fmt"
+	"sync"
+)
+
+// Manager owns the DVK record/playback lifecycle: at most one recording and
+// one playback at a time. Device ids are passed per call so the host can route
+// recording to the mic and playback to the rig (or the preview speakers).
+type Manager struct {
+	mu       sync.Mutex
+	recStop  chan struct{}
+	recDone  chan recResult
+	playStop chan struct{}
+	onChange func() // fired on any record/playback state transition
+}
+
+type recResult struct {
+	pcm []byte
+	err error
+}
+
+// NewManager creates a DVK manager. onChange (optional) is called whenever the
+// recording/playback state changes, so the host can push an audio:status event.
+func NewManager(onChange func()) *Manager { return &Manager{onChange: onChange} }
+
+func (m *Manager) notify() {
+	if m.onChange != nil {
+		m.onChange()
+	}
+}
+
+// StartRecording begins capturing from deviceID into memory. Finish with
+// StopRecording (which writes the WAV) or CancelRecording (which discards it).
+func (m *Manager) StartRecording(deviceID string) error {
+	m.mu.Lock()
+	if m.recStop != nil {
+		m.mu.Unlock()
+		return fmt.Errorf("already recording")
+	}
+	stop := make(chan struct{})
+	done := make(chan recResult, 1)
+	m.recStop, m.recDone = stop, done
+	m.mu.Unlock() // release BEFORE notify — onChange re-enters via IsRecording()
+	go func() {
+		pcm, err := recordPCM(deviceID, stop)
+		done <- recResult{pcm, err}
+	}()
+	m.notify()
+	return nil
+}
+
+// StopRecording ends the capture and writes it to path as a WAV file.
+func (m *Manager) StopRecording(path string) error {
+	m.mu.Lock()
+	stop, done := m.recStop, m.recDone
+	m.recStop, m.recDone = nil, nil
+	m.mu.Unlock()
+	if stop == nil {
+		return fmt.Errorf("not recording")
+	}
+	close(stop)
+	res := <-done
+	m.notify()
+	if res.err != nil {
+		return res.err
+	}
+	if len(res.pcm) == 0 {
+		return fmt.Errorf("captured no audio (check the recording device)")
+	}
+	return writeWAV(path, res.pcm)
+}
+
+// CancelRecording aborts a recording without saving.
+func (m *Manager) CancelRecording() {
+	m.mu.Lock()
+	stop, done := m.recStop, m.recDone
+	m.recStop, m.recDone = nil, nil
+	m.mu.Unlock()
+	if stop != nil {
+		close(stop)
+		<-done
+		m.notify()
+	}
+}
+
+func (m *Manager) IsRecording() bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.recStop != nil
+}
+
+func (m *Manager) IsPlaying() bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.playStop != nil
+}
+
+// Play renders a WAV file to deviceID. Any current playback is stopped first.
+// Returns immediately; playback runs in the background.
+func (m *Manager) Play(deviceID, path string) error {
+	pcm, rate, ch, bits, err := readWAV(path)
+	if err != nil {
+		return err
+	}
+	m.StopPlayback()
+	stop := make(chan struct{})
+	m.mu.Lock()
+	m.playStop = stop
+	m.mu.Unlock()
+	go func() {
+		_ = playPCM(deviceID, pcm, rate, ch, bits, stop)
+		m.mu.Lock()
+		if m.playStop == stop {
+			m.playStop = nil
+		}
+		m.mu.Unlock()
+		m.notify()
+	}()
+	m.notify()
+	return nil
+}
+
+// StopPlayback halts any in-progress playback.
+func (m *Manager) StopPlayback() {
+	m.mu.Lock()
+	stop := m.playStop
+	m.playStop = nil
+	m.mu.Unlock()
+	if stop != nil {
+		close(stop)
+		m.notify()
+	}
+}