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