gpt-sovits 0.2.0

A Rust implementation of GPT-SoVITS for high-performance voice synthesis and voice cloning
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//noinspection SpellCheckingInspection
use {
    ndarray::ShapeError,
    ort::Error as OrtError,
    pest::error::Error as PestError,
    std::{
        cmp::Ord,
        error::Error,
        fmt::{Debug, Display, Formatter, Result as FmtResult},
        hash::Hash,
        io::Error as IoError,
        time::SystemTimeError,
    },
    voxudio::OperationError as VoxudioError,
};

#[derive(Debug)]
pub enum GSVError {
    Box(Box<dyn Error + Send + Sync>),
    DecodeTokenFailed,
    GeneratePhonemesOrBertFeaturesFailed(String),
    InputEmpty,
    Io(IoError),
    Ort(OrtError),
    Pest(String),
    Shape(ShapeError),
    SystemTime(SystemTimeError),
    UnknownRuleAll(String),
    UnknownRuleIdent(String),
    UnknownRuleWord(String),
    UnknownGreekLetter(String),
    UnknownOperator(String),
    UnknownFlag(String),
    UnknownRuleInPercent(String),
    UnknownDigit(String),
    UnknownRuleInNum(String),
    UnknownRuleInSigns(String),
    Voxudio(VoxudioError),
}

impl Error for GSVError {}

impl Display for GSVError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        write!(f, "GSVError: ")?;
        match self {
            Self::Box(e) => Display::fmt(e, f),
            Self::DecodeTokenFailed => {
                write!(f, "DecodeTokenFailedError: Can't decode output audio.")
            }
            Self::GeneratePhonemesOrBertFeaturesFailed(s) => write!(
                f,
                "GeneratePhonemesOrBertFeaturesFailedError: No phonemes or BERT features could be generated for the text: {}",
                s
            ),
            Self::InputEmpty => write!(f, "InputEmptyError: Input data is empty."),
            Self::Io(e) => Display::fmt(e, f),
            Self::Ort(e) => write!(f, "OrtError: {}", e),
            Self::Pest(s) => write!(f, "PestError: {}", s),
            Self::Shape(e) => Display::fmt(e, f),
            Self::SystemTime(e) => Display::fmt(e, f),
            Self::UnknownRuleAll(s) => {
                write!(f, "UnknownRuleAllError: Unknown rule in all: {:?}", s)
            }
            Self::UnknownRuleIdent(s) => {
                write!(f, "UnknownRuleIdentError: Unknown rule in ident: {:?}", s)
            }
            Self::UnknownRuleWord(s) => {
                write!(f, "UnknownRuleWordError: Unknown rule in word: {:?}", s)
            }
            Self::UnknownGreekLetter(s) => {
                write!(f, "UnknownGreekLetterError: Unknown Greek letter: {:?}", s)
            }
            Self::UnknownOperator(s) => {
                write!(f, "UnknownOperatorError: Unknown operator: {:?}", s)
            }
            Self::UnknownFlag(s) => {
                write!(f, "UnknownFlagError: Unknown flag: {:?}", s)
            }
            Self::UnknownRuleInPercent(s) => {
                write!(
                    f,
                    "UnknownRuleInPercentError: Unknown rule in percent: {:?}",
                    s
                )
            }
            Self::UnknownDigit(s) => {
                write!(f, "UnknownDigitError: Unknown digit: {:?}", s)
            }
            Self::UnknownRuleInNum(s) => {
                write!(f, "UnknownRuleInNumError: Unknown rule in num: {:?}", s)
            }
            Self::UnknownRuleInSigns(s) => {
                write!(f, "UnknownRuleInSignsError: Unknown rule in signs: {:?}", s)
            }
            Self::Voxudio(e) => Display::fmt(e, f),
        }
    }
}

impl<R> From<OrtError<R>> for GSVError
where
    OrtError<R>: Display,
{
    fn from(value: OrtError<R>) -> Self {
        Self::Pest(format!("{value}"))
    }
}

impl From<IoError> for GSVError {
    fn from(value: IoError) -> Self {
        Self::Io(value)
    }
}

impl From<ShapeError> for GSVError {
    fn from(value: ShapeError) -> Self {
        Self::Shape(value)
    }
}

impl From<SystemTimeError> for GSVError {
    fn from(value: SystemTimeError) -> Self {
        Self::SystemTime(value)
    }
}

impl From<Box<dyn Error + Send + Sync>> for GSVError {
    fn from(value: Box<dyn Error + Send + Sync>) -> Self {
        Self::Box(value)
    }
}

impl<R> From<PestError<R>> for GSVError
where
    R: Copy + Debug + Hash + Ord,
{
    fn from(value: PestError<R>) -> Self {
        Self::Pest(format!("{}", value))
    }
}

impl From<VoxudioError> for GSVError {
    fn from(value: VoxudioError) -> Self {
        Self::Pest(format!("{value}"))
    }
}