@aochuang/common 1.0.0 → 1.0.126

package/common/voice/index.js

@@ -0,0 +1,21 @@
+import Voice from './voice'
+
+export { setAacCodecParserLibPath, getAacCodecParserLibPath, setBenzAMRRecorderLibPath, getBenzAMRRecorderLibPath } from './util'
+
+export function getRateOptions () {
+  return [{
+    value: 1,
+    showText: '1倍',
+    text: '1倍（默认）'
+  }, {
+    value: 1.25,
+    showText: '1.5倍',
+    text: '1.5倍'
+  }, {
+    value: 1.5,
+    showText: '2倍',
+    text: '2倍'
+  }]
+}
+
+export default Voice

package/common/voice/util.js

@@ -0,0 +1,18 @@
+let aacCodecParserLibPath = './lib/aac-codec-parser/aac-codec-parser.js'
+let benzAMRRecorderLibPath = '/lib/ac-amr-recorder/BenzAMRRecorder.js'
+
+export function setAacCodecParserLibPath (libPath) {
+  aacCodecParserLibPath = libPath
+}
+
+export function getAacCodecParserLibPath () {
+  return aacCodecParserLibPath
+}
+
+export function setBenzAMRRecorderLibPath (libPath) {
+  benzAMRRecorderLibPath = libPath
+}
+
+export function getBenzAMRRecorderLibPath () {
+  return benzAMRRecorderLibPath
+}

package/common/voice/voice-player-aac.js

@@ -0,0 +1,584 @@
+import { loadScript } from '../../utils/file'
+import { getAacCodecParserLibPath } from './util'
+import axios from 'axios'
+
+async function appendBuffer(sourceBuffer, buffer) {
+  if (sourceBuffer.updating) {
+      await new Promise(resolve => {
+          sourceBuffer.addEventListener('updateend', resolve, { once: true });
+      });
+  }
+
+  sourceBuffer.appendBuffer(buffer);
+
+  return new Promise(resolve => {
+      sourceBuffer.addEventListener('updateend', resolve, { once: true });
+  });
+}
+
+export default class VoicePlayerAAC {
+  constructor(options) {
+    this.options = Object.assign({}, {
+      playRate: 1,
+      onPlaying: null,
+      onEnded: null,
+      onPlay: null,
+      onError: null,
+      onPause: null,
+      bitrateKbps: 195.02 // 新增：开放码率校准入口，用户可根据实际音频调整
+    }, options)
+
+    this.$audio = document.createElement('audio')
+    this.$audio.autoplay = false
+    this._timer = null
+    this._playbackRate = 1
+    this._currPosition = 0
+    this._url = ''
+    this._play = false
+
+    // MSE 核心变量
+    this.currentMediaSource = null
+    this.mediaSourceSrc = null
+    this.currentObjectUrl = null
+    this.sourceBuffer = null
+    this.iterator = null
+    this.wrapper = null
+    this.audioData = null
+    this.estimatedDuration = 0
+    this.bufferCleaner = null
+    this.loadNextSegment = false
+    this.isPlaying = false
+    this.isPreloading = false
+    this.lastSeekTarget = null
+    this.downloading = false
+
+    // 并发控制锁
+    this.isSeeking = false // 拖拽操作锁
+    this.seekDebounceTimer = null // 拖拽防抖定时器
+
+    this.bindAudioEvents()
+  }
+
+  // 大于18M走分片解析逻辑
+  isUseBigFile (audioData) {
+    if (!audioData) {
+      return false
+    }
+    return audioData.byteLength > 18 * 1024 * 1024; // 18MB字节阈值
+  }
+
+  bindAudioEvents() {
+    this.$audio.onplaying = () => {
+      let totalPosition = this.$audio.duration
+      if (this.isUseBigFile(this.audioData)) {
+        totalPosition = this.estimatedDuration
+      }
+      clearInterval(this._timer)
+      this._timer = setInterval(() => {
+        if (!this._play) return
+        const currPosition = this.$audio.currentTime
+        this.options.onPlaying?.({
+          currPosition,
+          totalPosition
+        })
+        if (currPosition >= totalPosition) {
+          clearInterval(this._timer)
+          this.stop()
+        }
+      }, 100)
+    }
+    this.$audio.onplay = () => {
+      this.options.onPlay?.()
+    }
+
+    this.$audio.onended = () => {
+      // 有时候还没播放完就触发了这个事件，导致进度条有问题
+      this.options.onPlaying && this.options.onPlaying({
+        currPosition: Math.min(this.$audio.currentTime, this.$audio.duration),
+        totalPosition: this.$audio.duration
+      })
+      clearInterval(this._timer)
+      this.stop()
+    }
+
+    this.$audio.addEventListener('stop', () => {
+      clearInterval(this._timer)
+      this.options.onEnded?.()
+    })
+
+    this.$audio.addEventListener('error', (e) => {
+      console.error('Audio error:', this.$audio.error)
+      this.options.onError?.({
+        type: 'aac',
+        url: this._url,
+        message: this.$audio.error || '未知音频错误'
+      })
+    })
+  }
+
+  getScript() {
+    return new Promise((resolve, reject) => {
+      if (window.MSEAudioWrapper) {
+        resolve(window.MSEAudioWrapper)
+      } else {
+        loadScript(getAacCodecParserLibPath())
+          .then(() => resolve(window.MSEAudioWrapper))
+          .catch(reject)
+      }
+    })
+  }
+
+  setPlaybackRate(rate) {
+    if (typeof rate !== 'number') {
+      throw new Error('播放倍率必须为数字类型')
+    }
+    this.stop()
+    this._playbackRate = rate
+    this.$audio.playbackRate = rate
+  }
+
+  async setPosition(position) {
+    if (position === this._currPosition) return
+    this._currPosition = position
+    if (this.isUseBigFile(this.audioData)) {
+      clearTimeout(this.seekDebounceTimer)
+      this.seekDebounceTimer = setTimeout(async () => {
+        const targetTime = Math.max(0, Math.min(position, this.estimatedDuration))
+        console.log('[setPosition] 防抖后执行跳转:', targetTime)
+        await this.seekToTime(targetTime, targetTime < this.$audio.currentTime)
+      }, 300)
+    } else {
+      this.$audio.currentTime = position
+    }
+  }
+
+  setUrl(url, cb) {
+    if (this._url !== url) {
+      this._url = url
+      this.clearMediaResources()
+    }
+    if (!url) {
+      this.stop()
+    }
+    cb?.({ status: 'success' })
+  }
+
+  start() {
+    return this.getScript().then(() => {
+      if (this._play || !this._url) return
+      this._play = true
+      this.downloading = true
+      if (this.abortController) {
+        // 切换音频时，先取消上一个未完成的请求
+        this.abortController.abort()
+      }
+      this.abortController = new AbortController()
+      const { signal } = this.abortController
+      let ps = null
+      if (this.audioData) {
+        ps = Promise.resolve(this.audioData)
+      } else {
+        ps = axios.get(this._url, {
+          responseType: 'arraybuffer',
+          signal: signal
+        }).then((response) => {
+          const arrayBuffer = response.data
+          const audioData = new Uint8Array(arrayBuffer)
+          return audioData
+        })
+      }
+      return ps.then((audioData) => {
+        try {
+          this.clearMediaResources()
+          this.audioData = audioData
+          console.log('音频数据加载完成，大小:', this.audioData.byteLength)
+          this.estimatedDuration = this.calculateEstimatedDuration(this.audioData.byteLength)
+          console.log('预估总时长:', this.estimatedDuration.toFixed(2), 's | 使用码率:', this.options.bitrateKbps, 'kbps')
+          this.mediaSource = new MediaSource()
+          this.currentMediaSource = this.mediaSource
+          this.mediaSourceSrc = URL.createObjectURL(this.mediaSource)
+          this.currentObjectUrl = this.mediaSourceSrc
+          this.$audio.src = this.mediaSourceSrc
+          if (this.isUseBigFile(this.audioData)) {
+            this.$audio.addEventListener('waiting', async () => {
+              if (!this.isSeeking) {
+                console.log('检测到缓冲不足，补充10秒缓冲...')
+                await this.forcePreload(10)
+              }
+            }, { passive: true })
+            this.$audio.addEventListener('playing', () => this.isPlaying = true)
+            this.$audio.addEventListener('pause', () => this.isPlaying = false)
+            this.mediaSource.addEventListener('sourceerror', (e) => {
+              console.error('媒体源错误:', e)
+              this.options.onError?.({ type: 'mse', url: this._url, message: e })
+            })
+            this.mediaSource.addEventListener('sourceopen', async () => {
+              if (!this._play) return
+              try {
+                const MIME_TYPE = 'audio/aac; codecs=mp4a.40.2'
+                this.wrapper = new window.MSEAudioWrapper(MIME_TYPE)
+                this.iterator = this.wrapper.iterator(this.audioData)
+                this.sourceBuffer = this.mediaSource.addSourceBuffer(this.wrapper.mimeType || MIME_TYPE)
+                this.sourceBuffer.mode = 'sequence'
+                console.log('SourceBuffer 初始化完成，模式:', this.sourceBuffer.mode)
+                const initialSegments = []
+                for (let i = 0; i < 15; i++) {
+                  const { value, done } = this.iterator.next()
+                  if (done) break
+                  initialSegments.push(value)
+                }
+                for (const seg of initialSegments) {
+                  await this.appendBufferSafe(this.sourceBuffer, seg)
+                }
+                console.log('初始缓冲加载完成 | 缓冲范围:', this.getBufferedRange())
+                this.$audio.currentTime = 0
+                await this.$audio.play()
+                this.isPlaying = true
+                this.bufferCleaner = setInterval(async () => {
+                  if (this.isSeeking || !this.sourceBuffer || this.sourceBuffer.buffered.length === 0) return
+                  const currentTime = this.$audio.currentTime
+                  const [bufferStart, bufferEnd] = this.getBufferedRange()
+                  if (this.isPlaying && bufferEnd - bufferStart > 15) {
+                    const cleanEnd = Math.max(currentTime - 5, bufferStart)
+                    if (bufferStart < cleanEnd && cleanEnd <= bufferEnd) {
+                      try {
+                        await this.safeRemoveBuffer(this.sourceBuffer, bufferStart, cleanEnd)
+                      } catch (err) {
+                        console.warn('清理缓冲失败，跳过本次操作:', err)
+                      }
+                    }
+                  }
+                  if (bufferEnd - currentTime < 8 && !this.loadNextSegment && !this.isPreloading) {
+                    this.loadNextSegment = true
+                    try {
+                      const { value: segment, done } = this.iterator.next()
+                      if (!done) {
+                        await this.appendBufferSafe(this.sourceBuffer, segment)
+                      } else {
+                        this.mediaSource.endOfStream()
+                      }
+                    } catch (err) {
+                      console.error('加载分片失败:', err)
+                    } finally {
+                      this.loadNextSegment = false
+                    }
+                  }
+  
+                  if (!this.isPlaying && bufferEnd - currentTime < 5 && !this.isPreloading) {
+                    const { value: segment, done } = this.iterator.next()
+                    if (!done) {
+                      await this.appendBufferSafe(this.sourceBuffer, segment)
+                    }
+                  }
+                }, 500)
+  
+              } catch (e) {
+                console.error('MSE 初始化失败:', e)
+                this.options.onError?.({ type: 'mse', url: this._url, message: e })
+              }
+            }, { once: true })
+            this.$audio.play().catch(err => console.log('等待缓冲中:', err.message))
+          } else {
+            this.mediaSource.addEventListener('sourceopen', async () => {
+              if (!this._play) {
+                return
+              }
+              try {
+                this.wrapper = new window.MSEAudioWrapper('audio/aac');
+                this.sourceBuffer = null;
+                let segmentCount = 0;
+                let totalBytesProcessed = 0;
+                for (const segment of this.wrapper.iterator(this.audioData)) {
+                  segmentCount++;
+                  totalBytesProcessed += segment.byteLength;
+                  console.log(`Processing segment ${segmentCount}, size: ${segment.byteLength}`);
+                  if (!this.sourceBuffer) {
+                    if (this.wrapper.mimeType) {
+                      console.log('Creating SourceBuffer with mimeType:', this.wrapper.mimeType);
+                      this.sourceBuffer = this.mediaSource.addSourceBuffer(this.wrapper.mimeType);
+                      console.log('Default SourceBuffer mode:', this.sourceBuffer.mode);
+                      this.sourceBuffer.mode = 'sequence'; // Critical for timeline placement
+                      console.log('Set SourceBuffer mode to:', this.sourceBuffer.mode);
+                    } else {
+                      throw new Error('MimeType not determined yet');
+                    }
+                  }
+                  await appendBuffer(this.sourceBuffer, segment);
+                }
+                console.log(`Finished processing. Total segments: ${segmentCount}, Total bytes: ${totalBytesProcessed}`);
+                this.mediaSource.endOfStream();
+                if (this.sourceBuffer && this.sourceBuffer.buffered.length > 0) {
+                  const buffered = this.sourceBuffer.buffered;
+                  console.log(`Buffered range: ${buffered.start(0)} - ${buffered.end(0)}`);
+                  console.log(`Audio duration: ${this.$audio.duration}`);
+                }
+                this.$audio.play()
+              } catch (e) {
+                console.error(e);
+                this.options.onError && this.options.onError({
+                  type: 'aac',
+                  url: this._url,
+                  message: e ? e.message : '未知错误'
+                })
+              }
+            })
+          }
+        } catch (err) {
+          console.error('音频播放全局错误:', err)
+          this.options.onError?.({ type: 'global', url: this._url, message: err })
+        }
+      }).finally(() => {
+        this.downloading = false
+      })
+    })
+  }
+
+  async safeRemoveBuffer(sourceBuffer, start, end, retries = 3, delay = 500) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        if (sourceBuffer.updating) {
+          await new Promise(resolve => sourceBuffer.addEventListener('updateend', resolve, { once: true }))
+        }
+        sourceBuffer.remove(start, end)
+        await new Promise(resolve => sourceBuffer.addEventListener('updateend', resolve, { once: true }))
+        // 校验清理结果，确保无残留
+        if (sourceBuffer.buffered.length === 0) {
+          console.log(`缓冲清理成功: ${start.toFixed(1)}s -> ${end.toFixed(1)}s | 无残留`)
+          return true
+        }
+      } catch (err) {
+        if (err.name === 'InvalidStateError' && i < retries - 1) {
+          console.warn(`缓冲清理重试 ${i + 1}/${retries}:`, err)
+          await new Promise(resolve => setTimeout(resolve, delay))
+        } else {
+          console.error('缓冲清理最终失败:', err)
+          // 兜底：强制清空所有缓冲
+          try {
+            sourceBuffer.remove(0, sourceBuffer.buffered.end(0))
+          } catch (e) {}
+          return false
+        }
+      }
+    }
+    return false
+  }
+
+  // 新增：获取当前缓冲范围 [start, end]，简化代码
+  getBufferedRange() {
+    if (!this.sourceBuffer || this.sourceBuffer.buffered.length === 0) return [0, 0]
+    return [
+      this.sourceBuffer.buffered.start(0),
+      this.sourceBuffer.buffered.end(0)
+    ]
+  }
+
+  // 重写：适配逻辑仅在缓冲覆盖目标时间后生效，不提前适配到分片起始
+  getNearestValidPlayTime(targetTime) {
+    if (!this.sourceBuffer || this.sourceBuffer.buffered.length === 0) {
+      console.log('[适配位置] 无缓冲，使用目标时间:', targetTime)
+      return targetTime
+    }
+
+    const [bufferStart, bufferEnd] = this.getBufferedRange()
+    console.log(`[适配位置] 目标时间:${targetTime.toFixed(1)}s | 缓冲范围:${bufferStart.toFixed(1)}~${bufferEnd.toFixed(1)}s`)
+
+    // 核心修改：如果缓冲未覆盖目标时间，返回目标时间（等待加载），而非跳转到缓冲边界
+    if (targetTime > bufferEnd) {
+      console.log('[适配位置] 缓冲未覆盖目标时间，等待加载后再定位')
+      return targetTime
+    }
+    if (targetTime < bufferStart) return bufferStart
+    return targetTime
+  }
+
+  async autoAdaptBufferPosition() {
+    if (!this.$audio || !this.sourceBuffer || this.isSeeking) return
+    const targetTime = this.lastSeekTarget || this.$audio.currentTime
+    const newTime = this.getNearestValidPlayTime(targetTime)
+
+    if (newTime !== this.$audio.currentTime) {
+      console.log('[自动适配] 调整播放时间为:', newTime.toFixed(1))
+      this.$audio.currentTime = newTime
+    }
+  }
+
+  // 优化：加载后返回实际缓冲范围，校验是否加载到目标位置
+  async forcePreload(minBufferSeconds = 10) {
+    if (this.isPreloading || !this.sourceBuffer || !this.iterator) return [0, 0]
+    this.isPreloading = true
+    let preloaded = 0
+
+    try {
+      while (preloaded < minBufferSeconds) {
+        const { value: segment, done } = this.iterator.next()
+        if (done || !segment) break
+        await this.appendBufferSafe(this.sourceBuffer, segment)
+        preloaded++
+      }
+      const [start, end] = this.getBufferedRange()
+      console.log(`预加载完成，新增${preloaded}秒缓冲 | 当前缓冲:${start.toFixed(1)}~${end.toFixed(1)}s`)
+      return [start, end]
+    } catch (err) {
+      console.error('强制预加载失败:', err)
+      return [0, 0]
+    } finally {
+      this.isPreloading = false
+    }
+  }
+
+  /**
+   * 核心重写：解决定位到分片起始、向后跳转无反应、适配过早问题
+   */
+  async seekToTime(targetTime, isBackwardSeek = false) {
+    if (this.isSeeking) {
+      console.log('[seekToTime] 正在执行拖拽，跳过本次请求')
+      return
+    }
+    this.isSeeking = true
+    // 锁定最终目标时间，全程不改变
+    const finalTargetTime = Math.max(0, Math.min(targetTime, this.estimatedDuration))
+    this.lastSeekTarget = finalTargetTime
+    console.log(`[seekToTime] 锁定目标时间:${finalTargetTime.toFixed(1)}s | 向后跳转:${isBackwardSeek}`)
+
+    try {
+      // 1. 等待空闲 + 彻底清理旧缓冲
+      if (this.sourceBuffer.updating) {
+        await new Promise(resolve => this.sourceBuffer.addEventListener('updateend', resolve, { once: true }))
+      }
+      const [oldBufferStart, oldBufferEnd] = this.getBufferedRange()
+      if (oldBufferEnd > 0) {
+        await this.safeRemoveBuffer(this.sourceBuffer, oldBufferStart, oldBufferEnd)
+      }
+
+      // 2. 精准计算字节位置（使用可配置码率），重置迭代器
+      const targetBytePosition = Math.max(0, (finalTargetTime / this.estimatedDuration) * this.audioData.length)
+      this.iterator = this.wrapper.iterator(this.audioData.slice(targetBytePosition))
+      console.log(`[seekToTime] 迭代器定位到字节:${targetBytePosition} | 对应目标时间:${finalTargetTime.toFixed(1)}s`)
+
+      // 3. 预加载目标缓冲，等待加载完成
+      const [bufferStart, bufferEnd] = await this.forcePreload(20) // 增加预加载时长，确保覆盖目标时间
+
+      // 4. 适配位置（此时缓冲已加载，不会跳转到分片起始）
+      const adaptTime = this.getNearestValidPlayTime(finalTargetTime)
+      console.log(`[seekToTime] 缓冲加载完成 | 最终定位时间:${adaptTime.toFixed(1)}s`)
+
+      // 5. 强制设置播放位置，解决向后跳转无反应
+      this.$audio.currentTime = adaptTime
+      if (!this.isPlaying) {
+        await this.$audio.play()
+        this.isPlaying = true
+      }
+
+    } catch (err) {
+      console.error('定位失败:', err)
+    } finally {
+      // 延迟释放锁，确保缓冲完全加载
+      setTimeout(() => {
+        this.isSeeking = false
+      }, 500)
+    }
+  }
+
+  // 优化：使用可配置码率计算时长，支持校准
+  calculateEstimatedDuration(fileSizeBytes) {
+    const bitrateKbps = this.options.bitrateKbps
+    const fileSizeBits = fileSizeBytes * 8
+    return fileSizeBits / (bitrateKbps * 1000)
+  }
+
+  async appendBufferSafe(sourceBuffer, buffer) {
+    if (!sourceBuffer) return
+    if (sourceBuffer.updating) {
+      await new Promise(resolve => sourceBuffer.addEventListener('updateend', resolve, { once: true }))
+    }
+
+    try {
+      sourceBuffer.appendBuffer(buffer)
+      await new Promise(resolve => sourceBuffer.addEventListener('updateend', resolve, { once: true }))
+    } catch (err) {
+      if (err.name === 'QuotaExceededError') {
+        console.warn('缓冲区已满，清理最旧的10秒缓冲...')
+        await this.safeRemoveBuffer(sourceBuffer, 0, Math.min(10, sourceBuffer.buffered.end(0)))
+        sourceBuffer.appendBuffer(buffer)
+        await new Promise(resolve => sourceBuffer.addEventListener('updateend', resolve, { once: true }))
+      } else {
+        console.error('追加缓冲失败:', err)
+      }
+    }
+  }
+
+  async togglePlayPause() {
+    if (!this.$audio) return
+    if (this.isPlaying) {
+      this.$audio.pause()
+      this.isPlaying = false
+    } else {
+      const targetTime = this.lastSeekTarget || this.$audio.currentTime
+      const newTime = this.getNearestValidPlayTime(targetTime)
+      this.$audio.currentTime = newTime
+      await this.$audio.play()
+      this.isPlaying = true
+    }
+  }
+
+  clearMediaResources() {
+    if (this.$audio) {
+      this.$audio.pause()
+      this.$audio.removeAttribute('src')
+    }
+    if (this.currentMediaSource) {
+      try {
+        if (this.currentMediaSource.readyState !== 'closed') {
+          this.currentMediaSource.endOfStream()
+        }
+      } catch (e) {}
+      this.currentMediaSource = null
+    }
+    if (this.currentObjectUrl) {
+      URL.revokeObjectURL(this.currentObjectUrl)
+      this.currentObjectUrl = null
+    }
+    if (this.bufferCleaner) {
+      clearInterval(this.bufferCleaner)
+      this.bufferCleaner = null
+    }
+
+    this.isPlaying = false
+    this.sourceBuffer = null
+    this.iterator = null
+    this.loadNextSegment = false
+    this.audioData = null
+    this.wrapper = null
+    this.estimatedDuration = 0
+    this.isPreloading = false
+    this.lastSeekTarget = null
+    this.isSeeking = false
+    clearTimeout(this.seekDebounceTimer)
+  }
+
+  resume () {
+    console.log('aac不支持')
+  }
+
+  pause () {
+    console.log('aac不支持')
+  }
+
+  stop (callback) {
+    if (!this._play) {
+      callback?.()
+      return 
+    }
+    this._play = false
+    this.$audio.pause()
+    this.$audio.currentTime = 0
+    this.$audio.dispatchEvent(new Event('stop'))
+    callback?.()
+  }
+
+  destroy() {
+    clearInterval(this._timer)
+    this.stop()
+    this.clearMediaResources()
+  }
+}