piper-plus 0.2.0

High-quality neural text-to-speech engine with 8-language support
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

use piper_plus_g2p::G2pError;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum PiperError {
    #[error("config file not found: {path}")]
    ConfigNotFound { path: String },

    #[error("invalid config: {reason}")]
    InvalidConfig { reason: String },

    #[error("model load failed: {0}")]
    ModelLoad(String),

    #[error("unsupported language: {code}")]
    UnsupportedLanguage { code: String },

    #[error("unknown phoneme: {phoneme}")]
    UnknownPhoneme { phoneme: String },

    #[error("inference failed: {0}")]
    Inference(String),

    #[error("audio output error: {0}")]
    AudioOutput(#[from] std::io::Error),

    #[error("JSON parse error: {0}")]
    JsonParse(#[from] serde_json::Error),

    #[error("WAV write error: {0}")]
    WavWrite(String),

    #[error("phonemization error: {0}")]
    Phonemize(String),

    #[error("dictionary load error: {path}")]
    DictionaryLoad { path: String },

    #[error("jpreprocess initialization error: {0}")]
    JPreprocessInit(String),

    #[error("label parse error: {0}")]
    LabelParse(String),

    #[error("phoneme ID not found: {phoneme}")]
    PhonemeIdNotFound { phoneme: String },

    // --- Phase 4 error variants ---
    #[error("streaming error: {0}")]
    Streaming(String),

    #[error("playback error: {0}")]
    Playback(String),

    #[error("timing error: {0}")]
    Timing(String),

    #[error("download error: {0}")]
    Download(String),

    #[error("resampling error: {0}")]
    Resample(String),

    #[error("device error: {0}")]
    Device(String),

    #[error("batch processing error: {0}")]
    Batch(String),

    #[error("WASM error: {0}")]
    Wasm(String),
}

impl From<G2pError> for PiperError {
    fn from(e: G2pError) -> Self {
        match e {
            G2pError::UnsupportedLanguage { code } => PiperError::UnsupportedLanguage { code },
            G2pError::UnknownPhoneme { phoneme } => PiperError::UnknownPhoneme { phoneme },
            G2pError::Phonemize(msg) => PiperError::Phonemize(msg),
            G2pError::DictionaryLoad { path } => PiperError::DictionaryLoad { path },
            G2pError::PhonemeIdNotFound { phoneme } => PiperError::PhonemeIdNotFound { phoneme },
            G2pError::LabelParse(msg) => PiperError::LabelParse(msg),
            G2pError::JPreprocessInit(msg) => PiperError::JPreprocessInit(msg),
        }
    }
}