natural-tts 0.3.1

High-level bindings to a variety of text-to-speech libraries.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#[cfg(feature = "coqui")]
pub mod coqui;
#[cfg(feature = "gtts")]
pub mod gtts;
#[cfg(feature = "meta")]
pub mod meta;
#[cfg(feature = "msedge")]
pub mod msedge;
#[cfg(feature = "parler")]
pub mod parler;
#[cfg(feature = "tts-rs")]
pub mod tts_rs;

use crate::{
    utils::{play_wav_file, read_wav_file},
    TtsError,
};
use hound::WavSpec;
#[cfg(feature = "msedge")]
use msedge_tts::tts::AudioMetadata;
use rodio::{cpal::Sample, OutputStream, Sink};
use std::{fs::File, path::PathBuf};

pub enum AudioHandler {
    Sink {
        sink: Sink,
        stream: OutputStream,
    },
    #[cfg(feature = "tts-rs")]
    Tts,
}

impl Clone for AudioHandler {
    fn clone(&self) -> Self {
        match self {
            Self::Sink { .. } => panic!("Sink cant be cloned"),
            #[cfg(feature = "tts-rs")]
            Self::Tts => Self::Tts,
        }
    }
}

impl From<(Sink, OutputStream)> for AudioHandler {
    fn from(value: (Sink, OutputStream)) -> Self {
        Self::Sink {
            sink: value.0,
            stream: value.1,
        }
    }
}

pub trait NaturalModelTrait {
    type SynthesizeType: Sample + Send + hound::Sample;
    fn save(&mut self, message: String, path: &PathBuf) -> Result<(), TtsError>;

    fn start(&mut self, message: String, path: &PathBuf) -> Result<AudioHandler, TtsError> {
        let _ = self.save(message.clone(), path);
        Ok(AudioHandler::from(play_wav_file(path)?))
    }

    fn synthesize(
        &mut self,
        message: String,
        path: &PathBuf,
    ) -> Result<SynthesizedAudio<Self::SynthesizeType>, TtsError> {
        let _ = self.save(message.clone(), path);
        let rwf = read_wav_file(path)?;
        Ok(rwf)
    }
}

pub enum Spec {
    Wav(WavSpec),
    #[cfg(feature = "msedge")]
    Synthesized(String, Vec<AudioMetadata>),
    Unknown,
}

pub struct SynthesizedAudio<T: Sample> {
    pub spec: Spec,
    pub data: Vec<T>,
    pub duration: Option<i32>,
}

impl<T: Sample> SynthesizedAudio<T> {
    pub fn new(data: Vec<T>, spec: Spec, duration: Option<i32>) -> Self {
        return Self {
            data,
            spec,
            duration,
        };
    }
}

pub fn did_save(path: &PathBuf) -> Result<(), TtsError> {
    let file = File::open(path);
    match file {
        Ok(_) => Ok(()),
        Err(_) => Err(TtsError::NotSaved),
    }
}