428 lines
9.9 KiB
Go
428 lines
9.9 KiB
Go
package main
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"math"
|
||
"math/cmplx"
|
||
"runtime"
|
||
"sync"
|
||
"syscall"
|
||
"time"
|
||
"unsafe"
|
||
|
||
"golang.org/x/sys/windows"
|
||
)
|
||
|
||
// ============================================================
|
||
// FFT: 纯 Go radix-2 Cooley-Tukey (1024 点)
|
||
// ============================================================
|
||
|
||
const fftSize = 1024
|
||
const targetBins = 128
|
||
|
||
func fft(x []complex128) {
|
||
n := len(x)
|
||
if n <= 1 {
|
||
return
|
||
}
|
||
for i, j := 1, 0; i < n; i++ {
|
||
bit := n >> 1
|
||
for j&bit != 0 {
|
||
j ^= bit
|
||
bit >>= 1
|
||
}
|
||
j ^= bit
|
||
if i < j {
|
||
x[i], x[j] = x[j], x[i]
|
||
}
|
||
}
|
||
for length := 2; length <= n; length <<= 1 {
|
||
half := length >> 1
|
||
angle := -2 * math.Pi / float64(length)
|
||
wn := complex(math.Cos(angle), math.Sin(angle))
|
||
for i := 0; i < n; i += length {
|
||
w := complex(1, 0)
|
||
for j := 0; j < half; j++ {
|
||
u := x[i+j]
|
||
v := x[i+j+half] * w
|
||
x[i+j] = u + v
|
||
x[i+j+half] = u - v
|
||
w *= wn
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func fftMagnitude(input []float32) []float64 {
|
||
n := len(input)
|
||
if n > fftSize {
|
||
n = fftSize
|
||
input = input[:fftSize]
|
||
}
|
||
x := make([]complex128, fftSize)
|
||
for i := 0; i < n; i++ {
|
||
w := 0.5 * (1 - math.Cos(2*math.Pi*float64(i)/float64(n-1)))
|
||
x[i] = complex(float64(input[i])*w, 0)
|
||
}
|
||
fft(x)
|
||
mag := make([]float64, fftSize/2)
|
||
for i := range mag {
|
||
mag[i] = cmplx.Abs(x[i]) / float64(fftSize)
|
||
}
|
||
return mag
|
||
}
|
||
|
||
// downsampleBins: 分段映射 — 低频线性保细节，中高频对数保覆盖
|
||
// 不再做额外 tilt 补偿，映射本身就是均衡的
|
||
func downsampleBins(magnitudes []float64, target int) []float64 {
|
||
srcLen := len(magnitudes)
|
||
if srcLen == 0 || target == 0 {
|
||
return make([]float64, target)
|
||
}
|
||
|
||
// 低频线性区间：前20%的 display bins 覆盖 FFT 1-80 (约47Hz-3.7kHz)
|
||
// 中高频对数区间：后80%覆盖 FFT 80-512 (3.7kHz-24kHz)
|
||
const lowEnd = 80 // 低频截止 FFT 索引
|
||
const lowFrac = 0.2
|
||
|
||
bins := make([]float64, target)
|
||
for i := 0; i < target; i++ {
|
||
frac := float64(i) / float64(target)
|
||
fracNext := float64(i+1) / float64(target)
|
||
|
||
var start, end int
|
||
if frac < lowFrac {
|
||
start = int(frac / lowFrac * float64(lowEnd))
|
||
end = int(fracNext / lowFrac * float64(lowEnd))
|
||
} else {
|
||
f := (frac - lowFrac) / (1 - lowFrac)
|
||
fNext := (fracNext - lowFrac) / (1 - lowFrac)
|
||
start = lowEnd + int(float64(srcLen-lowEnd)*math.Pow(f, 0.7))
|
||
end = lowEnd + int(float64(srcLen-lowEnd)*math.Pow(fNext, 0.7))
|
||
}
|
||
|
||
if end <= start {
|
||
end = start + 1
|
||
}
|
||
if end > srcLen {
|
||
end = srcLen
|
||
}
|
||
|
||
// 取最大值保留峰值冲击力
|
||
maxVal := 0.0
|
||
for j := start; j < end; j++ {
|
||
if magnitudes[j] > maxVal {
|
||
maxVal = magnitudes[j]
|
||
}
|
||
}
|
||
bins[i] = maxVal
|
||
}
|
||
return bins
|
||
}
|
||
|
||
func smoothBinsGo(prev, curr []float64, factor float64) []float64 {
|
||
n := len(curr)
|
||
if len(prev) != n {
|
||
return curr
|
||
}
|
||
out := make([]float64, n)
|
||
for i := 0; i < n; i++ {
|
||
out[i] = prev[i]*factor + curr[i]*(1-factor)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// ============================================================
|
||
// COM vtable 调用辅助
|
||
// ============================================================
|
||
|
||
func comCall(obj uintptr, vtableIdx uintptr, args ...uintptr) uintptr {
|
||
if obj == 0 {
|
||
return 0x80004003 // E_POINTER
|
||
}
|
||
vtable := *(*uintptr)(unsafe.Pointer(obj))
|
||
method := *(*uintptr)(unsafe.Pointer(vtable + vtableIdx*unsafe.Sizeof(uintptr(0))))
|
||
a := make([]uintptr, 12)
|
||
a[0] = obj
|
||
for i, arg := range args {
|
||
a[i+1] = arg
|
||
}
|
||
n := uintptr(len(args) + 1)
|
||
switch {
|
||
case n <= 3:
|
||
r, _, _ := syscall.Syscall(method, n, a[0], a[1], a[2])
|
||
return r
|
||
case n <= 6:
|
||
r, _, _ := syscall.Syscall6(method, n, a[0], a[1], a[2], a[3], a[4], a[5])
|
||
return r
|
||
case n <= 9:
|
||
r, _, _ := syscall.Syscall9(method, n, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8])
|
||
return r
|
||
case n <= 12:
|
||
r, _, _ := syscall.Syscall12(method, n, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11])
|
||
return r
|
||
default:
|
||
return 0x80070057 // E_INVALIDARG
|
||
}
|
||
}
|
||
|
||
// COM GUID 常量
|
||
var (
|
||
clsidMMDeviceEnumerator = windows.GUID{Data1: 0xBCDE0395, Data2: 0xE52F, Data3: 0x467C, Data4: [8]byte{0x8E, 0x3D, 0xC4, 0x57, 0x92, 0x91, 0x69, 0x2E}}
|
||
iidIMMDeviceEnumerator = windows.GUID{Data1: 0xA95664D2, Data2: 0x9614, Data3: 0x4F35, Data4: [8]byte{0xA7, 0x46, 0xDE, 0x8D, 0xB6, 0x36, 0x17, 0xE6}}
|
||
iidIAudioClient = windows.GUID{Data1: 0x1CB9AD4C, Data2: 0xDBFA, Data3: 0x4C32, Data4: [8]byte{0xB1, 0x78, 0xC2, 0xF5, 0x68, 0xA7, 0x03, 0xB2}}
|
||
iidIAudioCaptureClient = windows.GUID{Data1: 0xC8ADBD64, Data2: 0xE71E, Data3: 0x48A0, Data4: [8]byte{0xA4, 0xDE, 0x18, 0x5C, 0x39, 0x5C, 0xD3, 0x17}}
|
||
)
|
||
|
||
const (
|
||
enumeratorGetDefaultAudioEndpoint = 4
|
||
)
|
||
|
||
const (
|
||
deviceActivate = 3
|
||
)
|
||
|
||
const (
|
||
audioClientInitialize = 3
|
||
audioClientGetBufferSize = 4
|
||
audioClientGetMixFormat = 8
|
||
audioClientStart = 10
|
||
audioClientStop = 11
|
||
audioClientGetService = 14
|
||
)
|
||
|
||
const (
|
||
captureGetBuffer = 3
|
||
captureReleaseBuffer = 4
|
||
)
|
||
|
||
// ============================================================
|
||
// WASAPI 捕获生命周期
|
||
// ============================================================
|
||
|
||
var (
|
||
audioMu sync.Mutex
|
||
audioStop chan struct{}
|
||
audioDone chan struct{}
|
||
audioActive bool
|
||
smoothed []float64
|
||
runningMax float64
|
||
)
|
||
|
||
func startAudioCapture() {
|
||
audioMu.Lock()
|
||
defer audioMu.Unlock()
|
||
if audioActive {
|
||
return
|
||
}
|
||
audioStop = make(chan struct{})
|
||
audioDone = make(chan struct{})
|
||
audioActive = true
|
||
smoothed = nil
|
||
runningMax = 0
|
||
go audioCaptureLoop()
|
||
log.Println("音频捕获: 已启动")
|
||
}
|
||
|
||
func stopAudioCapture() {
|
||
audioMu.Lock()
|
||
stop := audioStop
|
||
audioMu.Unlock()
|
||
if stop == nil {
|
||
return
|
||
}
|
||
close(stop)
|
||
if audioDone != nil {
|
||
<-audioDone
|
||
}
|
||
audioMu.Lock()
|
||
audioActive = false
|
||
audioStop = nil
|
||
audioDone = nil
|
||
audioMu.Unlock()
|
||
log.Println("音频捕获: 已停止")
|
||
}
|
||
|
||
func audioActiveState() bool {
|
||
audioMu.Lock()
|
||
defer audioMu.Unlock()
|
||
return audioActive
|
||
}
|
||
|
||
func audioCaptureLoop() {
|
||
runtime.LockOSThread()
|
||
defer runtime.UnlockOSThread()
|
||
|
||
ole32dll.NewProc("CoInitializeEx").Call(0, 0)
|
||
defer ole32dll.NewProc("CoUninitialize").Call()
|
||
|
||
var enumerator uintptr
|
||
hr, _, _ := ole32dll.NewProc("CoCreateInstance").Call(
|
||
uintptr(unsafe.Pointer(&clsidMMDeviceEnumerator)),
|
||
0, 1,
|
||
uintptr(unsafe.Pointer(&iidIMMDeviceEnumerator)),
|
||
uintptr(unsafe.Pointer(&enumerator)),
|
||
)
|
||
if hr != 0 || enumerator == 0 {
|
||
log.Printf("音频捕获: 创建枚举器失败 hr=0x%x", hr)
|
||
close(audioDone)
|
||
return
|
||
}
|
||
defer comRelease(enumerator)
|
||
|
||
var device uintptr
|
||
hr = comCall(enumerator, enumeratorGetDefaultAudioEndpoint, 0, 0, uintptr(unsafe.Pointer(&device)))
|
||
if hr != 0 || device == 0 {
|
||
log.Printf("音频捕获: 获取默认音频设备失败 hr=0x%x", hr)
|
||
close(audioDone)
|
||
return
|
||
}
|
||
defer comRelease(device)
|
||
|
||
var audioClient uintptr
|
||
hr = comCall(device, deviceActivate,
|
||
uintptr(unsafe.Pointer(&iidIAudioClient)),
|
||
1, 0,
|
||
uintptr(unsafe.Pointer(&audioClient)),
|
||
)
|
||
if hr != 0 || audioClient == 0 {
|
||
log.Printf("音频捕获: Activate(IAudioClient) 失败 hr=0x%x", hr)
|
||
close(audioDone)
|
||
return
|
||
}
|
||
defer comRelease(audioClient)
|
||
|
||
var pwfx uintptr
|
||
hr = comCall(audioClient, audioClientGetMixFormat, uintptr(unsafe.Pointer(&pwfx)))
|
||
if hr != 0 || pwfx == 0 {
|
||
log.Printf("音频捕获: GetMixFormat 失败 hr=0x%x", hr)
|
||
close(audioDone)
|
||
return
|
||
}
|
||
defer ole32dll.NewProc("CoTaskMemFree").Call(pwfx)
|
||
|
||
nChannels := *(*uint16)(unsafe.Pointer(pwfx + 2))
|
||
nSamplesPerSec := *(*uint32)(unsafe.Pointer(pwfx + 4))
|
||
log.Printf("音频捕获: 格式 ch=%d rate=%d", nChannels, nSamplesPerSec)
|
||
|
||
hr = comCall(audioClient, audioClientInitialize,
|
||
0,
|
||
0x00020000,
|
||
10000000,
|
||
0,
|
||
pwfx,
|
||
0,
|
||
)
|
||
if hr != 0 {
|
||
log.Printf("音频捕获: Initialize 失败 hr=0x%x", hr)
|
||
close(audioDone)
|
||
return
|
||
}
|
||
|
||
var captureClient uintptr
|
||
hr = comCall(audioClient, audioClientGetService,
|
||
uintptr(unsafe.Pointer(&iidIAudioCaptureClient)),
|
||
uintptr(unsafe.Pointer(&captureClient)),
|
||
)
|
||
if hr != 0 || captureClient == 0 {
|
||
log.Printf("音频捕获: GetService(IAudioCaptureClient) 失败 hr=0x%x", hr)
|
||
close(audioDone)
|
||
return
|
||
}
|
||
defer comRelease(captureClient)
|
||
|
||
comCall(audioClient, audioClientStart)
|
||
defer comCall(audioClient, audioClientStop)
|
||
|
||
ch := int(nChannels)
|
||
bufSize := int(nSamplesPerSec)/10*ch + fftSize*ch
|
||
ringBuf := make([]float32, bufSize)
|
||
writePos := 0
|
||
|
||
cfg := loadConfig()
|
||
smoothingFactor := cfg.AudioSmoothing
|
||
if smoothingFactor <= 0 {
|
||
smoothingFactor = 0.7
|
||
}
|
||
|
||
// 预分配 mono slice
|
||
mono := make([]float32, fftSize)
|
||
|
||
ticker := time.NewTicker(33 * time.Millisecond)
|
||
defer ticker.Stop()
|
||
|
||
for {
|
||
select {
|
||
case <-audioStop:
|
||
close(audioDone)
|
||
return
|
||
case <-ticker.C:
|
||
}
|
||
|
||
for {
|
||
var pData, nFrames, flags uintptr
|
||
hr = comCall(captureClient, captureGetBuffer,
|
||
uintptr(unsafe.Pointer(&pData)),
|
||
uintptr(unsafe.Pointer(&nFrames)),
|
||
uintptr(unsafe.Pointer(&flags)),
|
||
0, 0,
|
||
)
|
||
if hr != 0 || nFrames == 0 {
|
||
break
|
||
}
|
||
samples := unsafe.Slice((*float32)(unsafe.Pointer(pData)), nFrames*uintptr(ch))
|
||
for _, s := range samples {
|
||
ringBuf[writePos] = s
|
||
writePos = (writePos + 1) % bufSize
|
||
}
|
||
comCall(captureClient, captureReleaseBuffer, uintptr(nFrames))
|
||
}
|
||
|
||
for i := 0; i < fftSize; i++ {
|
||
pos := (writePos - fftSize*ch + i*ch + bufSize) % bufSize
|
||
var sum float32
|
||
for c := 0; c < ch; c++ {
|
||
sum += ringBuf[(pos+c)%bufSize]
|
||
}
|
||
mono[i] = sum / float32(ch)
|
||
}
|
||
|
||
mag := fftMagnitude(mono)
|
||
bins := downsampleBins(mag, targetBins)
|
||
|
||
if smoothed != nil {
|
||
bins = smoothBinsGo(smoothed, bins, smoothingFactor)
|
||
}
|
||
smoothed = bins
|
||
|
||
// 全局归一化（慢衰减 runningMax）
|
||
curMax := 0.0
|
||
for _, v := range bins {
|
||
if v > curMax {
|
||
curMax = v
|
||
}
|
||
}
|
||
if curMax > runningMax {
|
||
runningMax = curMax
|
||
} else {
|
||
runningMax *= 0.985
|
||
}
|
||
if runningMax > 0.001 {
|
||
for i := range bins {
|
||
bins[i] /= runningMax
|
||
}
|
||
}
|
||
|
||
data, _ := json.Marshal(bins)
|
||
evalJS(fmt.Sprintf(`if(window.updateAudioDataFromGo) updateAudioDataFromGo(%s)`, string(data)))
|
||
}
|
||
}
|
||
|
||
func comRelease(obj uintptr) {
|
||
if obj != 0 {
|
||
comCall(obj, 2)
|
||
}
|
||
}
|