feat(player): add silence detection and smart speed to local audio player

client/players/LocalAudioPlayer.js

@@ -1,5 +1,6 @@
 import Hls from 'hls.js'
 import EventEmitter from 'events'
+import SilenceMap from './smart-speed/SilenceMap'
 
 export default class LocalAudioPlayer extends EventEmitter {
   constructor(ctx) {
@@ -25,6 +26,10 @@ export default class LocalAudioPlayer extends EventEmitter {
     this.audioSourceNode = null
     this.usingWebAudio = false
 
+    this.silenceMap = new SilenceMap()
+    this.silenceDetectorNode = null
+    this.enableSmartSpeed = false
+
     this.initialize()
   }
 
@@ -92,6 +97,51 @@ export default class LocalAudioPlayer extends EventEmitter {
     }
   }
 
+  async initSilenceDetector() {
+    if (!this.usingWebAudio || !this.audioContext) return
+    if (this.silenceDetectorNode) return
+
+    try {
+      await this.audioContext.audioWorklet.addModule('/client/players/smart-speed/SilenceDetectorProcessor.js')
+      this.silenceDetectorNode = new AudioWorkletNode(this.audioContext, 'silence-detector')
+
+      this.silenceDetectorNode.port.onmessage = (event) => {
+        const msg = event.data
+        if (msg.type === 'silence-start') {
+          this._silenceStartTime = msg.time
+        } else if (msg.type === 'silence-end') {
+          if (this._silenceStartTime !== null) {
+            this.silenceMap.addRegion(this._silenceStartTime, msg.time)
+            this._silenceStartTime = null
+          }
+        }
+      }
+
+      this.audioSourceNode.disconnect()
+      this.audioSourceNode.connect(this.silenceDetectorNode)
+      this.silenceDetectorNode.connect(this.audioContext.destination)
+
+      this._silenceStartTime = null
+      console.log('[LocalPlayer] Silence detector initialised')
+    } catch (err) {
+      console.warn('[LocalPlayer] Failed to initialise silence detector', err)
+      this.silenceDetectorNode = null
+    }
+  }
+
+  destroySilenceDetector() {
+    if (this.silenceDetectorNode) {
+      try {
+        this.silenceDetectorNode.disconnect()
+      } catch (err) {
+        // Ignore disconnect errors
+      }
+      this.silenceDetectorNode = null
+    }
+    this.silenceMap.reset()
+    this._silenceStartTime = null
+  }
+
   evtPlay() {
     this.emit('stateChange', 'PLAYING')
   }
@@ -137,6 +187,7 @@ export default class LocalAudioPlayer extends EventEmitter {
   }
 
   destroy() {
+    this.destroySilenceDetector()
     this.destroyHlsInstance()
     this.destroyWebAudio()
     if (this.player) {
@@ -239,6 +290,7 @@ export default class LocalAudioPlayer extends EventEmitter {
 
   loadCurrentTrack() {
     if (!this.currentTrack) return
+    this.silenceMap.reset()
     // When direct play track is loaded current time needs to be set
     this.trackStartTime = Math.max(0, this.startTime - (this.currentTrack.startOffset || 0))
     this.player.src = this.currentTrack.relativeContentUrl
@@ -319,9 +371,19 @@ export default class LocalAudioPlayer extends EventEmitter {
     this.player.playbackRate = playbackRate
   }
 
+  async setSmartSpeed(enabled) {
+    this.enableSmartSpeed = enabled
+    if (enabled && this.usingWebAudio) {
+      await this.initSilenceDetector()
+    } else {
+      this.destroySilenceDetector()
+    }
+  }
+
   seek(time, playWhenReady) {
     if (!this.player) return
 
+    this.silenceMap.reset()
     this.playWhenReady = playWhenReady
 
     if (this.isHlsTranscode) {

client/players/smart-speed/SilenceDetectorProcessor.js

@@ -0,0 +1,71 @@
+const SPEAKING = 0
+const SILENCE = 1
+const CANDIDATE = 2
+
+const DEBOUNCE_MS = 200
+const RMS_REPORT_INTERVAL = 10
+
+class SilenceDetectorProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super()
+    this.state = SPEAKING
+    this.silenceThreshold = -40
+    this.candidateStartSample = 0
+    this.sampleRate = sampleRate
+    this.blockCount = 0
+
+    this.port.onmessage = (event) => {
+      const msg = event.data
+      if (msg.type === 'set-threshold') {
+        this.silenceThreshold = msg.value
+      }
+    }
+  }
+
+  process(inputs) {
+    const input = inputs[0]
+    if (!input || !input.length) return true
+
+    const channel = input[0]
+    if (!channel) return true
+
+    let sum = 0
+    for (let i = 0; i < channel.length; i++) {
+      sum += channel[i] * channel[i]
+    }
+    const rms = Math.sqrt(sum / channel.length)
+    const dbfs = rms === 0 ? -Infinity : 20 * Math.log10(rms)
+
+    this.blockCount++
+
+    if (dbfs < this.silenceThreshold) {
+      if (this.state === SPEAKING) {
+        this.candidateStartSample = currentFrame
+        this.state = CANDIDATE
+      } else if (this.state === CANDIDATE) {
+        const elapsedMs = ((currentFrame - this.candidateStartSample) / this.sampleRate) * 1000
+        if (elapsedMs >= DEBOUNCE_MS) {
+          this.state = SILENCE
+          const silenceStartTime = (this.candidateStartSample / this.sampleRate) * 1000
+          this.port.postMessage({ type: 'silence-start', time: silenceStartTime })
+        }
+      }
+    } else {
+      if (this.state === SILENCE) {
+        const currentTime = (currentFrame / this.sampleRate) * 1000
+        this.port.postMessage({ type: 'silence-end', time: currentTime })
+      }
+      if (this.state !== SPEAKING) {
+        this.state = SPEAKING
+      }
+    }
+
+    if (this.blockCount % RMS_REPORT_INTERVAL === 0) {
+      this.port.postMessage({ type: 'rms', value: dbfs })
+    }
+
+    return true
+  }
+}
+
+registerProcessor('silence-detector', SilenceDetectorProcessor)

client/players/smart-speed/SilenceMap.js

@@ -0,0 +1,61 @@
+class SilenceMap {
+  constructor() {
+    this._regions = []
+  }
+
+  get regionCount() {
+    return this._regions.length
+  }
+
+  getRegions() {
+    return [...this._regions]
+  }
+
+  addRegion(startMs, endMs) {
+    if (typeof startMs !== 'number' || typeof endMs !== 'number') return
+    if (startMs < 0 || endMs < 0) return
+    if (endMs <= startMs) return
+
+    const newRegion = { start: startMs, end: endMs }
+    const merged = []
+    let inserted = false
+
+    for (const region of this._regions) {
+      if (newRegion.start <= region.end + 10 && newRegion.end >= region.start - 10) {
+        newRegion.start = Math.min(newRegion.start, region.start)
+        newRegion.end = Math.max(newRegion.end, region.end)
+      } else if (!inserted && region.start > newRegion.end) {
+        merged.push(newRegion)
+        merged.push(region)
+        inserted = true
+      } else {
+        merged.push(region)
+      }
+    }
+
+    if (!inserted) {
+      merged.push(newRegion)
+    }
+
+    this._regions = merged
+  }
+
+  getCompressedOffset(atTimeMs, ratio) {
+    if (!ratio || ratio <= 1) return 0
+    let saved = 0
+    for (const region of this._regions) {
+      if (atTimeMs <= region.start) break
+      const silenceStart = region.start
+      const silenceEnd = Math.min(region.end, atTimeMs)
+      const silenceDuration = silenceEnd - silenceStart
+      saved += silenceDuration * (1 - 1 / ratio)
+    }
+    return saved
+  }
+
+  reset() {
+    this._regions = []
+  }
+}
+
+module.exports = SilenceMap