def _getAvailableVoices(self):
o = OrderedDict()
for name in os.listdir(_ibmeci.ttsPath):
if name.lower().endswith('.syn'):
info = _ibmeci.langs[name.lower()[:3]]
o[str(info[0])] = VoiceInfo(str(info[0]), info[1], info[2])
return o
def _getAvailableVoices(self):
voices = OrderedDict()
for v in _espeak.getVoiceList():
l = v.languages[1:]
identifier = os.path.basename(v.identifier)
voices[identifier] = VoiceInfo(identifier, v.name, l)
return voices
def _getAvailableVoices(self):
voices = OrderedDict()
v = self._getVoiceTokens()
# #2629: Iterating uses IEnumVARIANT and GetBestInterface doesn't work on tokens returned by some token enumerators.
# Therefore, fetch the items by index, as that method explicitly returns the correct interface.
for i in range(len(v)):
try:
ID = v[i].Id
name = v[i].GetDescription()
try:
language = locale.windows_locale[int(
v[i].getattribute('language').split(';')[0], 16)]
except KeyError:
language = None
# Extract the name Attribute of each voice which could be used in SAPI5 XML for voice selection.
voiceAttribName = v[i].getattribute('name')
except COMError:
log.warning("Could not get the voice info. Skipping...")
voices[ID] = VoiceInfo(ID, name, language)
if voiceAttribName in _realtime.list_VoiceAttribName:
log.warning(
name +
' do not has the required Name attribute in the registry. Hence it could not be used as the secondary voice.'
)
else:
_realtime.list_VoiceAttribName.append(voiceAttribName)
_realtime.list_VoiceID.append(ID)
_realtime.list_VoiceName.append(name)
_realtime.list_VoiceLang.append(language)
return voices
def _getAvailableVoices(self): voices=OrderedDict() for v in _espeak.getVoiceList(): l=v.languages[1:] # #5783: For backwards compatibility, voice identifies should always be lowercase identifier=os.path.basename(v.identifier).lower() voices[identifier]=VoiceInfo(identifier,v.name,l) return voices
def _getVoiceInfoFromOnecoreVoiceString(self, voiceStr):
"""
Produces an NVDA VoiceInfo object representing the given voice string from Onecore speech.
"""
# The voice string is made up of the ID, the language, and the display name.
ID, language, name = voiceStr.split(':')
language = language.replace('-', '_')
return VoiceInfo(ID, name, language=language)
def _getAvailableVoices(self, onlyValid=True):
voices = OrderedDict()
voicesStr = self._dll.ocSpeech_getVoices(self._handle).split('|')
for voiceStr in voicesStr:
id, name = voiceStr.split(":")
if onlyValid and not self._isVoiceValid(id):
continue
voices[id] = VoiceInfo(id, name)
return voices
def _getAvailableVoices(self):
voices = OrderedDict()
for v in _espeak.getVoiceList():
l = v.languages[1:]
# #7167: Some languages names contain unicode characters EG: Norwegian Bokmål
name = v.name.decode("UTF-8")
# #5783: For backwards compatibility, voice identifies should always be lowercase
identifier = os.path.basename(v.identifier).lower()
voices[identifier] = VoiceInfo(identifier, name, l)
return voices
def _getAvailableVoices(self): voices=OrderedDict() for mode in self._enginesList: ID=str(mode.gModeID) name="%s - %s"%(mode.szModeName,mode.szProductName) try: language=locale.windows_locale[mode.language.LanguageID] except KeyError: language=None voices[ID]=VoiceInfo(ID,name,language) return voices
def _makeVoiceInfo(self, v):
localeName = self._languageNamesToLocales.get(v.szLanguage.decode(),
None)
langDescription = None
# if we have the locale name use the localized language description from windows:
if localeName is not None:
langDescription = languageHandler.getLanguageDescription(
localeName)
if not langDescription:
# For some languages (i.g. scotish english) windows doesn't gives us any description.
# The synth returned something in english, it is better than nothing.
langDescription = v.szLanguage.decode()
name = "%s - %s" % (v.szVoiceName.decode(), langDescription)
return VoiceInfo(v.szVoiceName.decode(), name, localeName or None)
def _getAvailableVoices(self):
voices=OrderedDict()
v=self._getVoiceTokens()
# #2629: Iterating uses IEnumVARIANT and GetBestInterface doesn't work on tokens returned by some token enumerators.
# Therefore, fetch the items by index, as that method explicitly returns the correct interface.
for i in range(len(v)):
try:
ID=v[i].Id
name=v[i].GetDescription()
try:
language=locale.windows_locale[int(v[i].getattribute('language').split(';')[0],16)]
except KeyError:
language=None
except COMError:
log.warning("Could not get the voice info. Skipping...")
voices[ID]=VoiceInfo(ID,name,language)
return voices
def _getAvailableVoices(self):
d = OrderedDict()
for name in sorted(voices):
d[name] = VoiceInfo(name, name)
return d
def _getAvailableVariants(self): return OrderedDict((ID,VoiceInfo(ID, name)) for ID, name in self._variantDict.iteritems())
def _get_availableVoices(self):
return OrderedDict(
(profile,
VoiceInfo(profile, profile, self.__voice_languages[profile.split(
"+")[0]])) for profile in self.__profiles)
def _getAvailableVoices(self):
return OrderedDict((("", VoiceInfo("", "Tts3", language="it")), ))
def __init__(self):
self.__lib = ctypes.CDLL(lib_path.encode(sys.getfilesystemencoding()))
self.__lib.RHVoice_initialize.argtypes = (c_char_p, RHVoice_callback,
c_char_p, c_uint)
self.__lib.RHVoice_initialize.restype = c_int
self.__lib.RHVoice_new_message_utf16.argtypes = (c_wchar_p, c_int,
c_int)
self.__lib.RHVoice_new_message_utf16.restype = RHVoice_message
self.__lib.RHVoice_delete_message.argtypes = (RHVoice_message, )
self.__lib.RHVoice_speak.argtypes = (RHVoice_message, )
self.__lib.RHVoice_get_min_rate.restype = c_float
self.__lib.RHVoice_get_rate.restype = c_float
self.__lib.RHVoice_get_max_rate.restype = c_float
self.__lib.RHVoice_get_min_pitch.restype = c_float
self.__lib.RHVoice_get_pitch.restype = c_float
self.__lib.RHVoice_get_max_pitch.restype = c_float
self.__lib.RHVoice_get_volume.restype = c_float
self.__lib.RHVoice_get_max_volume.restype = c_float
self.__lib.RHVoice_get_voice_count.restype = c_int
self.__lib.RHVoice_get_variant_count.restype = c_int
self.__lib.RHVoice_get_voice_name.argtypes = (c_int, )
self.__lib.RHVoice_get_voice_name.restype = c_char_p
self.__lib.RHVoice_get_variant_name.argtypes = (c_int, )
self.__lib.RHVoice_get_variant_name.restype = c_char_p
self.__lib.RHVoice_find_voice.argtypes = (c_char_p, )
self.__lib.RHVoice_find_voice.restype = c_int
self.__lib.RHVoice_find_variant.argtypes = (c_char_p, )
self.__lib.RHVoice_find_variant.restype = c_int
self.__lib.RHVoice_get_voice.restype = c_int
self.__lib.RHVoice_get_variant.restype = c_int
self.__lib.RHVoice_set_voice.argtypes = (c_int, )
self.__lib.RHVoice_set_variant.argtypes = (c_int, )
self.__lib.RHVoice_get_version.restype = c_char_p
self.__silence_flag = threading.Event()
self.__audio_callback = AudioCallback(self.__lib, self.__silence_flag)
self.__audio_callback_wrapper = RHVoice_callback(self.__audio_callback)
sample_rate = self.__lib.RHVoice_initialize(
data_path.encode("UTF-8"), self.__audio_callback_wrapper,
cfg_path.encode("UTF-8"), 0)
if sample_rate == 0:
raise RuntimeError("RHVoice: initialization error")
voice_count = self.__lib.RHVoice_get_voice_count()
if voice_count == 0:
raise RuntimeError("RHVoice: initialization error")
self.__player = nvwave.WavePlayer(
channels=1,
samplesPerSec=sample_rate,
bitsPerSample=16,
outputDevice=config.conf["speech"]["outputDevice"])
self.__audio_callback.set_player(self.__player)
self.__tts_queue = Queue.Queue()
self.__tts_thread = TTSThread(self.__lib, self.__tts_queue,
self.__player, self.__silence_flag)
self._availableVoices = OrderedDict()
for id in range(1, voice_count + 1):
name = self.__lib.RHVoice_get_voice_name(id)
self._availableVoices[name] = VoiceInfo(name, name, "ru")
self.__lib.RHVoice_set_voice(1)
self.__voice = self.__lib.RHVoice_get_voice_name(1)
variant_count = self.__lib.RHVoice_get_variant_count()
self._availableVariants = OrderedDict()
for id in range(1, variant_count + 1):
name = self.__lib.RHVoice_get_variant_name(id)
self._availableVariants[name] = VoiceInfo(name, name, "ru")
self.__lib.RHVoice_set_variant(1)
self.__variant = self.__lib.RHVoice_get_variant_name(1)
self.__rate = 50
self.__pitch = 50
self.__volume = 50
self.__native_rate_range = (self.__lib.RHVoice_get_min_rate(),
self.__lib.RHVoice_get_max_rate(),
self.__lib.RHVoice_get_rate())
self.__native_pitch_range = (self.__lib.RHVoice_get_min_pitch(),
self.__lib.RHVoice_get_max_pitch(),
self.__lib.RHVoice_get_pitch())
self.__native_volume_range = (0, self.__lib.RHVoice_get_max_volume(),
self.__lib.RHVoice_get_volume())
self.__char_mapping = {}
for c in range(9):
self.__char_mapping[c] = 32
self.__char_mapping[11] = 32
self.__char_mapping[12] = 32
for c in range(14, 32):
self.__char_mapping[c] = 32
self.__char_mapping[ord("<")] = u"<"
self.__char_mapping[ord("&")] = u"&"
self.__tts_thread.start()
log.info("Using RHVoice version %s" % self.__lib.RHVoice_get_version())
class SynthDriver(SynthDriver):
name = "pico"
description = "Svox pico synthesizer"
supportedSettings=(SynthDriver.VoiceSetting(),SynthDriver.RateSetting(),SynthDriver.PitchSetting(),SynthDriver.VolumeSetting())
supportedCommands = {
IndexCommand,
}
supportedNotifications = {synthIndexReached, synthDoneSpeaking}
availableVoices=OrderedDict()
availableVoices["en-us"] = VoiceInfo('en-us', _('American English'), "en-us")
availableVoices["en-gb"] = VoiceInfo('en-gb', _('British English'), "en-gb")
availableVoices["es"] = VoiceInfo('es', _('Spanish'), "es")
availableVoices["fr"] = VoiceInfo('fr', _('French'), "fr")
availableVoices["it"] = VoiceInfo('it', _('Italian'), "it")
availableVoices["de"] = VoiceInfo('de', _('Deutch'), "de")
_voice = 'en-us'
pitch = 50
rate = 50
volume = 100
#:tuples of (langName,langData,speakerData)
voice_resources={
'en-us': (b'American English', b'en-US_ta.bin', b'en-US_lh0_sg.bin'),
'en-gb': (b'British English', b'en-GB_ta.bin', b'en-GB_kh0_sg.bin'),
'es': (b'Spanish', b'es-ES_ta.bin', b'es-ES_zl0_sg.bin'),
'fr': (b'French', b'fr-FR_ta.bin', b'fr-FR_nk0_sg.bin'),
'it': (b'Italian', b'it-IT_ta.bin', b'it-IT_cm0_sg.bin'),
'de': (b'Deutch', b'de-DE_ta.bin', b'de-DE_gl0_sg.bin'),
}
@classmethod
def check(cls):
return os.path.isfile(os.path.join(BASE_PATH, "svox-pico.dll"))
def pico_system_errcheck(self,result,func,args):
if result!=0:
message=ctypes.create_string_buffer(200)
self.dll.pico_getSystemStatusMessage(self.pico_system,result,message)
raise RuntimeError("error while calling '%s' with arguments %s. underlying API reports: '%s'"%(func.__name__,args,message.value))
return result
def pico_engine_errcheck(self,result,func,args):
if result<0:
message=ctypes.create_string_buffer(200)
self.dll.pico_getEngineStatusMessage(self.pico_engine, result, message)
raise RuntimeError("error while calling '%s' with arguments %s. underlying API reports: '%s'"%(func.__name__,args,message.value))
return result
def __init__(self):
self.dll=ctypes.cdll.LoadLibrary(os.path.join(BASE_PATH, 'svox-pico.dll'))
#prepare dll object
system_functs = ('pico_initialize', 'pico_terminate', 'pico_getSystemStatusMessage', 'pico_getNrSystemWarnings',
'pico_getSystemWarning', 'pico_loadResource', 'pico_unloadResource', 'pico_getResourceName', 'pico_createVoiceDefinition', 'pico_addResourceToVoiceDefinition',
'pico_releaseVoiceDefinition', 'pico_newEngine', 'pico_disposeEngine')
for func in system_functs:
getattr(self.dll,func).errcheck=self.pico_system_errcheck
engine_funcs = ('pico_putTextUtf8', 'pico_getData', 'pico_resetEngine', 'pico_getEngineStatusMessage', 'pico_getNrEngineWarnings', 'pico_getEngineWarning')
for func in engine_funcs:
getattr(self.dll, func).errcheck = self.pico_engine_errcheck
#init pico system
self._svox_memory = ctypes.create_string_buffer(SVOX_MEMORY_SIZE)
self.pico_system = pico_system()
self.dll.pico_initialize(self._svox_memory, SVOX_MEMORY_SIZE, ctypes.byref(self.pico_system))
self.pico_engine = None
self.player = nvwave.WavePlayer(channels=1, samplesPerSec=16000, bitsPerSample=16, outputDevice=config.conf["speech"]["outputDevice"])
self.queue = queue.Queue()
self.isSpeaking = False
self.background_thread = threading.Thread(target=self.background_thread_func)
self.background_thread.daemon = True
self.background_thread.start()
self._set_voice("es")
#log the version
#version_string=ctypes.create_string_buffer(200)
#self.dll.picoext_getVersionInfo(version_string,200)
#log.info("Using pico version '%s'"%version_string.value)
def load_resources(self, name, langData, speakerData):
"""Loads lingware data, defines voice"""
langRes = pico_resource()
self.dll.pico_loadResource(self.pico_system, os.path.join(BASE_PATH.encode('utf-8'), b'svox-pico-data', langData), ctypes.byref(langRes))
langResName=ctypes.create_string_buffer(200)
self.dll.pico_getResourceName(self.pico_system, langRes, langResName)
speakerRes = pico_resource()
self.dll.pico_loadResource(self.pico_system, os.path.join(BASE_PATH.encode('utf-8'), b'svox-pico-data', speakerData), ctypes.byref(speakerRes))
speakerResName=ctypes.create_string_buffer(200)
self.dll.pico_getResourceName(self.pico_system, speakerRes, speakerResName)
self.dll.pico_createVoiceDefinition(self.pico_system, name)
self.dll.pico_addResourceToVoiceDefinition(self.pico_system, name, langResName)
self.dll.pico_addResourceToVoiceDefinition(self.pico_system, name, speakerResName)
self._resources = (name, langRes, speakerRes)
def free_resources(self):
if not self._resources: return
self.dll.pico_releaseVoiceDefinition(self.pico_system,self._resources[0])
self.dll.pico_unloadResource(self.pico_system,ctypes.byref(self._resources[1]))
self.dll.pico_unloadResource(self.pico_system,ctypes.byref(self._resources[2]))
self._resources=None
def terminate(self):
self.cancel()
self.queue.put((None,None))
self.background_thread.join()
self.player.close()
self.player=None
if self.pico_engine:
self.dll.pico_disposeEngine(self.pico_system,ctypes.byref(self.pico_engine))
self.free_resources()
self.dll.pico_terminate(ctypes.byref(self.pico_system))
self.pico_system=None
del self.dll
def _get_voice(self):
return self._voice
def _set_voice(self,value):
name = self.voice_resources[value][0]
if self.pico_engine:
self.cancel()
self.queue.join()
self.dll.pico_disposeEngine(self.pico_system,ctypes.byref(self.pico_engine))
self.free_resources()
self.load_resources(*self.voice_resources[value])
self.pico_engine = pico_engine()
self.dll.pico_newEngine(self.pico_system, name, ctypes.byref(self.pico_engine))
self._voice = value
def build_string(self,s):
"""applies voice parameters"""
pitch=self.pitch+50 if self.pitch<=50 else self.pitch*2
speed = int(20 +(self.rate/50.0) *80) if self.rate<=50 else 100 +(self.rate-50)*8
volume = self.volume*0.7
return ('<pitch level="%d"><speed level="%d"><volume level="%d">%s</volume></speed></pitch>' %(pitch, speed, volume, s)).encode('utf-8')
def background_thread_func(self):
bytes_sent=ctypes.c_int16()
out_buffer=ctypes.create_string_buffer(OUT_BUFFER_SIZE)
bytes_received=ctypes.c_int16()
data_type=ctypes.c_int16()
while True:
data, index = self.queue.get()
if data is None:
break
synthIndexReached.notify(synth=self, index=index)
remaining=len(data)+1
while remaining and self.isSpeaking:
self.dll.pico_putTextUtf8(self.pico_engine, data, remaining, ctypes.byref(bytes_sent))
remaining-=bytes_sent.value
data=data[bytes_sent.value:]
status=PICO_STEP_BUSY
buf=BytesIO()
while self.isSpeaking and status==PICO_STEP_BUSY:
status=self.dll.pico_getData(self.pico_engine, out_buffer, OUT_BUFFER_SIZE, ctypes.byref(bytes_received), ctypes.byref(data_type))
if status==PICO_STEP_BUSY:
buf.write(ctypes.string_at(out_buffer, bytes_received.value))
if buf.tell() >= 4096:
self.player.feed(buf.getvalue())
buf.seek(0)
buf.truncate(0)
else:
if buf.tell():
self.player.feed(buf.getvalue())
synthDoneSpeaking.notify(synth=self)
self.player.idle()
if not self.isSpeaking: #stop requested during playback
self.dll.pico_resetEngine(self.pico_engine,0)
self.lastIndex=None
self.queue.task_done()
def cancel(self):
#clear queue
try:
while True:
self.queue.get_nowait()
self.queue.task_done()
except queue.Empty:
pass
self.isSpeaking=False
self.player.stop()
self.lastIndex=None
def speak(self,speechSequence):
self.isSpeaking=True
textList=[]
index=None
for item in speechSequence:
if isinstance(item, str):
textList.append(item)
elif isinstance(item,speech.IndexCommand):
index=item.index
text = " ".join(textList)
if text:
self.queue.put((self.build_string(text), index))
def pause(self,switch):
self.player.pause(switch)
def _getAvailableVariants(self):
dbs = self._voiceManager.defaultVoiceInstance.variants
return OrderedDict([(d, VoiceInfo(d, d)) for d in dbs])
class SynthDriver(SynthDriver):
name = "newfon"
description = "Newfon"
supportedSettings = (
SynthDriver.VoiceSetting(),
SynthDriver.LanguageSetting(),
SynthDriver.RateSetting(),
SynthSetting("accel", _("&Acceleration")),
SynthDriver.PitchSetting(),
SynthDriver.InflectionSetting(10),
SynthDriver.VolumeSetting(),
)
_volume = 100
_language = "ru"
_pitch = 50
_accel = 0
_inflection = 50
_rate = 70
availableVoices = OrderedDict((
str(index), VoiceInfo(str(index), name)
) for index, name in enumerate(
[_("male 1"), _("female 1"),
_("male 2"), _("female 2")]))
availableAccels = OrderedDict(
(str(x), StringParameterInfo(str(x), str(x))) for x in xrange(8))
pitchTable = [(90, 130), (190, 330), (60, 120), (220, 340)]
availableLanguages = OrderedDict(
(("ru", LanguageInfo("ru")), ("uk", LanguageInfo("uk"))))
newfon_lib = None
sdrvxpdbDll = None
dictDll = None
@classmethod
def check(cls):
return os.path.isfile('synthDrivers/newfon_nvda.dll')
def calculateMinMaxPitch(self, pitch, inflection):
min, max = self.pitchTable[int(self.voice)]
i = max - min
i = int((i / 50.0) * ((inflection - 50) / 2))
min -= i
max += i
i = int((pitch - 50) / 1.3)
min += i
max += i
return min, max
def __init__(self):
global player
player = nvwave.WavePlayer(
channels=1,
samplesPerSec=10000,
bitsPerSample=8,
outputDevice=config.conf["speech"]["outputDevice"])
self.hasDictLib = os.path.isfile('synthDrivers/dict.dll')
if self.hasDictLib:
self.sdrvxpdb_lib = windll.LoadLibrary(
r"synthDrivers\sdrvxpdb.dll")
self.dict_lib = windll.LoadLibrary(r"synthDrivers\dict.dll")
self.newfon_lib = windll.LoadLibrary(r"synthDrivers\newfon_nvda.dll")
self.newfon_lib.speakText.argtypes = [c_char_p, c_int]
if not self.newfon_lib.initialize(): raise Exception
self.newfon_lib.set_callback(processAudio)
self.newfon_lib.set_dictionary(1)
def terminate(self):
self.cancel()
global player
player.close()
player = None
self.newfon_lib.terminate()
del self.newfon_lib
if self.hasDictLib:
del self.dict_lib
del self.sdrvxpdb_lib
def speakText(self, text, index=None):
global isSpeaking
isSpeaking = True
text = processText(text, self._language)
if index is not None:
self.newfon_lib.speakText(text, index)
else:
self.newfon_lib.speakText(text, -1)
def _get_lastIndex(self):
return self.newfon_lib.get_lastIndex()
def cancel(self):
self.newfon_lib.cancel()
global isSpeaking, player
isSpeaking = False
player.stop()
def _get_voice(self):
return str(self.newfon_lib.get_voice())
def _set_voice(self, value):
self.newfon_lib.set_voice(int(value))
self._set_pitch(self._pitch)
def _get_volume(self):
return self._volume
def _set_volume(self, value):
self.newfon_lib.set_volume(value)
self._volume = value
def _get_rate(self):
return self._rate
def _set_rate(self, value):
self.newfon_lib.set_rate(value)
self._rate = value
def _set_pitch(self, value):
#if value <= 50: value = 50
#self.newfon_lib.set_accel(value/5 -10 )
self._pitch = value
min, max = self.calculateMinMaxPitch(self._pitch, self._inflection)
self.newfon_lib.set_pitch_min(min)
self.newfon_lib.set_pitch_max(max)
def _get_pitch(self):
return self._pitch
def pause(self, switch):
global player
player.pause(switch)
def _get_language(self):
return self._language
def _set_language(self, language):
self._language = language
if not self.hasDictLib: return
if language == "ru": self.newfon_lib.set_dictionary(1)
else: self.newfon_lib.set_dictionary(0)
def _set_inflection(self, inflection):
self._inflection = inflection
self._set_pitch(self._pitch)
def _get_inflection(self):
return self._inflection
def _set_accel(self, a):
self._accel = a
self.newfon_lib.set_accel(int(a))
def _get_accel(self):
return self._accel