StyleMeta::r#typeを追加し、トークという区分を実装に導入する

crates/voicevox_core/Cargo.toml

@@ -32,9 +32,10 @@ open_jtalk.workspace = true
 ouroboros.workspace = true
 rayon.workspace = true
 regex.workspace = true
-serde = { workspace = true, features = ["derive"] }
+serde = { workspace = true, features = ["derive", "rc"] }
 serde_json = { workspace = true, features = ["preserve_order"] }
 smallvec.workspace = true
+strum = { workspace = true, features = ["derive"] }
 tempfile.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["rt"] } # FIXME: feature-gateする

crates/voicevox_core/src/error.rs

@@ -1,11 +1,12 @@
 use crate::{
     engine::{FullContextLabelError, KanaParseError},
     user_dict::InvalidWordError,
-    StyleId, VoiceModelId,
+    StyleId, StyleType, VoiceModelId,
 };
 //use engine::
 use duplicate::duplicate_item;
-use std::path::PathBuf;
+use itertools::Itertools as _;
+use std::{collections::BTreeSet, path::PathBuf};
 use thiserror::Error;
 use uuid::Uuid;
 
@@ -38,6 +39,7 @@ impl Error {
                 LoadModelErrorKind::ReadZipEntry { .. } => ErrorKind::ReadZipEntry,
                 LoadModelErrorKind::ModelAlreadyLoaded { .. } => ErrorKind::ModelAlreadyLoaded,
                 LoadModelErrorKind::StyleAlreadyLoaded { .. } => ErrorKind::StyleAlreadyLoaded,
+                LoadModelErrorKind::MissingModelData { .. } => ErrorKind::MissingModelData,
                 LoadModelErrorKind::InvalidModelData => ErrorKind::InvalidModelData,
             },
             ErrorRepr::GetSupportedDevices(_) => ErrorKind::GetSupportedDevices,
@@ -70,10 +72,14 @@ pub(crate) enum ErrorRepr {
     GetSupportedDevices(#[source] anyhow::Error),
 
     #[error(
-        "`{style_id}`に対するスタイルが見つかりませんでした。音声モデルが読み込まれていないか、読\
-         み込みが解除されています"
+        "`{style_id}` ([{style_types}])に対するスタイルが見つかりませんでした。音声モデルが\
+         読み込まれていないか、読み込みが解除されています",
+        style_types = style_types.iter().format(", ")
     )]
-    StyleNotFound { style_id: StyleId },
+    StyleNotFound {
+        style_id: StyleId,
+        style_types: &'static BTreeSet<StyleType>,
+    },
 
     #[error(
         "`{model_id}`に対する音声モデルが見つかりませんでした。読み込まれていないか、読み込みが既\
@@ -121,6 +127,8 @@ pub enum ErrorKind {
     ModelAlreadyLoaded,
     /// すでに読み込まれているスタイルを読み込もうとした。
     StyleAlreadyLoaded,
+    /// モデルデータが見つからなかった。
+    MissingModelData,
     /// 無効なモデルデータ。
     InvalidModelData,
     /// サポートされているデバイス情報取得に失敗した。
@@ -169,6 +177,8 @@ pub(crate) enum LoadModelErrorKind {
     ModelAlreadyLoaded { id: VoiceModelId },
     #[display(fmt = "スタイル`{id}`は既に読み込まれています")]
     StyleAlreadyLoaded { id: StyleId },
+    #[display(fmt = "`{style_type}`に対応するモデルデータがありませんでした")]
+    MissingModelData { style_type: StyleType },
     #[display(fmt = "モデルデータを読むことができませんでした")]
     InvalidModelData,
 }

crates/voicevox_core/src/infer.rs

@@ -1,17 +1,17 @@
-pub(crate) mod domain;
+pub(crate) mod domains;
 mod model_file;
 pub(crate) mod runtimes;
-pub(crate) mod status;
+pub(crate) mod session_set;
 
-use std::{borrow::Cow, fmt::Debug};
+use std::{borrow::Cow, collections::BTreeSet, fmt::Debug};
 
 use derive_new::new;
 use duplicate::duplicate_item;
 use enum_map::{Enum, EnumMap};
 use ndarray::{Array, ArrayD, Dimension, ShapeError};
 use thiserror::Error;
 
-use crate::SupportedDevices;
+use crate::{StyleType, SupportedDevices};
 
 pub(crate) trait InferenceRuntime: 'static {
     type Session: Sized + Send + 'static;
@@ -32,9 +32,17 @@ pub(crate) trait InferenceRuntime: 'static {
     fn run(ctx: Self::RunContext<'_>) -> anyhow::Result<Vec<OutputTensor>>;
 }
 
-/// ある`VoiceModel`が提供する推論操作の集合を示す。
-pub(crate) trait InferenceDomain {
+/// 共に扱われるべき推論操作の集合を示す。
+pub(crate) trait InferenceDomain: Sized {
     type Operation: InferenceOperation;
+
+    /// 対応する`StyleType`。
+    ///
+    /// 複数の`InferenceDomain`に対応する`StyleType`があってもよい。
+    ///
+    /// また、どの`InferenceDomain`にも属さない`StyleType`があってもよい。そのような`StyleType`は
+    /// 音声モデルのロード時に単に拒否されるべきである。
+    fn style_types() -> &'static BTreeSet<StyleType>;
 }
 
 /// `InferenceDomain`の推論操作を表す列挙型。

crates/voicevox_core/src/infer/domains.rs

@@ -0,0 +1,22 @@
+mod talk;
+
+pub(crate) use self::talk::{
+    DecodeInput, DecodeOutput, PredictDurationInput, PredictDurationOutput, PredictIntonationInput,
+    PredictIntonationOutput, TalkDomain, TalkOperation,
+};
+
+pub(crate) struct InferenceDomainMap<V: InferenceDomainMapValues + ?Sized> {
+    pub(crate) talk: V::Talk,
+}
+
+pub(crate) trait InferenceDomainMapValues {
+    type Talk;
+}
+
+impl<T> InferenceDomainMapValues for (T,) {
+    type Talk = T;
+}
+
+impl<A> InferenceDomainMapValues for [A] {
+    type Talk = A;
+}

crates/voicevox_core/src/infer/domain.rs → crates/voicevox_core/src/infer/domains/talk.rs

@@ -1,22 +1,32 @@
+use std::collections::BTreeSet;
+
 use enum_map::Enum;
 use macros::{InferenceInputSignature, InferenceOperation, InferenceOutputSignature};
 use ndarray::{Array0, Array1, Array2};
+use once_cell::sync::Lazy;
+
+use crate::StyleType;
 
-use super::{
+use super::super::{
     InferenceDomain, InferenceInputSignature as _, InferenceOutputSignature as _, OutputTensor,
 };
 
-pub(crate) enum InferenceDomainImpl {}
+pub(crate) enum TalkDomain {}
+
+impl InferenceDomain for TalkDomain {
+    type Operation = TalkOperation;
 
-impl InferenceDomain for InferenceDomainImpl {
-    type Operation = InferenceOperationImpl;
+    fn style_types() -> &'static BTreeSet<StyleType> {
+        static STYLE_TYPES: Lazy<BTreeSet<StyleType>> = Lazy::new(|| [StyleType::Talk].into());
+        &STYLE_TYPES
+    }
 }
 
 #[derive(Clone, Copy, Enum, InferenceOperation)]
 #[inference_operation(
-    type Domain = InferenceDomainImpl;
+    type Domain = TalkDomain;
 )]
-pub(crate) enum InferenceOperationImpl {
+pub(crate) enum TalkOperation {
     #[inference_operation(
         type Input = PredictDurationInput;
         type Output = PredictDurationOutput;

crates/voicevox_core/src/infer/session_set.rs

@@ -0,0 +1,102 @@
+use std::{collections::HashMap, fmt::Display, marker::PhantomData, sync::Arc};
+
+use anyhow::bail;
+use enum_map::{Enum as _, EnumMap};
+use itertools::Itertools as _;
+
+use crate::error::ErrorRepr;
+
+use super::{
+    model_file, InferenceDomain, InferenceInputSignature, InferenceOperation, InferenceRuntime,
+    InferenceSessionOptions, InferenceSignature, ParamInfo,
+};
+
+pub(crate) struct SessionSet<R: InferenceRuntime, D: InferenceDomain>(
+    EnumMap<D::Operation, Arc<std::sync::Mutex<R::Session>>>,
+);
+
+impl<R: InferenceRuntime, D: InferenceDomain> SessionSet<R, D> {
+    pub(crate) fn new(
+        model_bytes: &EnumMap<D::Operation, Vec<u8>>,
+        options: &EnumMap<D::Operation, InferenceSessionOptions>,
+    ) -> anyhow::Result<Self> {
+        let mut sessions = model_bytes
+            .iter()
+            .map(|(op, model_bytes)| {
+                let (expected_input_param_infos, expected_output_param_infos) =
+                    <D::Operation as InferenceOperation>::PARAM_INFOS[op];
+
+                let (sess, actual_input_param_infos, actual_output_param_infos) =
+                    R::new_session(|| model_file::decrypt(model_bytes), options[op])?;
+
+                check_param_infos(expected_input_param_infos, &actual_input_param_infos)?;
+                check_param_infos(expected_output_param_infos, &actual_output_param_infos)?;
+
+                Ok((op.into_usize(), std::sync::Mutex::new(sess).into()))
+            })
+            .collect::<anyhow::Result<HashMap<_, _>>>()?;
+
+        return Ok(Self(EnumMap::<D::Operation, _>::from_fn(|k| {
+            sessions.remove(&k.into_usize()).expect("should exist")
+        })));
+
+        fn check_param_infos<D: PartialEq + Display>(
+            expected: &[ParamInfo<D>],
+            actual: &[ParamInfo<D>],
+        ) -> anyhow::Result<()> {
+            if !(expected.len() == actual.len()
+                && itertools::zip_eq(expected, actual)
+                    .all(|(expected, actual)| expected.accepts(actual)))
+            {
+                let expected = display_param_infos(expected);
+                let actual = display_param_infos(actual);
+                bail!("expected {{{expected}}}, got {{{actual}}}")
+            }
+            Ok(())
+        }
+
+        fn display_param_infos(infos: &[ParamInfo<impl Display>]) -> impl Display {
+            infos
+                .iter()
+                .map(|ParamInfo { name, dt, ndim }| {
+                    let brackets = match *ndim {
+                        Some(ndim) => "[]".repeat(ndim),
+                        None => "[]...".to_owned(),
+                    };
+                    format!("{name}: {dt}{brackets}")
+                })
+                .join(", ")
+        }
+    }
+}
+
+impl<R: InferenceRuntime, D: InferenceDomain> SessionSet<R, D> {
+    pub(crate) fn get<I>(&self) -> SessionCell<R, I>
+    where
+        I: InferenceInputSignature,
+        I::Signature: InferenceSignature<Domain = D>,
+    {
+        SessionCell {
+            inner: self.0[I::Signature::OPERATION].clone(),
+            marker: PhantomData,
+        }
+    }
+}
+
+pub(crate) struct SessionCell<R: InferenceRuntime, I> {
+    inner: Arc<std::sync::Mutex<R::Session>>,
+    marker: PhantomData<fn(I)>,
+}
+
+impl<R: InferenceRuntime, I: InferenceInputSignature> SessionCell<R, I> {
+    pub(crate) fn run(
+        self,
+        input: I,
+    ) -> crate::Result<<I::Signature as InferenceSignature>::Output> {
+        let inner = &mut self.inner.lock().unwrap();
+        let ctx = input.make_run_context::<R>(inner);
+        R::run(ctx)
+            .and_then(TryInto::try_into)
+            .map_err(|e| ErrorRepr::InferenceFailed(e).into())
+    }
+}