supertonic-core 0.1.1

Engine-agnostic TTS pipeline for Supertonic — text processing, audio encoding, style loading
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
102
103
104
105
106
107
108
109
110
111
112
113

use async_trait::async_trait;

use crate::config::Config;

#[derive(Debug, Clone)]
pub enum TensorValue {
    F32(ndarray::Array<f32, ndarray::IxDyn>),
    I64(ndarray::Array<i64, ndarray::IxDyn>),
}

impl TensorValue {
    pub fn as_f32(&self) -> Option<&ndarray::Array<f32, ndarray::IxDyn>> {
        match self {
            TensorValue::F32(arr) => Some(arr),
            _ => None,
        }
    }

    pub fn into_f32(self) -> Option<ndarray::Array<f32, ndarray::IxDyn>> {
        match self {
            TensorValue::F32(arr) => Some(arr),
            _ => None,
        }
    }

    pub fn shape(&self) -> &[usize] {
        match self {
            TensorValue::F32(arr) => arr.shape(),
            TensorValue::I64(arr) => arr.shape(),
        }
    }
}

impl From<ndarray::Array<f32, ndarray::IxDyn>> for TensorValue {
    fn from(arr: ndarray::Array<f32, ndarray::IxDyn>) -> Self {
        TensorValue::F32(arr)
    }
}

impl From<ndarray::Array<i64, ndarray::IxDyn>> for TensorValue {
    fn from(arr: ndarray::Array<i64, ndarray::IxDyn>) -> Self {
        TensorValue::I64(arr)
    }
}

#[derive(Debug, Clone)]
pub struct SynthesisParams {
    pub total_step: usize,
    pub speed: f32,
    pub silence_duration: f32,
    pub rng_seed: Option<u64>,
}

impl Default for SynthesisParams {
    fn default() -> Self {
        SynthesisParams {
            total_step: 8,
            speed: 1.05,
            silence_duration: 0.3,
            rng_seed: None,
        }
    }
}

#[derive(Debug, Clone)]
pub struct SynthesisResult {
    pub audio: Vec<f32>,
    pub duration_secs: f32,
    pub sample_rate: u32,
}

#[derive(Debug, Clone)]
pub struct ChunkResult {
    pub audio: Vec<f32>,
    pub duration_secs: f32,
    pub chunk_index: usize,
    pub is_last: bool,
}

#[async_trait]
pub trait InferenceEngine: Send + Sync {
    async fn predict_duration(
        &self,
        text_ids: &TensorValue,
        style_dp: &TensorValue,
        text_mask: &TensorValue,
    ) -> Result<TensorValue, anyhow::Error>;

    async fn encode_text(
        &self,
        text_ids: &TensorValue,
        style_ttl: &TensorValue,
        text_mask: &TensorValue,
    ) -> Result<TensorValue, anyhow::Error>;

    async fn estimate_vector(
        &self,
        noisy_latent: &TensorValue,
        text_emb: &TensorValue,
        style_ttl: &TensorValue,
        latent_mask: &TensorValue,
        text_mask: &TensorValue,
        current_step: &TensorValue,
        total_step: &TensorValue,
    ) -> Result<TensorValue, anyhow::Error>;

    async fn vocode(
        &self,
        latent: &TensorValue,
    ) -> Result<TensorValue, anyhow::Error>;

    fn config(&self) -> &Config;
}