kato
b0487be39e
Introduce a supervised child process for capture, VAD, and recognition, enabling automatic restart on crash/hang and hot-reload via SIGHUP. Add `--model-auto-restart`, `--model-timeout`, and `--model-shutdown-timeout` options. Refactor `Run()` with lifecycle hooks for proper process group cleanup. Update README with new behavior and CLI flags.
98 lines
2.2 KiB
Go
98 lines
2.2 KiB
Go
// Package capture reads the default PulseAudio-compatible output monitor.
|
|
package capture
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
|
|
"tea.chunkbyte.com/kato/captioneer/src/audio"
|
|
)
|
|
|
|
func ValidatePrograms() error {
|
|
for _, program := range []string{"pactl", "parec"} {
|
|
if _, err := exec.LookPath(program); err != nil {
|
|
return fmt.Errorf("%s was not found in PATH: %w", program, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func DefaultMonitorSource(ctx context.Context) (string, error) {
|
|
output, err := exec.CommandContext(ctx, "pactl", "get-default-sink").Output()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return strings.TrimSpace(string(output)) + ".monitor", nil
|
|
}
|
|
|
|
func Packets(ctx context.Context, monitorSource string) (<-chan []float32, func() error, error) {
|
|
cmd := exec.CommandContext(ctx, "parec",
|
|
"--device="+monitorSource,
|
|
"--format=s16le",
|
|
fmt.Sprintf("--rate=%d", audio.SampleRate),
|
|
fmt.Sprintf("--channels=%d", audio.Channels),
|
|
"--raw",
|
|
"--latency-msec=50",
|
|
)
|
|
cmd.Stderr = os.Stderr
|
|
cmd.SysProcAttr = &syscall.SysProcAttr{Pdeathsig: syscall.SIGKILL}
|
|
stdout, err := cmd.StdoutPipe()
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if err := cmd.Start(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
packets := make(chan []float32, 50) // Five seconds at 100 ms per packet.
|
|
var waitOnce sync.Once
|
|
var waitErr error
|
|
wait := func() error {
|
|
waitOnce.Do(func() { waitErr = cmd.Wait() })
|
|
return waitErr
|
|
}
|
|
|
|
go func() {
|
|
defer close(packets)
|
|
packetBytes := make([]byte, audio.SamplesPerPacket()*audio.BytesPerSample)
|
|
for {
|
|
n, readErr := io.ReadFull(stdout, packetBytes)
|
|
if n > 0 {
|
|
enqueueLatest(packets, audio.PCM16LEToFloat32(packetBytes[:n]))
|
|
}
|
|
if readErr != nil {
|
|
if ctx.Err() == nil && !errors.Is(readErr, io.EOF) && !errors.Is(readErr, io.ErrUnexpectedEOF) {
|
|
fmt.Fprintf(os.Stderr, "audio capture read error: %v\n", readErr)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return packets, wait, nil
|
|
}
|
|
|
|
func enqueueLatest(packets chan []float32, packet []float32) {
|
|
select {
|
|
case packets <- packet:
|
|
return
|
|
default:
|
|
}
|
|
|
|
select {
|
|
case <-packets:
|
|
default:
|
|
}
|
|
select {
|
|
case packets <- packet:
|
|
default:
|
|
}
|
|
fmt.Fprintln(os.Stderr, "warning: caption processing overloaded; dropped 100 ms of oldest audio")
|
|
}
|