diff --git a/Cargo.lock b/Cargo.lock index 3245a45..6a64f06 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1425,9 +1425,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.26" +version = "0.4.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e" +checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" [[package]] name = "macro_rules_attribute" @@ -2312,6 +2312,20 @@ dependencies = [ "zstd", ] +[[package]] +name = "sbv2_editor" +version = "0.2.0-alpha6" +dependencies = [ + "anyhow", + "axum", + "dotenvy", + "env_logger", + "log", + "sbv2_core", + "serde", + "tokio", +] + [[package]] name = "sbv2_wasm" version = "0.2.0-alpha6" @@ -2364,18 +2378,18 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.218" +version = "1.0.219" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8dfc9d19bdbf6d17e22319da49161d5d0108e4188e8b680aef6299eed22df60" +checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.218" +version = "1.0.219" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f09503e191f4e797cb8aac08e9a4a4695c5edf6a2e70e376d961ddd5c969f82b" +checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" dependencies = [ "proc-macro2", "quote", @@ -2732,9 +2746,9 @@ dependencies = [ [[package]] name = "tokio" -version = "1.43.0" +version = "1.44.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d61fa4ffa3de412bfea335c6ecff681de2b609ba3c77ef3e00e521813a9ed9e" +checksum = "f382da615b842244d4b8738c82ed1275e6c5dd90c459a30941cd07080b06c91a" dependencies = [ "backtrace", "bytes", diff --git a/Cargo.toml b/Cargo.toml index 240b6e0..fe3e0ab 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] resolver = "2" -members = ["./crates/sbv2_api", "./crates/sbv2_core", "./crates/sbv2_bindings", "./crates/sbv2_wasm"] +members = ["./crates/sbv2_api", "./crates/sbv2_core", "./crates/sbv2_bindings", "./crates/sbv2_wasm", "crates/sbv2_editor"] [workspace.package] version = "0.2.0-alpha6" diff --git a/crates/sbv2_core/src/jtalk.rs b/crates/sbv2_core/src/jtalk.rs index 8359784..205be8e 100644 --- a/crates/sbv2_core/src/jtalk.rs +++ b/crates/sbv2_core/src/jtalk.rs @@ -1,5 +1,5 @@ use crate::error::{Error, Result}; -use crate::mora::{MORA_KATA_TO_MORA_PHONEMES, VOWELS}; +use crate::mora::{CONSONANTS, MORA_KATA_TO_MORA_PHONEMES, MORA_PHONEMES_TO_MORA_KATA, VOWELS}; use crate::norm::{replace_punctuation, PUNCTUATIONS}; use jpreprocess::{kind, DefaultTokenizer, JPreprocess, SystemDictionaryConfig, UserDictionary}; use once_cell::sync::Lazy; @@ -76,6 +76,34 @@ static MORA_PATTERN: Lazy> = Lazy::new(|| { }); static LONG_PATTERN: Lazy = Lazy::new(|| Regex::new(r"(\w)(ー*)").unwrap()); +fn phone_tone_to_kana(phones: Vec, tones: Vec) -> Vec<(String, i32)> { + let phones = &phones[1..]; + let tones = &tones[1..]; + let mut results = Vec::new(); + let mut current_mora = String::new(); + for ((phone, next_phone), (&tone, &next_tone)) in phones + .iter() + .zip(phones.iter().skip(1)) + .zip(tones.iter().zip(tones.iter().skip(1))) + { + if PUNCTUATIONS.contains(&phone.clone().as_str()) { + results.push((phone.to_string(), tone)); + continue; + } + if CONSONANTS.contains(&phone.clone()) { + assert_eq!(current_mora, ""); + assert_eq!(tone, next_tone); + current_mora = phone.to_string() + } else { + current_mora += phone; + let kana = MORA_PHONEMES_TO_MORA_KATA.get(¤t_mora).unwrap(); + results.push((kana.to_string(), tone)); + current_mora = String::new(); + } + } + results +} + pub struct JTalkProcess { jpreprocess: Arc, parsed: Vec, @@ -165,6 +193,11 @@ impl JTalkProcess { Ok((phones, tones, new_word2ph)) } + pub fn g2kana_tone(&self) -> Result> { + let (phones, tones, _) = self.g2p()?; + Ok(phone_tone_to_kana(phones, tones)) + } + fn distribute_phone(n_phone: i32, n_word: i32) -> Vec { let mut phones_per_word = vec![0; n_word as usize]; for _ in 0..n_phone { diff --git a/crates/sbv2_core/src/main.rs b/crates/sbv2_core/src/main.rs index 07d9843..d635a4f 100644 --- a/crates/sbv2_core/src/main.rs +++ b/crates/sbv2_core/src/main.rs @@ -30,8 +30,7 @@ fn main_inner() -> anyhow::Result<()> { } } - let audio = - tts_holder.easy_synthesize(ident, &text, 0, 0, tts::SynthesizeOptions::default())?; + let audio = tts_holder.easy_synthesize(ident, text, 0, 0, tts::SynthesizeOptions::default())?; fs::write("output.wav", audio)?; Ok(()) diff --git a/crates/sbv2_core/src/mora.rs b/crates/sbv2_core/src/mora.rs index de7f54f..4becd67 100644 --- a/crates/sbv2_core/src/mora.rs +++ b/crates/sbv2_core/src/mora.rs @@ -25,6 +25,21 @@ static MORA_LIST_ADDITIONAL: Lazy> = Lazy::new(|| { data.additional }); +pub static MORA_PHONEMES_TO_MORA_KATA: Lazy> = Lazy::new(|| { + let mut map = HashMap::new(); + for mora in MORA_LIST_MINIMUM.iter() { + map.insert( + format!( + "{}{}", + mora.consonant.clone().unwrap_or("".to_string()), + mora.vowel + ), + mora.mora.clone(), + ); + } + map +}); + pub static MORA_KATA_TO_MORA_PHONEMES: Lazy, String)>> = Lazy::new(|| { let mut map = HashMap::new(); @@ -37,4 +52,12 @@ pub static MORA_KATA_TO_MORA_PHONEMES: Lazy, Str map }); +pub static CONSONANTS: Lazy> = Lazy::new(|| { + let consonants = MORA_KATA_TO_MORA_PHONEMES + .values() + .filter_map(|(consonant, _)| consonant.clone()) + .collect::>(); + consonants +}); + pub const VOWELS: [&str; 6] = ["a", "i", "u", "e", "o", "N"]; diff --git a/crates/sbv2_core/src/tts.rs b/crates/sbv2_core/src/tts.rs index 0c45da5..83d8c1a 100644 --- a/crates/sbv2_core/src/tts.rs +++ b/crates/sbv2_core/src/tts.rs @@ -41,7 +41,7 @@ pub struct TTSModelHolder { tokenizer: Tokenizer, bert: Session, models: Vec, - jtalk: jtalk::JTalk, + pub jtalk: jtalk::JTalk, max_loaded_models: Option, } @@ -205,6 +205,23 @@ impl TTSModelHolder { ) -> Result<(Array2, Array1, Array1, Array1)> { crate::tts_util::parse_text_blocking( text, + None, + &self.jtalk, + &self.tokenizer, + |token_ids, attention_masks| { + crate::bert::predict(&mut self.bert, token_ids, attention_masks) + }, + ) + } + + pub fn parse_text_neo( + &mut self, + text: String, + given_tones: Option>, + ) -> Result<(Array2, Array1, Array1, Array1)> { + crate::tts_util::parse_text_blocking( + &text, + given_tones, &self.jtalk, &self.tokenizer, |token_ids, attention_masks| { @@ -347,6 +364,79 @@ impl TTSModelHolder { }; tts_util::array_to_vec(audio_array) } + + pub fn easy_synthesize_neo + Copy>( + &mut self, + ident: I, + text: &str, + given_tones: Option>, + style_id: i32, + speaker_id: i64, + options: SynthesizeOptions, + ) -> Result> { + self.find_and_load_model(ident)?; + let style_vector = self.get_style_vector(ident, style_id, options.style_weight)?; + let audio_array = if options.split_sentences { + let texts: Vec<&str> = text.split('\n').collect(); + let mut audios = vec![]; + for (i, t) in texts.iter().enumerate() { + if t.is_empty() { + continue; + } + let (bert_ori, phones, tones, lang_ids) = + self.parse_text_neo(t.to_string(), given_tones.clone())?; + + let vits2 = self + .find_model(ident)? + .vits2 + .as_mut() + .ok_or(Error::ModelNotFoundError(ident.into().to_string()))?; + let audio = model::synthesize( + vits2, + bert_ori.to_owned(), + phones, + Array1::from_vec(vec![speaker_id]), + tones, + lang_ids, + style_vector.clone(), + options.sdp_ratio, + options.length_scale, + 0.677, + 0.8, + )?; + audios.push(audio.clone()); + if i != texts.len() - 1 { + audios.push(Array3::zeros((1, 1, 22050))); + } + } + concatenate( + Axis(2), + &audios.iter().map(|x| x.view()).collect::>(), + )? + } else { + let (bert_ori, phones, tones, lang_ids) = self.parse_text(text)?; + + let vits2 = self + .find_model(ident)? + .vits2 + .as_mut() + .ok_or(Error::ModelNotFoundError(ident.into().to_string()))?; + model::synthesize( + vits2, + bert_ori.to_owned(), + phones, + Array1::from_vec(vec![speaker_id]), + tones, + lang_ids, + style_vector, + options.sdp_ratio, + options.length_scale, + 0.677, + 0.8, + )? + }; + tts_util::array_to_vec(audio_array) + } } /// Synthesize options diff --git a/crates/sbv2_core/src/tts_util.rs b/crates/sbv2_core/src/tts_util.rs index 24b059a..37f89ae 100644 --- a/crates/sbv2_core/src/tts_util.rs +++ b/crates/sbv2_core/src/tts_util.rs @@ -1,10 +1,22 @@ use std::io::Cursor; use crate::error::Result; +use crate::jtalk::JTalkProcess; +use crate::mora::MORA_KATA_TO_MORA_PHONEMES; +use crate::norm::PUNCTUATIONS; use crate::{jtalk, nlp, norm, tokenizer, utils}; use hound::{SampleFormat, WavSpec, WavWriter}; use ndarray::{concatenate, s, Array, Array1, Array2, Array3, Axis}; use tokenizers::Tokenizer; + +pub fn preprocess_parse_text(text: &str, jtalk: &jtalk::JTalk) -> Result<(String, JTalkProcess)> { + let text = jtalk.num2word(text)?; + let normalized_text = norm::normalize_text(&text); + + let process = jtalk.process_text(&normalized_text)?; + Ok((normalized_text, process)) +} + /// Parse text and return the input for synthesize /// /// # Note @@ -21,13 +33,9 @@ pub async fn parse_text( Box>>>, >, ) -> Result<(Array2, Array1, Array1, Array1)> { - let text = jtalk.num2word(text)?; - let normalized_text = norm::normalize_text(&text); - - let process = jtalk.process_text(&normalized_text)?; + let (normalized_text, process) = preprocess_parse_text(text, jtalk)?; let (phones, tones, mut word2ph) = process.g2p()?; let (phones, tones, lang_ids) = nlp::cleaned_text_to_sequence(phones, tones); - let phones = utils::intersperse(&phones, 0); let tones = utils::intersperse(&tones, 0); let lang_ids = utils::intersperse(&lang_ids, 0); @@ -92,6 +100,7 @@ pub async fn parse_text( #[allow(clippy::type_complexity)] pub fn parse_text_blocking( text: &str, + given_tones: Option>, jtalk: &jtalk::JTalk, tokenizer: &Tokenizer, bert_predict: impl FnOnce(Vec, Vec) -> Result>, @@ -100,7 +109,10 @@ pub fn parse_text_blocking( let normalized_text = norm::normalize_text(&text); let process = jtalk.process_text(&normalized_text)?; - let (phones, tones, mut word2ph) = process.g2p()?; + let (phones, mut tones, mut word2ph) = process.g2p()?; + if let Some(given_tones) = given_tones { + tones = given_tones; + } let (phones, tones, lang_ids) = nlp::cleaned_text_to_sequence(phones, tones); let phones = utils::intersperse(&phones, 0); @@ -178,3 +190,23 @@ pub fn array_to_vec(audio_array: Array3) -> Result> { writer.finalize()?; Ok(cursor.into_inner()) } + +pub fn kata_tone2phone_tone(kata_tone: Vec<(String, i32)>) -> Vec<(String, i32)> { + let mut results = vec![("_".to_string(), 0)]; + for (mora, tone) in kata_tone { + if PUNCTUATIONS.contains(&mora.as_str()) { + results.push((mora, 0)); + continue; + } else { + let (consonant, vowel) = MORA_KATA_TO_MORA_PHONEMES.get(&mora).unwrap(); + if let Some(consonant) = consonant { + results.push((consonant.to_string(), tone)); + results.push((vowel.to_string(), tone)); + } else { + results.push((vowel.to_string(), tone)); + } + } + } + results.push(("_".to_string(), 0)); + results +} diff --git a/crates/sbv2_editor/Cargo.toml b/crates/sbv2_editor/Cargo.toml new file mode 100644 index 0000000..3dd2501 --- /dev/null +++ b/crates/sbv2_editor/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "sbv2_editor" +version.workspace = true +edition.workspace = true +description.workspace = true +license.workspace = true +readme.workspace = true +repository.workspace = true +documentation.workspace = true + +[dependencies] +anyhow.workspace = true +axum = "0.8.1" +dotenvy.workspace = true +env_logger.workspace = true +log = "0.4.27" +sbv2_core = { version = "0.2.0-alpha6", path = "../sbv2_core", features = ["aivmx"] } +serde = { version = "1.0.219", features = ["derive"] } +tokio = { version = "1.44.1", features = ["full"] } diff --git a/crates/sbv2_editor/README.md b/crates/sbv2_editor/README.md new file mode 100644 index 0000000..d9b4b1f --- /dev/null +++ b/crates/sbv2_editor/README.md @@ -0,0 +1,2 @@ +# sbv2-voicevox +sbv2-apiをvoicevox化します。 \ No newline at end of file diff --git a/crates/sbv2_editor/query2.json b/crates/sbv2_editor/query2.json new file mode 100644 index 0000000..6cffac4 --- /dev/null +++ b/crates/sbv2_editor/query2.json @@ -0,0 +1,226 @@ +{ + "accent_phrases": [ + { + "moras": [ + { + "text": "コ", + "consonant": "k", + "consonant_length": 0.10002632439136505, + "vowel": "o", + "vowel_length": 0.15740256011486053, + "pitch": 5.749961853027344 + }, + { + "text": "ン", + "consonant": null, + "consonant_length": null, + "vowel": "N", + "vowel_length": 0.08265873789787292, + "pitch": 5.89122200012207 + }, + { + "text": "ニ", + "consonant": "n", + "consonant_length": 0.03657080978155136, + "vowel": "i", + "vowel_length": 0.1175866425037384, + "pitch": 5.969866752624512 + }, + { + "text": "チ", + "consonant": "ch", + "consonant_length": 0.09005842357873917, + "vowel": "i", + "vowel_length": 0.08666137605905533, + "pitch": 5.958892822265625 + }, + { + "text": "ワ", + "consonant": "w", + "consonant_length": 0.07833231985569, + "vowel": "a", + "vowel_length": 0.21250136196613312, + "pitch": 5.949411392211914 + } + ], + "accent": 5, + "pause_mora": { + "text": "、", + "consonant": null, + "consonant_length": null, + "vowel": "pau", + "vowel_length": 0.4723339378833771, + "pitch": 0.0 + }, + "is_interrogative": false + }, + { + "moras": [ + { + "text": "オ", + "consonant": null, + "consonant_length": null, + "vowel": "o", + "vowel_length": 0.22004225850105286, + "pitch": 5.6870927810668945 + }, + { + "text": "ン", + "consonant": null, + "consonant_length": null, + "vowel": "N", + "vowel_length": 0.09161105751991272, + "pitch": 5.93472957611084 + }, + { + "text": "セ", + "consonant": "s", + "consonant_length": 0.08924821764230728, + "vowel": "e", + "vowel_length": 0.14142127335071564, + "pitch": 6.121850490570068 + }, + { + "text": "エ", + "consonant": null, + "consonant_length": null, + "vowel": "e", + "vowel_length": 0.10636933892965317, + "pitch": 6.157896041870117 + }, + { + "text": "ゴ", + "consonant": "g", + "consonant_length": 0.07600915431976318, + "vowel": "o", + "vowel_length": 0.09598273783922195, + "pitch": 6.188933849334717 + }, + { + "text": "オ", + "consonant": null, + "consonant_length": null, + "vowel": "o", + "vowel_length": 0.1079121008515358, + "pitch": 6.235202789306641 + }, + { + "text": "セ", + "consonant": "s", + "consonant_length": 0.09591838717460632, + "vowel": "e", + "vowel_length": 0.10286372154951096, + "pitch": 6.153214454650879 + }, + { + "text": "エ", + "consonant": null, + "consonant_length": null, + "vowel": "e", + "vowel_length": 0.08992656320333481, + "pitch": 6.02571439743042 + }, + { + "text": "ノ", + "consonant": "n", + "consonant_length": 0.05660202354192734, + "vowel": "o", + "vowel_length": 0.09676017612218857, + "pitch": 5.711844444274902 + } + ], + "accent": 5, + "pause_mora": null, + "is_interrogative": false + }, + { + "moras": [ + { + "text": "セ", + "consonant": "s", + "consonant_length": 0.07805486768484116, + "vowel": "e", + "vowel_length": 0.09617523103952408, + "pitch": 5.774399280548096 + }, + { + "text": "カ", + "consonant": "k", + "consonant_length": 0.06712044775485992, + "vowel": "a", + "vowel_length": 0.148829385638237, + "pitch": 6.063965797424316 + }, + { + "text": "イ", + "consonant": null, + "consonant_length": null, + "vowel": "i", + "vowel_length": 0.11061104387044907, + "pitch": 6.040698051452637 + }, + { + "text": "エ", + "consonant": null, + "consonant_length": null, + "vowel": "e", + "vowel_length": 0.13046696782112122, + "pitch": 5.806027889251709 + } + ], + "accent": 1, + "pause_mora": null, + "is_interrogative": false + }, + { + "moras": [ + { + "text": "ヨ", + "consonant": "y", + "consonant_length": 0.07194744795560837, + "vowel": "o", + "vowel_length": 0.08622600883245468, + "pitch": 5.694094657897949 + }, + { + "text": "オ", + "consonant": null, + "consonant_length": null, + "vowel": "o", + "vowel_length": 0.10635452717542648, + "pitch": 5.787222385406494 + }, + { + "text": "コ", + "consonant": "k", + "consonant_length": 0.07077334076166153, + "vowel": "o", + "vowel_length": 0.09248624742031097, + "pitch": 5.793357849121094 + }, + { + "text": "ソ", + "consonant": "s", + "consonant_length": 0.08705667406320572, + "vowel": "o", + "vowel_length": 0.2238258570432663, + "pitch": 5.643765449523926 + } + ], + "accent": 1, + "pause_mora": null, + "is_interrogative": false + } + ], + "speedScale": 1.0, + "pitchScale": 0.0, + "intonationScale": 1.0, + "volumeScale": 1.0, + "prePhonemeLength": 0.1, + "postPhonemeLength": 0.1, + "pauseLength": null, + "pauseLengthScale": 1.0, + "outputSamplingRate": 24000, + "outputStereo": false, + "kana": "コンニチワ'、オンセエゴ'オセエノ/セ'カイエ/ヨ'オコソ" +} \ No newline at end of file diff --git a/crates/sbv2_editor/src/error.rs b/crates/sbv2_editor/src/error.rs new file mode 100644 index 0000000..d3cf600 --- /dev/null +++ b/crates/sbv2_editor/src/error.rs @@ -0,0 +1,27 @@ +use axum::{ + http::StatusCode, + response::{IntoResponse, Response}, +}; + +pub type AppResult = std::result::Result; + +pub struct AppError(anyhow::Error); + +impl IntoResponse for AppError { + fn into_response(self) -> Response { + ( + StatusCode::INTERNAL_SERVER_ERROR, + format!("Something went wrong: {}", self.0), + ) + .into_response() + } +} + +impl From for AppError +where + E: Into, +{ + fn from(err: E) -> Self { + Self(err.into()) + } +} diff --git a/crates/sbv2_editor/src/main.rs b/crates/sbv2_editor/src/main.rs new file mode 100644 index 0000000..fb596d5 --- /dev/null +++ b/crates/sbv2_editor/src/main.rs @@ -0,0 +1,197 @@ +use axum::extract::State; +use axum::{ + extract::Query, + http::header::CONTENT_TYPE, + response::IntoResponse, + routing::{get, post}, + Json, Router, +}; +use sbv2_core::tts_util::kata_tone2phone_tone; +use sbv2_core::{ + tts::{SynthesizeOptions, TTSModelHolder}, + tts_util::preprocess_parse_text, +}; +use serde::{Deserialize, Serialize}; +use tokio::{fs, net::TcpListener, sync::Mutex}; + +use std::env; +use std::sync::Arc; + +use error::AppResult; + +mod error; + +#[derive(Deserialize)] +struct RequestCreateAudioQuery { + text: String, +} + +#[derive(Serialize, Deserialize)] +struct AudioQuery { + kana: String, + tone: i32, +} + +#[derive(Serialize)] +struct ResponseCreateAudioQuery { + audio_query: Vec, + text: String, +} + +async fn create_audio_query( + State(state): State, + Query(request): Query, +) -> AppResult { + let (text, process) = { + let tts_model = state.tts_model.lock().await; + preprocess_parse_text(&request.text, &tts_model.jtalk)? + }; + let kana_tone_list = process.g2kana_tone()?; + let audio_query = kana_tone_list + .iter() + .map(|(kana, tone)| AudioQuery { + kana: kana.clone(), + tone: *tone, + }) + .collect::>(); + Ok(Json(ResponseCreateAudioQuery { audio_query, text })) +} + +#[derive(Deserialize)] +pub struct RequestSynthesis { + text: String, + speaker_id: i64, + sdp_ratio: f32, + length_scale: f32, + style_id: i32, + audio_query: Vec, + ident: String, +} + +async fn synthesis( + State(state): State, + Json(request): Json, +) -> AppResult { + let phone_tone = request + .audio_query + .iter() + .map(|query| (query.kana.clone(), query.tone)) + .collect::>(); + let phone_tone = kata_tone2phone_tone(phone_tone); + let tones = phone_tone.iter().map(|(_, tone)| *tone).collect::>(); + let buffer = { + let mut tts_model = state.tts_model.lock().await; + tts_model.easy_synthesize_neo( + &request.ident, + &request.text, + Some(tones), + request.style_id, + request.speaker_id, + SynthesizeOptions { + sdp_ratio: request.sdp_ratio, + length_scale: request.length_scale, + ..Default::default() + }, + )? + }; + Ok(([(CONTENT_TYPE, "audio/wav")], buffer)) +} + +#[derive(Clone)] +struct AppState { + tts_model: Arc>, +} + +impl AppState { + pub async fn new() -> anyhow::Result { + let mut tts_model = TTSModelHolder::new( + &fs::read(env::var("BERT_MODEL_PATH")?).await?, + &fs::read(env::var("TOKENIZER_PATH")?).await?, + env::var("HOLDER_MAX_LOADED_MODElS") + .ok() + .and_then(|x| x.parse().ok()), + )?; + let models = env::var("MODELS_PATH").unwrap_or("models".to_string()); + let mut f = fs::read_dir(&models).await?; + let mut entries = vec![]; + while let Ok(Some(e)) = f.next_entry().await { + let name = e.file_name().to_string_lossy().to_string(); + if name.ends_with(".onnx") && name.starts_with("model_") { + let name_len = name.len(); + let name = name.chars(); + entries.push( + name.collect::>()[6..name_len - 5] + .iter() + .collect::(), + ); + } else if name.ends_with(".sbv2") { + let entry = &name[..name.len() - 5]; + log::info!("Try loading: {entry}"); + let sbv2_bytes = match fs::read(format!("{models}/{entry}.sbv2")).await { + Ok(b) => b, + Err(e) => { + log::warn!("Error loading sbv2_bytes from file {entry}: {e}"); + continue; + } + }; + if let Err(e) = tts_model.load_sbv2file(entry, sbv2_bytes) { + log::warn!("Error loading {entry}: {e}"); + }; + log::info!("Loaded: {entry}"); + } else if name.ends_with(".aivmx") { + let entry = &name[..name.len() - 6]; + log::info!("Try loading: {entry}"); + let aivmx_bytes = match fs::read(format!("{models}/{entry}.aivmx")).await { + Ok(b) => b, + Err(e) => { + log::warn!("Error loading aivmx bytes from file {entry}: {e}"); + continue; + } + }; + if let Err(e) = tts_model.load_aivmx(entry, aivmx_bytes) { + log::error!("Error loading {entry}: {e}"); + } + log::info!("Loaded: {entry}"); + } + } + for entry in entries { + log::info!("Try loading: {entry}"); + let style_vectors_bytes = + match fs::read(format!("{models}/style_vectors_{entry}.json")).await { + Ok(b) => b, + Err(e) => { + log::warn!("Error loading style_vectors_bytes from file {entry}: {e}"); + continue; + } + }; + let vits2_bytes = match fs::read(format!("{models}/model_{entry}.onnx")).await { + Ok(b) => b, + Err(e) => { + log::warn!("Error loading vits2_bytes from file {entry}: {e}"); + continue; + } + }; + if let Err(e) = tts_model.load(&entry, style_vectors_bytes, vits2_bytes) { + log::warn!("Error loading {entry}: {e}"); + }; + log::info!("Loaded: {entry}"); + } + Ok(Self { + tts_model: Arc::new(Mutex::new(tts_model)), + }) + } +} + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + dotenvy::dotenv_override().ok(); + env_logger::init(); + let app = Router::new() + .route("/", get(|| async { "Hello, world!" })) + .route("/audio_query", get(create_audio_query)) + .route("/synthesis", post(synthesis)) + .with_state(AppState::new().await?); + let listener = TcpListener::bind("0.0.0.0:8080").await?; + axum::serve(listener, app).await?; + Ok(()) +} diff --git a/test.py b/test.py new file mode 100644 index 0000000..4b97abf --- /dev/null +++ b/test.py @@ -0,0 +1,19 @@ +import requests + + +data = (requests.get("http://localhost:8080/audio_query", params={ + "text": "こんにちは、今日はいい天気ですね。", +})).json() +print(data) + +data = (requests.post("http://localhost:8080/synthesis", json={ + "text": data["text"], + "ident": "tsukuyomi", + "speaker_id": 0, + "style_id": 0, + "sdp_ratio": 0.5, + "length_scale": 0.5, + "audio_query": data["audio_query"], +})).content +with open("test.wav", "wb") as f: + f.write(data) \ No newline at end of file