新クラス設計API

Cargo.toml

@@ -24,6 +24,9 @@ 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" }
+reqwest = { version = "0.11.13", default-features = false, features = ["rustls-tls", "stream"] }
+tokio = {version="1.25.0",features=["rt","rt-multi-thread","macros","sync"]}
+derive-getters = "0.2.0"
 
 # min-sized-rustを元にrelease buildのサイズが小さくなるようにした
 # https://github.com/johnthagen/min-sized-rust

crates/download/Cargo.toml

@@ -19,9 +19,9 @@ octocrab = { git = "https://github.com/XAMPPRocky/octocrab.git", rev = "7db3611f
 once_cell.workspace = true
 platforms = "3.0.2"
 rayon = "1.6.1"
-reqwest = { version = "0.11.13", default-features = false, features = ["rustls-tls", "stream"] }
+reqwest.workspace=true
 strum = { version = "0.24.1", features = ["derive"] }
-tokio = { version = "1.24.1", features = ["macros", "rt-multi-thread", "sync"] }
+tokio.workspace=true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 url = "2.3.0"

crates/voicevox_core/Cargo.toml

@@ -12,7 +12,7 @@ directml = ["onnxruntime/directml"]
 [dependencies]
 anyhow.workspace = true
 cfg-if = "1.0.0"
-derive-getters = "0.2.0"
+derive-getters.workspace = true
 derive-new = "0.5.9"
 easy-ext.workspace = true
 fs-err.workspace = true
@@ -25,15 +25,18 @@ thiserror.workspace = true
 tracing.workspace = true
 open_jtalk = { git = "https://github.com/VOICEVOX/open_jtalk-rs.git", rev="9edab53f0bfa877dbb37224d17fd0f3efbe32abd" }
 regex = "1.6.0"
+async_zip = { version ="0.0.11",features=["full"]}
+futures = "0.3.26"
+nanoid = "0.4.0"
+tokio.workspace = true 
 
 [dev-dependencies]
 rstest = "0.15.0"
 pretty_assertions = "1.3.0"
-async-std = { version = "1.12.0", features = ["attributes"] }
-surf = "2.3.2"
 flate2 = "1.0.24"
 tar = "0.4.38"
 heck = "0.4.0"
+reqwest.workspace=true
 
 [target."cfg(windows)".dependencies]
 humansize = "2.1.2"

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 get_supported_devices() -> 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_get_supported_devices_works() {
+        let result = SupportedDevices::get_supported_devices();
+        // 環境によって結果が変わるので、関数呼び出しが成功するかどうかの確認のみ行う
+        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")]
@@ -47,55 +52,69 @@ impl PartialEq for OpenJtalkError {
 pub type Result<T> = std::result::Result<T, OpenJtalkError>;
 
 pub struct OpenJtalk {
-    mecab: ManagedResource<Mecab>,
-    njd: ManagedResource<Njd>,
-    jpcommon: ManagedResource<JpCommon>,
+    mecab: Mutex<ManagedResource<Mecab>>,
+    njd: Mutex<ManagedResource<Njd>>,
+    jpcommon: Mutex<ManagedResource<JpCommon>>,
     dict_loaded: bool,
 }
 
+#[allow(unsafe_code)]
+unsafe impl Send for OpenJtalk {}
+
+#[allow(unsafe_code)]
+unsafe impl Sync for OpenJtalk {}
+
 impl OpenJtalk {
-    pub fn initialize() -> Self {
+    pub fn new_without_dic() -> Self {
         Self {
-            mecab: ManagedResource::initialize(),
-            njd: ManagedResource::initialize(),
-            jpcommon: ManagedResource::initialize(),
+            mecab: Mutex::new(ManagedResource::initialize()),
+            njd: Mutex::new(ManagedResource::initialize()),
+            jpcommon: Mutex::new(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 mut jpcommon = self.jpcommon.lock().unwrap();
+        let mut njd = self.njd.lock().unwrap();
+        let mut mecab = self.mecab.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(),
@@ -110,15 +129,19 @@ 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
+            .mecab
+            .lock()
+            .unwrap()
+            .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(),
             })
         }
     }
@@ -225,28 +248,26 @@ mod tests {
     #[rstest]
     #[case("",Err(OpenJtalkError::ExtractFullContext{text:"".into(),source:None}))]
     #[case("こんにちは、ヒホです。", Ok(testdata_hello_hiho()))]
-    #[async_std::test]
+    #[tokio::test]
     async fn extract_fullcontext_works(
         #[case] text: &str,
         #[case] expected: super::Result<Vec<String>>,
     ) {
         let open_jtalk_dic_dir = download_open_jtalk_dict_if_no_exists().await;
-        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_eq!(expected, result);
     }
 
     #[rstest]
     #[case("こんにちは、ヒホです。", Ok(testdata_hello_hiho()))]
-    #[async_std::test]
+    #[tokio::test]
     async fn extract_fullcontext_loop_works(
         #[case] text: &str,
         #[case] expected: super::Result<Vec<String>>,
     ) {
         let open_jtalk_dic_dir = download_open_jtalk_dict_if_no_exists().await;
-        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_eq!(expected, result);