LaiTool/src/main/Service/tts.ts

import { errorMessage, successMessage } from '../Public/generalTools'
import { SoftwareService } from '../../define/db/service/SoftWare/softwareService'
import path from 'path'
import { define } from '../../define/define'
import { isEmpty } from 'lodash'
import { ValidateJson } from '../../define/Tools/validate'
const { EdgeTTS } = require('node-edge-tts')

export class TTS {
  softService: SoftwareService

  constructor() { }

  /**
   * 初始化TTS服务
   */
  async InitService() {
    if (!this.softService) {
      this.softService = await SoftwareService.getInstance()
    }
  }

  /**
   * 初始化TTS设置
   */
  async InitTTSSetting() {
    let defaultData = {
      selectModel: 'edge-tts',
      edgeTTS: {
        value: 'zh-CN-XiaoxiaoNeural',
        gender: 'Female',
        label: '晓晓',
        lang: 'zh-CN',
        saveSubtitles: true,
        pitch: 0, // 语调
        rate: 10, // 倍速
        volumn: 0 // 音量
      }
    }
    await this.SaveTTSConfig(defaultData)
    return defaultData
  }

  /**
   * 获取TTS配置
   */
  // @ts-ignore
  async GetTTSCOnfig(): Promise<GeneralResponse.SuccessItem | GeneralResponse.ErrorItem> {
    try {
      await this.InitService()
      let res = this.softService.GetSoftWarePropertyData('ttsSetting')
      let resObj = undefined
      if (isEmpty(res)) {
        // 没有数据，需要初始化
        resObj = await this.InitTTSSetting()
      } else {
        let tryParse = ValidateJson(res)
        if (!tryParse) {
          throw new Error('解析TTS配置失败，数据格式不正确')
        }
        resObj = JSON.parse(res)
      }
      return successMessage(resObj, '获取TTS配置成功', 'TTS_GetTTSCOnfig')
    } catch (error) {
      return errorMessage('获取TTS配置失败，错误信息如下：' + error.toString(), 'TTS_GetTTSCOnfig')
    }
  }
  /**
   * 保存TTS配置
   * @param {*} data 要保存的数据
   */
  // @ts-ignore
  async SaveTTSConfig(data: TTSSettingModel.TTSSetting) {
    try {
      await this.InitService()
      let res = this.softService.SaveSoftwarePropertyData('ttsSetting', JSON.stringify(data))
      return res
    } catch (error) {
      return errorMessage('保存TTS配置失败，错误信息如下：' + error.toString(), 'TTS_SaveTTSConfig')
    }
  }

  /**
   * 生成音频
   * @param text 要生成的文本
   */
  async GenerateAudio(text: string) {
    try {
      await this.InitService()
      let ttsSetting = await this.GetTTSCOnfig()
      if (ttsSetting.code === 0) {
        return ttsSetting
      }
      let res

      let audioPath = path.join(define.project_path, 'audio.mp3')
      let selectModel = ttsSetting.data.selectModel
      switch (selectModel) {
        case 'edge-tts':
          res = await this.GenerateAudioByEdgeTTS(text, ttsSetting.data.edgeTTS)
          break

        default:
          throw new Error('未知的TTS模式')
      }
      return res
    } catch (error) {
      return errorMessage('生成音频失败，错误信息如下：' + error.toString(), 'TTS_GenerateAudio')
    }
  }

  /**
   * 使用EdgeTTS生成音频的方法
   * @param text 要生成的文本
   * @param edgeTTS edgetts的设置
   * @returns
   */
  // @ts-ignore
  async GenerateAudioByEdgeTTS(text: string, edgeTTS: TTSSettingModel.EdgeTTSSetting) {
    try {
      const tts = new EdgeTTS({
        voice: edgeTTS.value,
        lang: edgeTTS.lang,
        outputFormat: 'audio-24khz-96kbitrate-mono-mp3',
        saveSubtitles: edgeTTS.saveSubtitles,
        pitch: `${edgeTTS.pitch}%`,
        rate: `${edgeTTS.rate}%`,
        volumn: `${edgeTTS.volumn}%`
      })
      let ttsRes = await tts.ttsPromise(text, 'C:\\Users\\27698\\Desktop\\audio.mp3')
      console.log(ttsRes)
      return successMessage(
        'C:\\Users\\27698\\Desktop\\audio.mp3',
        '生成音频成功',
        'TTS_GenerateAudioByEdgeTTS'
      )
    } catch (error) {
      return errorMessage(
        '生成音频失败，错误信息如下：' + error.toString(),
        'TTS_GenerateAudioByEdgeTTS'
      )
    }
  }
}