2020-05-18 20:01:28 +00:00
|
|
|
#[cfg(windows)]
|
2022-03-31 01:13:27 +00:00
|
|
|
use std::{
|
2022-07-26 14:37:45 +00:00
|
|
|
collections::VecDeque,
|
2022-03-31 01:13:27 +00:00
|
|
|
str::FromStr,
|
2022-07-26 14:37:45 +00:00
|
|
|
sync::{Arc, Mutex},
|
2022-03-31 01:13:27 +00:00
|
|
|
};
|
2020-09-23 15:31:21 +00:00
|
|
|
|
|
|
|
use lazy_static::lazy_static;
|
2020-05-18 20:01:28 +00:00
|
|
|
use log::{info, trace};
|
2022-03-31 01:13:27 +00:00
|
|
|
use unic_langid::LanguageIdentifier;
|
2021-11-01 15:36:15 +00:00
|
|
|
use windows::{
|
2021-03-31 15:38:32 +00:00
|
|
|
Foundation::TypedEventHandler,
|
|
|
|
Media::{
|
|
|
|
Core::MediaSource,
|
2021-05-20 22:07:55 +00:00
|
|
|
Playback::{MediaPlayer, MediaPlayerAudioCategory},
|
2022-03-31 01:13:27 +00:00
|
|
|
SpeechSynthesis::{SpeechSynthesizer, VoiceGender, VoiceInformation},
|
2021-03-11 19:21:41 +00:00
|
|
|
},
|
2020-06-14 23:56:01 +00:00
|
|
|
};
|
2020-05-18 20:01:28 +00:00
|
|
|
|
2022-07-26 14:37:45 +00:00
|
|
|
use crate::{
|
|
|
|
Backend, BackendId, Callbacks, Error, Features, Gender, UtteranceId, Voice, CALLBACKS,
|
|
|
|
};
|
2020-05-18 20:01:28 +00:00
|
|
|
|
2021-11-16 17:13:31 +00:00
|
|
|
impl From<windows::core::Error> for Error {
|
|
|
|
fn from(e: windows::core::Error) -> Self {
|
2021-03-31 15:38:32 +00:00
|
|
|
Error::WinRt(e)
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-28 16:09:54 +00:00
|
|
|
#[derive(Clone)]
|
2021-03-31 15:38:32 +00:00
|
|
|
pub struct WinRt {
|
2020-09-23 15:31:21 +00:00
|
|
|
id: BackendId,
|
2022-07-26 14:37:45 +00:00
|
|
|
synth: Arc<SpeechSynthesizer>,
|
2020-05-18 20:01:28 +00:00
|
|
|
player: MediaPlayer,
|
2022-07-26 14:37:45 +00:00
|
|
|
utterances: Arc<Mutex<VecDeque<Utterance>>>,
|
2020-12-08 03:35:07 +00:00
|
|
|
rate: f32,
|
|
|
|
pitch: f32,
|
|
|
|
volume: f32,
|
2022-03-31 01:13:27 +00:00
|
|
|
voice: VoiceInformation,
|
2020-12-08 03:35:07 +00:00
|
|
|
}
|
|
|
|
|
2022-07-26 14:37:45 +00:00
|
|
|
#[derive(Debug)]
|
2020-12-08 03:35:07 +00:00
|
|
|
struct Utterance {
|
|
|
|
id: UtteranceId,
|
|
|
|
text: String,
|
|
|
|
rate: f32,
|
|
|
|
pitch: f32,
|
|
|
|
volume: f32,
|
2022-03-31 01:13:27 +00:00
|
|
|
voice: VoiceInformation,
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
2022-07-26 14:37:45 +00:00
|
|
|
impl Utterance {
|
|
|
|
fn speak(
|
|
|
|
&self,
|
|
|
|
synth: &SpeechSynthesizer,
|
|
|
|
player: &MediaPlayer,
|
|
|
|
callbacks: &mut Callbacks,
|
|
|
|
) -> Result<(), windows::core::Error> {
|
|
|
|
synth.Options()?.SetSpeakingRate(self.rate.into())?;
|
|
|
|
synth.Options()?.SetAudioPitch(self.pitch.into())?;
|
|
|
|
synth.Options()?.SetAudioVolume(self.volume.into())?;
|
|
|
|
synth.SetVoice(&self.voice)?;
|
|
|
|
|
|
|
|
let stream = synth
|
|
|
|
.SynthesizeTextToStreamAsync(&self.text.clone().into())?
|
|
|
|
.get()?;
|
|
|
|
let content_type = stream.ContentType()?;
|
|
|
|
let source = MediaSource::CreateFromStream(&stream, &content_type)?;
|
|
|
|
|
|
|
|
player.SetSource(&source)?;
|
|
|
|
player.Play()?;
|
|
|
|
|
|
|
|
if let Some(callback) = callbacks.utterance_begin.as_mut() {
|
|
|
|
callback(self.id);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-23 15:31:21 +00:00
|
|
|
lazy_static! {
|
|
|
|
static ref NEXT_BACKEND_ID: Mutex<u64> = Mutex::new(0);
|
2020-10-08 12:16:10 +00:00
|
|
|
static ref NEXT_UTTERANCE_ID: Mutex<u64> = Mutex::new(0);
|
2020-09-23 15:31:21 +00:00
|
|
|
}
|
|
|
|
|
2021-03-31 15:38:32 +00:00
|
|
|
impl WinRt {
|
2020-05-18 20:01:28 +00:00
|
|
|
pub fn new() -> std::result::Result<Self, Error> {
|
|
|
|
info!("Initializing WinRT backend");
|
2022-07-26 14:37:45 +00:00
|
|
|
|
2020-05-18 20:01:28 +00:00
|
|
|
let player = MediaPlayer::new()?;
|
2021-03-31 15:38:32 +00:00
|
|
|
player.SetRealTimePlayback(true)?;
|
|
|
|
player.SetAudioCategory(MediaPlayerAudioCategory::Speech)?;
|
2022-07-26 14:37:45 +00:00
|
|
|
|
|
|
|
let bid = {
|
|
|
|
let mut backend_id = NEXT_BACKEND_ID.lock().unwrap();
|
|
|
|
let bid = BackendId::WinRt(*backend_id);
|
|
|
|
*backend_id += 1;
|
|
|
|
|
|
|
|
bid
|
|
|
|
};
|
|
|
|
|
|
|
|
let tts = Self {
|
2020-11-03 17:11:49 +00:00
|
|
|
id: bid,
|
2022-07-26 14:37:45 +00:00
|
|
|
synth: Arc::new(SpeechSynthesizer::new()?),
|
2020-11-03 17:11:49 +00:00
|
|
|
player,
|
2022-07-26 14:37:45 +00:00
|
|
|
utterances: Arc::new(Mutex::new(VecDeque::new())),
|
2020-12-08 03:35:07 +00:00
|
|
|
rate: 1.,
|
|
|
|
pitch: 1.,
|
|
|
|
volume: 1.,
|
2022-03-31 01:13:27 +00:00
|
|
|
voice: SpeechSynthesizer::DefaultVoice()?,
|
2022-07-26 14:37:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
let synth_clone = tts.synth.clone();
|
|
|
|
let utterances_clone = tts.utterances.clone();
|
|
|
|
tts.player.MediaEnded(&TypedEventHandler::new(
|
|
|
|
move |player: &Option<MediaPlayer>, _args| {
|
2022-07-26 15:29:40 +00:00
|
|
|
let mut utterances = utterances_clone.lock().unwrap();
|
|
|
|
|
|
|
|
let ended_utterance = utterances.pop_front().unwrap();
|
|
|
|
|
|
|
|
if let Some(callback) = CALLBACKS
|
|
|
|
.lock()
|
|
|
|
.unwrap()
|
|
|
|
.get_mut(&bid)
|
|
|
|
.unwrap()
|
|
|
|
.utterance_end
|
|
|
|
.as_mut()
|
|
|
|
{
|
|
|
|
callback(ended_utterance.id);
|
|
|
|
}
|
2022-07-26 14:37:45 +00:00
|
|
|
|
2022-07-26 15:29:40 +00:00
|
|
|
if let Some(new_utterance) = utterances.front() {
|
|
|
|
new_utterance.speak(
|
2022-07-26 14:37:45 +00:00
|
|
|
&synth_clone,
|
|
|
|
player.as_ref().unwrap(),
|
|
|
|
CALLBACKS.lock().unwrap().get_mut(&bid).unwrap(),
|
|
|
|
)?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
},
|
|
|
|
))?;
|
|
|
|
|
|
|
|
Ok(tts)
|
2020-07-06 17:52:18 +00:00
|
|
|
}
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
2021-03-31 15:38:32 +00:00
|
|
|
impl Backend for WinRt {
|
2020-09-23 15:31:21 +00:00
|
|
|
fn id(&self) -> Option<BackendId> {
|
|
|
|
Some(self.id)
|
|
|
|
}
|
|
|
|
|
2020-05-18 20:01:28 +00:00
|
|
|
fn supported_features(&self) -> Features {
|
|
|
|
Features {
|
|
|
|
stop: true,
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
rate: true,
|
|
|
|
pitch: true,
|
|
|
|
volume: true,
|
2020-07-07 14:08:44 +00:00
|
|
|
is_speaking: true,
|
2022-03-31 01:13:27 +00:00
|
|
|
voice: true,
|
|
|
|
get_voice: true,
|
2020-09-24 22:56:46 +00:00
|
|
|
utterance_callbacks: true,
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-22 17:40:03 +00:00
|
|
|
fn speak(
|
|
|
|
&mut self,
|
|
|
|
text: &str,
|
|
|
|
interrupt: bool,
|
|
|
|
) -> std::result::Result<Option<UtteranceId>, Error> {
|
2020-11-25 16:07:28 +00:00
|
|
|
if interrupt && self.is_speaking()? {
|
2020-06-14 23:56:01 +00:00
|
|
|
self.stop()?;
|
|
|
|
}
|
2022-07-26 14:37:45 +00:00
|
|
|
|
2020-12-08 03:35:07 +00:00
|
|
|
let utterance_id = {
|
|
|
|
let mut uid = NEXT_UTTERANCE_ID.lock().unwrap();
|
2021-03-31 15:38:32 +00:00
|
|
|
let utterance_id = UtteranceId::WinRt(*uid);
|
2020-12-07 20:58:59 +00:00
|
|
|
*uid += 1;
|
2020-12-08 03:35:07 +00:00
|
|
|
utterance_id
|
2020-12-07 20:58:59 +00:00
|
|
|
};
|
2022-07-26 14:37:45 +00:00
|
|
|
|
|
|
|
let utterance = Utterance {
|
|
|
|
id: utterance_id,
|
|
|
|
text: text.to_string(),
|
|
|
|
rate: self.rate,
|
|
|
|
pitch: self.pitch,
|
|
|
|
volume: self.volume,
|
|
|
|
voice: self.voice.clone(),
|
|
|
|
};
|
|
|
|
|
|
|
|
if !self.is_speaking()? {
|
|
|
|
utterance.speak(
|
|
|
|
&self.synth,
|
|
|
|
&self.player,
|
|
|
|
CALLBACKS.lock().unwrap().get_mut(&self.id).unwrap(),
|
|
|
|
)?;
|
2020-06-15 00:42:48 +00:00
|
|
|
}
|
2022-07-26 14:37:45 +00:00
|
|
|
|
|
|
|
self.utterances.lock().unwrap().push_back(utterance);
|
2020-09-24 22:56:46 +00:00
|
|
|
Ok(Some(utterance_id))
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:52:18 +00:00
|
|
|
fn stop(&mut self) -> std::result::Result<(), Error> {
|
2020-05-18 20:01:28 +00:00
|
|
|
trace!("stop()");
|
2020-11-25 16:07:28 +00:00
|
|
|
if !self.is_speaking()? {
|
|
|
|
return Ok(());
|
|
|
|
}
|
2022-07-26 14:37:45 +00:00
|
|
|
let mut utterances = self.utterances.lock().unwrap();
|
|
|
|
let mut callbacks = CALLBACKS.lock().unwrap();
|
|
|
|
let callbacks = callbacks.get_mut(&self.id).unwrap();
|
|
|
|
if let Some(callback) = callbacks.utterance_stop.as_mut() {
|
|
|
|
let utterances = utterances.iter();
|
|
|
|
for utterance in utterances {
|
|
|
|
callback(utterance.id);
|
2020-11-03 17:11:49 +00:00
|
|
|
}
|
|
|
|
}
|
2022-07-26 14:37:45 +00:00
|
|
|
utterances.clear();
|
2021-03-31 15:38:32 +00:00
|
|
|
self.player.Pause()?;
|
2020-05-18 20:01:28 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
fn min_rate(&self) -> f32 {
|
|
|
|
0.5
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
fn max_rate(&self) -> f32 {
|
|
|
|
6.0
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
fn normal_rate(&self) -> f32 {
|
|
|
|
1.
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
fn get_rate(&self) -> std::result::Result<f32, Error> {
|
2022-07-26 14:37:45 +00:00
|
|
|
Ok(self.rate)
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
fn set_rate(&mut self, rate: f32) -> std::result::Result<(), Error> {
|
2020-12-08 03:35:07 +00:00
|
|
|
self.rate = rate;
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn min_pitch(&self) -> f32 {
|
|
|
|
0.
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
|
|
|
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
fn max_pitch(&self) -> f32 {
|
|
|
|
2.
|
|
|
|
}
|
|
|
|
|
|
|
|
fn normal_pitch(&self) -> f32 {
|
|
|
|
1.
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_pitch(&self) -> std::result::Result<f32, Error> {
|
2022-07-26 14:37:45 +00:00
|
|
|
Ok(self.pitch)
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn set_pitch(&mut self, pitch: f32) -> std::result::Result<(), Error> {
|
2020-12-08 03:35:07 +00:00
|
|
|
self.pitch = pitch;
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn min_volume(&self) -> f32 {
|
|
|
|
0.
|
|
|
|
}
|
|
|
|
|
|
|
|
fn max_volume(&self) -> f32 {
|
|
|
|
1.
|
|
|
|
}
|
|
|
|
|
|
|
|
fn normal_volume(&self) -> f32 {
|
|
|
|
1.
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_volume(&self) -> std::result::Result<f32, Error> {
|
2022-07-26 14:37:45 +00:00
|
|
|
Ok(self.volume)
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn set_volume(&mut self, volume: f32) -> std::result::Result<(), Error> {
|
2020-12-08 03:35:07 +00:00
|
|
|
self.volume = volume;
|
Clean up speech synthesis properties, and implement everything for WinRT.
I'd previously attempted to normalize everything to `u8`, but this had some drawbacks:
* It failed to account for some synthesis drivers defining normal as mid-range, while most define it very low.
* It didn't track the normal value for a given synthesizer.
* There was no clean way to map a curve between the minimum, normal, and maximum rates.
Here we track the minimum, normal, and maximum values of rate, pitch, and volume. Sanity checks are done on set.
Also, as a further proof-of-concept, all properties are now implemented for the WinRT driver.
2020-05-18 23:12:59 +00:00
|
|
|
Ok(())
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
2020-06-02 19:53:14 +00:00
|
|
|
|
2020-06-02 21:59:04 +00:00
|
|
|
fn is_speaking(&self) -> std::result::Result<bool, Error> {
|
2022-07-26 14:37:45 +00:00
|
|
|
Ok(!self.utterances.lock().unwrap().is_empty())
|
2020-06-02 19:53:14 +00:00
|
|
|
}
|
2020-09-05 10:07:51 +00:00
|
|
|
|
2022-03-31 15:43:07 +00:00
|
|
|
fn voice(&self) -> Result<Option<Voice>, Error> {
|
2022-07-26 14:37:45 +00:00
|
|
|
Ok(Some((&self.voice).try_into()?))
|
2020-09-05 10:07:51 +00:00
|
|
|
}
|
|
|
|
|
2022-03-31 01:13:27 +00:00
|
|
|
fn voices(&self) -> Result<Vec<Voice>, Error> {
|
|
|
|
let mut rv: Vec<Voice> = vec![];
|
|
|
|
for voice in SpeechSynthesizer::AllVoices()? {
|
2022-07-26 14:37:45 +00:00
|
|
|
rv.push((&voice).try_into()?);
|
2022-03-31 01:13:27 +00:00
|
|
|
}
|
|
|
|
Ok(rv)
|
2020-09-05 10:07:51 +00:00
|
|
|
}
|
|
|
|
|
2022-03-31 01:13:27 +00:00
|
|
|
fn set_voice(&mut self, voice: &Voice) -> Result<(), Error> {
|
|
|
|
for v in SpeechSynthesizer::AllVoices()? {
|
|
|
|
let vid: String = v.Id()?.try_into()?;
|
|
|
|
if vid == voice.id {
|
2022-07-21 23:34:22 +00:00
|
|
|
self.voice = v;
|
2022-03-31 01:13:27 +00:00
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(Error::OperationFailed)
|
2020-09-05 10:07:51 +00:00
|
|
|
}
|
2020-05-18 20:01:28 +00:00
|
|
|
}
|
2020-09-24 22:56:46 +00:00
|
|
|
|
2022-07-26 14:37:45 +00:00
|
|
|
impl TryInto<Voice> for &VoiceInformation {
|
2022-03-31 01:13:27 +00:00
|
|
|
type Error = Error;
|
|
|
|
|
|
|
|
fn try_into(self) -> Result<Voice, Self::Error> {
|
|
|
|
let gender = self.Gender()?;
|
|
|
|
let gender = if gender == VoiceGender::Male {
|
|
|
|
Gender::Male
|
|
|
|
} else {
|
|
|
|
Gender::Female
|
|
|
|
};
|
|
|
|
let language: String = self.Language()?.try_into()?;
|
|
|
|
let language = LanguageIdentifier::from_str(&language).unwrap();
|
|
|
|
Ok(Voice {
|
|
|
|
id: self.Id()?.try_into()?,
|
|
|
|
name: self.DisplayName()?.try_into()?,
|
2022-03-31 18:25:08 +00:00
|
|
|
gender: Some(gender),
|
2022-03-31 01:13:27 +00:00
|
|
|
language,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|