project-vvm-async-api

Cargo.toml

@@ -10,18 +10,23 @@ members = [
 
 [workspace.dependencies]
 anyhow = "1.0.65"
+async_zip = { version = "0.0.11", features = ["full"] }
 clap = { version = "4.0.10", features = ["derive"] }
+const-default = { version = "1.0.0", features = ["derive"] }
 easy-ext = "1.0.1"
 fs-err = { version = "2.9.0", features = ["tokio"] }
 once_cell = "1.15.0"
 regex = "1.6.0"
 serde = { version = "1.0.145", features = ["derive"] }
-serde_json = "1.0.85"
+serde_json = { version = "1.0.85", features = ["preserve_order"] }
+strum = { version = "0.24.1", features = ["derive"] }
 test_util = { path = "crates/test_util" }
 thiserror = "1.0.37"
 tracing = { version = "0.1.37", features = ["log"] }
 tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
 voicevox_core = { path = "crates/voicevox_core" }
+tokio = { version = "1.25.0", features = ["rt", "rt-multi-thread", "macros", "sync"] }
+derive-getters = "0.2.0"
 
 # FIXME: iOS対応のpull request(https://github.com/wesleywiser/process_path/pull/16)がマージされる見込みが無いため
 [workspace.dependencies.process_path]

crates/download/Cargo.toml

@@ -20,8 +20,8 @@ once_cell.workspace = true
 platforms = "3.0.2"
 rayon = "1.6.1"
 reqwest = { version = "0.11.13", default-features = false, features = ["rustls-tls", "stream"] }
-strum = { version = "0.24.1", features = ["derive"] }
-tokio = { version = "1.24.1", features = ["macros", "rt-multi-thread", "sync"] }
+strum.workspace = true
+tokio.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 url = "2.3.0"

crates/test_util/Cargo.toml

@@ -5,9 +5,11 @@ edition.workspace = true
 publish.workspace = true
 
 [dependencies]
+async_zip.workspace = true
+once_cell.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-once_cell.workspace = true
+tokio.workspace = true
 
 [build-dependencies]
 anyhow.workspace = true

crates/test_util/src/lib.rs

@@ -1,5 +1,16 @@
 mod typing;
+
+use async_zip::{write::ZipFileWriter, Compression, ZipEntryBuilder};
 use once_cell::sync::Lazy;
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+use tokio::{
+    fs::{self, File},
+    io::{AsyncReadExt, AsyncWriteExt},
+    sync::Mutex,
+};
 pub use typing::*;
 
 pub const OPEN_JTALK_DIC_DIR: &str = concat!(
@@ -15,3 +26,49 @@ pub const EXAMPLE_DATA_JSON: &str = include_str!(concat!(
 pub static EXAMPLE_DATA: Lazy<ExampleData> = Lazy::new(|| {
     serde_json::from_str(EXAMPLE_DATA_JSON).expect("failed to parse example_data.json")
 });
+
+static PATH_MUTEX: Lazy<Mutex<HashMap<PathBuf, Mutex<()>>>> =
+    Lazy::new(|| Mutex::new(HashMap::default()));
+
+pub async fn convert_zip_vvm(dir: impl AsRef<Path>) -> PathBuf {
+    let dir = dir.as_ref();
+    let output_file_name = dir.file_name().unwrap().to_str().unwrap().to_owned() + ".vvm";
+
+    let out_file_path = PathBuf::from(env!("OUT_DIR"))
+        .join("test_data/models/")
+        .join(output_file_name);
+    let mut path_map = PATH_MUTEX.lock().await;
+    if !path_map.contains_key(&out_file_path) {
+        path_map.insert(out_file_path.clone(), Mutex::new(()));
+    }
+    let _m = path_map.get(&out_file_path).unwrap().lock().await;
+
+    if !out_file_path.exists() {
+        fs::create_dir_all(out_file_path.parent().unwrap())
+            .await
+            .unwrap();
+        let mut out_file = File::create(&out_file_path).await.unwrap();
+        let mut writer = ZipFileWriter::new(&mut out_file);
+
+        for entry in dir.read_dir().unwrap().flatten() {
+            let entry_builder = ZipEntryBuilder::new(
+                entry
+                    .path()
+                    .file_name()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .to_string(),
+                Compression::Deflate,
+            );
+            let mut entry_writer = writer.write_entry_stream(entry_builder).await.unwrap();
+            let mut file = File::open(entry.path()).await.unwrap();
+            let mut buf = Vec::with_capacity(entry.metadata().unwrap().len() as usize);
+            file.read_to_end(&mut buf).await.unwrap();
+            entry_writer.write_all(&buf).await.unwrap();
+            entry_writer.close().await.unwrap();
+        }
+        writer.close().await.unwrap();
+    }
+    out_file_path
+}

crates/voicevox_core/Cargo.toml

@@ -10,17 +10,24 @@ directml = ["onnxruntime/directml"]
 
 [dependencies]
 anyhow.workspace = true
+async_zip.workspace = true
 cfg-if = "1.0.0"
-derive-getters = "0.2.0"
+const-default.workspace = true
+derive-getters.workspace = true
 derive-new = "0.5.9"
+duplicate = "1.0.0"
 easy-ext.workspace = true
 fs-err.workspace = true
+futures = "0.3.26"
+nanoid = "0.4.0"
 once_cell.workspace = true
 process_path.workspace = true
 regex.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+strum.workspace = true
 thiserror.workspace = true
+tokio.workspace = true
 tracing.workspace = true
 
 [dependencies.onnxruntime]
@@ -32,9 +39,11 @@ git = "https://github.com/VOICEVOX/open_jtalk-rs.git"
 rev = "d766a52bad4ccafe18597e57bd6842f59dca881e"
 
 [dev-dependencies]
+flate2 = "1.0.24"
 heck = "0.4.0"
 pretty_assertions = "1.3.0"
 rstest = "0.15.0"
+tar = "0.4.38"
 test_util.workspace = true
 
 [target."cfg(windows)".dependencies]

crates/voicevox_core/src/devices.rs

@@ -0,0 +1,49 @@
+use serde::{Deserialize, Serialize};
+
+use super::*;
+
+#[derive(Getters, Debug, Serialize, Deserialize)]
+pub struct SupportedDevices {
+    cpu: bool,
+    cuda: bool,
+    dml: bool,
+}
+
+impl SupportedDevices {
+    /// サポートされているデバイス情報を取得する
+    pub fn create() -> Result<Self> {
+        let mut cuda_support = false;
+        let mut dml_support = false;
+        for provider in onnxruntime::session::get_available_providers()
+            .map_err(|e| Error::GetSupportedDevices(e.into()))?
+            .iter()
+        {
+            match provider.as_str() {
+                "CUDAExecutionProvider" => cuda_support = true,
+                "DmlExecutionProvider" => dml_support = true,
+                _ => {}
+            }
+        }
+
+        Ok(SupportedDevices {
+            cpu: true,
+            cuda: cuda_support,
+            dml: dml_support,
+        })
+    }
+
+    pub fn to_json(&self) -> serde_json::Value {
+        serde_json::to_value(self).expect("should not fail")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[rstest]
+    fn supported_devices_create_works() {
+        let result = SupportedDevices::create();
+        // 環境によって結果が変わるので、関数呼び出しが成功するかどうかの確認のみ行う
+        assert!(result.is_ok(), "{result:?}");
+    }
+}

crates/voicevox_core/src/engine/full_context_label.rs

@@ -306,7 +306,7 @@ impl Utterance {
     }
 
     pub fn extract_full_context_label(
-        open_jtalk: &mut open_jtalk::OpenJtalk,
+        open_jtalk: &open_jtalk::OpenJtalk,
         text: impl AsRef<str>,
     ) -> Result<Self> {
         let labels = open_jtalk.extract_fullcontext(text)?;

crates/voicevox_core/src/engine/open_jtalk.rs

@@ -1,7 +1,12 @@
-use std::path::{Path, PathBuf};
+use std::{
+    path::{Path, PathBuf},
+    sync::Mutex,
+};
 
 use ::open_jtalk::*;
 
+use crate::Error;
+
 #[derive(thiserror::Error, Debug)]
 pub enum OpenJtalkError {
     #[error("open_jtalk load error")]
@@ -17,55 +22,74 @@ pub enum OpenJtalkError {
 pub type Result<T> = std::result::Result<T, OpenJtalkError>;
 
 pub struct OpenJtalk {
+    resources: Mutex<Resources>,
+    dict_loaded: bool,
+}
+
+struct Resources {
     mecab: ManagedResource<Mecab>,
     njd: ManagedResource<Njd>,
     jpcommon: ManagedResource<JpCommon>,
-    dict_loaded: bool,
 }
 
+#[allow(unsafe_code)]
+unsafe impl Send for Resources {}
+
 impl OpenJtalk {
-    pub fn initialize() -> Self {
+    pub fn new_without_dic() -> Self {
         Self {
-            mecab: ManagedResource::initialize(),
-            njd: ManagedResource::initialize(),
-            jpcommon: ManagedResource::initialize(),
+            resources: Mutex::new(Resources {
+                mecab: ManagedResource::initialize(),
+                njd: ManagedResource::initialize(),
+                jpcommon: ManagedResource::initialize(),
+            }),
             dict_loaded: false,
         }
     }
-
-    pub fn extract_fullcontext(&mut self, text: impl AsRef<str>) -> Result<Vec<String>> {
-        let result = self.extract_fullcontext_non_reflesh(text);
-        self.jpcommon.refresh();
-        self.njd.refresh();
-        self.mecab.refresh();
-        result
+    pub fn new_with_initialize(
+        open_jtalk_dict_dir: impl AsRef<Path>,
+    ) -> crate::result::Result<Self> {
+        let mut s = Self::new_without_dic();
+        s.load(open_jtalk_dict_dir)
+            .map_err(|_| Error::NotLoadedOpenjtalkDict)?;
+        Ok(s)
     }
 
-    fn extract_fullcontext_non_reflesh(&mut self, text: impl AsRef<str>) -> Result<Vec<String>> {
+    pub fn extract_fullcontext(&self, text: impl AsRef<str>) -> Result<Vec<String>> {
+        let Resources {
+            mecab,
+            njd,
+            jpcommon,
+        } = &mut *self.resources.lock().unwrap();
+
+        jpcommon.refresh();
+        njd.refresh();
+        mecab.refresh();
+
         let mecab_text =
             text2mecab(text.as_ref()).map_err(|e| OpenJtalkError::ExtractFullContext {
                 text: text.as_ref().into(),
                 source: Some(e.into()),
             })?;
-        if self.mecab.analysis(mecab_text) {
-            self.njd.mecab2njd(
-                self.mecab
+        if mecab.analysis(mecab_text) {
+            njd.mecab2njd(
+                mecab
                     .get_feature()
                     .ok_or(OpenJtalkError::ExtractFullContext {
                         text: text.as_ref().into(),
                         source: None,
                     })?,
-                self.mecab.get_size(),
+                mecab.get_size(),
             );
-            self.njd.set_pronunciation();
-            self.njd.set_digit();
-            self.njd.set_accent_phrase();
-            self.njd.set_accent_type();
-            self.njd.set_unvoiced_vowel();
-            self.njd.set_long_vowel();
-            self.jpcommon.njd2jpcommon(&self.njd);
-            self.jpcommon.make_label();
-            self.jpcommon
+            njd.set_pronunciation();
+            njd.set_digit();
+            njd.set_accent_phrase();
+            njd.set_accent_type();
+            njd.set_unvoiced_vowel();
+            njd.set_long_vowel();
+            jpcommon.njd2jpcommon(njd);
+            jpcommon.make_label();
+            jpcommon
                 .get_label_feature_to_iter()
                 .ok_or_else(|| OpenJtalkError::ExtractFullContext {
                     text: text.as_ref().into(),
@@ -80,15 +104,20 @@ impl OpenJtalk {
         }
     }
 
-    pub fn load(&mut self, mecab_dict_dir: impl AsRef<Path>) -> Result<()> {
-        let result = self.mecab.load(mecab_dict_dir.as_ref());
+    fn load(&mut self, open_jtalk_dict_dir: impl AsRef<Path>) -> Result<()> {
+        let result = self
+            .resources
+            .lock()
+            .unwrap()
+            .mecab
+            .load(open_jtalk_dict_dir.as_ref());
         if result {
             self.dict_loaded = true;
             Ok(())
         } else {
             self.dict_loaded = false;
             Err(OpenJtalkError::Load {
-                mecab_dict_dir: mecab_dict_dir.as_ref().into(),
+                mecab_dict_dir: open_jtalk_dict_dir.as_ref().into(),
             })
         }
     }
@@ -101,7 +130,7 @@ impl OpenJtalk {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use test_util::OPEN_JTALK_DIC_DIR;
+    use ::test_util::OPEN_JTALK_DIC_DIR;
 
     use crate::{macros::tests::assert_debug_fmt_eq, *};
 
@@ -196,8 +225,7 @@ mod tests {
     #[case("",Err(OpenJtalkError::ExtractFullContext{text:"".into(),source:None}))]
     #[case("こんにちは、ヒホです。", Ok(testdata_hello_hiho()))]
     fn extract_fullcontext_works(#[case] text: &str, #[case] expected: super::Result<Vec<String>>) {
-        let mut open_jtalk = OpenJtalk::initialize();
-        open_jtalk.load(OPEN_JTALK_DIC_DIR).unwrap();
+        let open_jtalk = OpenJtalk::new_with_initialize(OPEN_JTALK_DIC_DIR).unwrap();
         let result = open_jtalk.extract_fullcontext(text);
         assert_debug_fmt_eq!(expected, result);
     }
@@ -208,8 +236,7 @@ mod tests {
         #[case] text: &str,
         #[case] expected: super::Result<Vec<String>>,
     ) {
-        let mut open_jtalk = OpenJtalk::initialize();
-        open_jtalk.load(OPEN_JTALK_DIC_DIR).unwrap();
+        let open_jtalk = OpenJtalk::new_with_initialize(OPEN_JTALK_DIC_DIR).unwrap();
         for _ in 0..10 {
             let result = open_jtalk.extract_fullcontext(text);
             assert_debug_fmt_eq!(expected, result);