Add htsengine module

Author: r9y9

.gitignore

@@ -1,5 +1,6 @@
 pyopenjtalk/version.py
 pyopenjtalk/openjtalk.cpp
+pyopenjtalk/htsengine.cpp
 pyopenjtalk/open_jtalk_dic_utf_8-1.10/
 pyopenjtalk/open_jtalk_dic_utf_8-1.11/
 docs/generated

pyopenjtalk/htsengine.pyx

@@ -0,0 +1,97 @@
+# coding: utf-8
+# cython: boundscheck=True, wraparound=True
+# cython: c_string_type=unicode, c_string_encoding=ascii
+
+import numpy as np
+
+cimport numpy as np
+np.import_array()
+
+cimport cython
+from libc.stdlib cimport malloc, free
+
+from htsengine cimport HTS_Engine
+from htsengine cimport (
+    HTS_Engine_initialize, HTS_Engine_load, HTS_Engine_clear, HTS_Engine_refresh,
+    HTS_Engine_get_sampling_frequency, HTS_Engine_get_fperiod,
+    HTS_Engine_synthesize_from_strings,
+    HTS_Engine_get_generated_speech, HTS_Engine_get_nsamples
+)
+
+cdef class HTSEngine(object):
+    """HTSEngine
+    """
+    cdef HTS_Engine* engine
+
+    def __cinit__(self, voice=b"htsvoice/mei_normal.htsvoice"):
+        self.engine = new HTS_Engine()
+
+        HTS_Engine_initialize(self.engine)
+
+        if self.load(voice) != 1:
+          self.clear()
+          raise RuntimeError("Failed to initalize HTS_Engine")
+
+    def load(self, bytes voice):
+        cdef char* voices = voice
+        cdef char ret
+        ret = HTS_Engine_load(self.engine, &voices, 1)
+        return ret
+
+    def get_sampling_frequency(self):
+        """Get sampling frequency
+        """
+        return HTS_Engine_get_sampling_frequency(self.engine)
+
+    def get_fperiod(self):
+        """Get frame period"""
+        return HTS_Engine_get_fperiod(self.engine)
+
+    def synthesize(self, list labels):
+        """Synthesize waveform from list of full-context labels
+
+        Args:
+            labels: full context labels
+
+        Returns:
+            np.ndarray: speech waveform
+        """
+        self.synthesize_from_strings(labels)
+        x = self.get_generated_speech()
+        self.refresh()
+        return x
+
+    def synthesize_from_strings(self, list labels):
+        """Synthesize from strings"""
+        cdef size_t num_lines = len(labels)
+        cdef char **lines = <char**> malloc((num_lines + 1) * sizeof(char*))
+        for n in range(len(labels)):
+            lines[n] = <char*>labels[n]
+
+        cdef char ret = HTS_Engine_synthesize_from_strings(self.engine, lines, num_lines)
+        free(lines)
+        if ret != 1:
+            raise RuntimeError("Failed to run synthesize_from_strings")
+
+    def get_generated_speech(self):
+        """Get generated speech"""
+        cdef size_t nsamples = HTS_Engine_get_nsamples(self.engine)
+        cdef np.ndarray speech = np.zeros([nsamples], dtype=np.float64)
+        cdef size_t index
+        for index in range(nsamples):
+            speech[index] = HTS_Engine_get_generated_speech(self.engine, index)
+        return speech
+
+    def get_fullcontext_label_format(self):
+        """Get full-context label format"""
+        return (<bytes>HTS_Engine_get_fullcontext_label_format(self.engine)).decode("utf-8")
+
+    def refresh(self):
+        HTS_Engine_refresh(self.engine)
+
+    def clear(self):
+        HTS_Engine_clear(self.engine)
+
+    def __dealloc__(self):
+        self.clear()
+        del self.engine

pyopenjtalk/htsengine/__init__.pxd

@@ -0,0 +1,19 @@
+# distutils: language = c++
+
+
+cdef extern from "HTS_engine.h":
+    cdef cppclass _HTS_Engine:
+        pass
+    ctypedef _HTS_Engine HTS_Engine
+
+    void HTS_Engine_initialize(HTS_Engine * engine)
+    char HTS_Engine_load(HTS_Engine * engine, char **voices, size_t num_voices)
+    size_t HTS_Engine_get_sampling_frequency(HTS_Engine * engine)
+    size_t HTS_Engine_get_fperiod(HTS_Engine * engine)
+    void HTS_Engine_refresh(HTS_Engine * engine)
+    void HTS_Engine_clear(HTS_Engine * engine)
+    const char *HTS_Engine_get_fullcontext_label_format(HTS_Engine * engine)
+    char HTS_Engine_synthesize_from_strings(HTS_Engine * engine, char **lines, size_t num_lines)
+    char HTS_Engine_synthesize_from_fn(HTS_Engine * engine, const char *fn)
+    double HTS_Engine_get_generated_speech(HTS_Engine * engine, size_t index)
+    size_t HTS_Engine_get_nsamples(HTS_Engine * engine)

setup.py

@@ -1,42 +1,41 @@
-# coding: utf-8
-
-from __future__ import with_statement, print_function, absolute_import
-
-from setuptools import setup, find_packages, Extension
-import setuptools.command.develop
-import setuptools.command.build_py
-from distutils.version import LooseVersion
-import subprocess
-import numpy as np
 import os
+import subprocess
+from distutils.version import LooseVersion
 from glob import glob
-from os.path import join, exists
+from os.path import exists, join
 from subprocess import run
 
-version = '0.0.3'
+import numpy as np
+import setuptools.command.build_py
+import setuptools.command.develop
+from setuptools import Extension, find_packages, setup
+
+version = "0.0.3"
 
-min_cython_ver = '0.21.0'
+min_cython_ver = "0.21.0"
 try:
     import Cython
+
     ver = Cython.__version__
     _CYTHON_INSTALLED = ver >= LooseVersion(min_cython_ver)
 except ImportError:
     _CYTHON_INSTALLED = False
 
 try:
     if not _CYTHON_INSTALLED:
-        raise ImportError('No supported version of Cython installed.')
-    from Cython.Distutils import build_ext
+        raise ImportError("No supported version of Cython installed.")
     from Cython.Build import cythonize
+    from Cython.Distutils import build_ext
+
     cython = True
 except ImportError:
     cython = False
 
 if cython:
-    ext = '.pyx'
-    cmdclass = {'build_ext': build_ext}
+    ext = ".pyx"
+    cmdclass = {"build_ext": build_ext}
 else:
-    ext = '.cpp'
+    ext = ".cpp"
     cmdclass = {}
     if not os.path.exists(join("pyopenjtalk", "openjtalk" + ext)):
         raise RuntimeError("Cython is required to generate C++ code")
@@ -59,99 +58,125 @@
 all_src = []
 include_dirs = []
 for s in [
-    "jpcommon", "mecab/src", "mecab2njd", "njd", "njd2jpcommon",
-    "njd_set_accent_phrase", "njd_set_accent_type",
-    "njd_set_digit", "njd_set_long_vowel", "njd_set_pronunciation",
-    "njd_set_unvoiced_vowel", "text2mecab",
+    "jpcommon",
+    "mecab/src",
+    "mecab2njd",
+    "njd",
+    "njd2jpcommon",
+    "njd_set_accent_phrase",
+    "njd_set_accent_type",
+    "njd_set_digit",
+    "njd_set_long_vowel",
+    "njd_set_pronunciation",
+    "njd_set_unvoiced_vowel",
+    "text2mecab",
 ]:
     all_src += glob(join(src_top, s, "*.c"))
     all_src += glob(join(src_top, s, "*.cpp"))
     include_dirs.append(join(os.getcwd(), src_top, s))
 
-# define core cython module
-ext_modules = [Extension(
-    name="pyopenjtalk.openjtalk",
-    sources=[join("pyopenjtalk", "openjtalk" + ext)] + all_src,
-    include_dirs=[np.get_include()] + include_dirs,
-    extra_compile_args=[],
-    extra_link_args=[],
-    language="c++",
-    define_macros=[
-        ("HAVE_CONFIG_H", None),
-        ("DIC_VERSION", 102), ("MECAB_DEFAULT_RC", "\"dummy\""),
-        ("PACKAGE", "\"open_jtalk\""),
-        ("VERSION", "\"1.10\""),
-        ("CHARSET_UTF_8", None),
-    ]
-)]
+# Extension for OpenJTalk frontend
+ext_modules = [
+    Extension(
+        name="pyopenjtalk.openjtalk",
+        sources=[join("pyopenjtalk", "openjtalk" + ext)] + all_src,
+        include_dirs=[np.get_include()] + include_dirs,
+        extra_compile_args=[],
+        extra_link_args=[],
+        language="c++",
+        define_macros=[
+            ("HAVE_CONFIG_H", None),
+            ("DIC_VERSION", 102),
+            ("MECAB_DEFAULT_RC", '"dummy"'),
+            ("PACKAGE", '"open_jtalk"'),
+            ("VERSION", '"1.10"'),
+            ("CHARSET_UTF_8", None),
+        ],
+    )
+]
+
+# Extension for HTSEngine backend
+htsengine_src_top = join("lib", "hts_engine_API", "src")
+all_htsengine_src = glob(join(htsengine_src_top, "lib", "*.c"))
+ext_modules += [
+    Extension(
+        name="pyopenjtalk.htsengine",
+        sources=[join("pyopenjtalk", "htsengine" + ext)] + all_htsengine_src,
+        include_dirs=[np.get_include(), join(htsengine_src_top, "include")],
+        extra_compile_args=[],
+        extra_link_args=[],
+        language="c++",
+    )
+]
 
 # Adapted from https://github.com/pytorch/pytorch
 cwd = os.path.dirname(os.path.abspath(__file__))
-if os.getenv('PYOPENJTALK_BUILD_VERSION'):
-    version = os.getenv('PYOPENJTALK_BUILD_VERSION')
+if os.getenv("PYOPENJTALK_BUILD_VERSION"):
+    version = os.getenv("PYOPENJTALK_BUILD_VERSION")
 else:
     try:
-        sha = subprocess.check_output(
-            ['git', 'rev-parse', 'HEAD'], cwd=cwd).decode('ascii').strip()
-        version += '+' + sha[:7]
+        sha = (
+            subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=cwd)
+            .decode("ascii")
+            .strip()
+        )
+        version += "+" + sha[:7]
     except subprocess.CalledProcessError:
         pass
     except IOError:  # FileNotFoundError for python 3
         pass
 
 
 class build_py(setuptools.command.build_py.build_py):
-
     def run(self):
         self.create_version_file()
         setuptools.command.build_py.build_py.run(self)
 
     @staticmethod
     def create_version_file():
         global version, cwd
-        print('-- Building version ' + version)
-        version_path = os.path.join(cwd, 'pyopenjtalk', 'version.py')
-        with open(version_path, 'w') as f:
+        print("-- Building version " + version)
+        version_path = os.path.join(cwd, "pyopenjtalk", "version.py")
+        with open(version_path, "w") as f:
             f.write("__version__ = '{}'\n".format(version))
 
 
 class develop(setuptools.command.develop.develop):
-
     def run(self):
         build_py.create_version_file()
         setuptools.command.develop.develop.run(self)
 
 
-cmdclass['build_py'] = build_py
-cmdclass['develop'] = develop
+cmdclass["build_py"] = build_py
+cmdclass["develop"] = develop
 
 
-with open('README.md', 'r') as fd:
+with open("README.md", "r") as fd:
     long_description = fd.read()
 
 setup(
-    name='pyopenjtalk',
+    name="pyopenjtalk",
     version=version,
-    description='A python wrapper for OpenJTalk',
+    description="A python wrapper for OpenJTalk",
     long_description=long_description,
-    long_description_content_type='text/markdown',
-    author='Ryuichi Yamamoto',
-    author_email='zryuichi@gmail.com',
-    url='https://github.com/r9y9/pyopenjtalk',
-    license='MIT',
+    long_description_content_type="text/markdown",
+    author="Ryuichi Yamamoto",
+    author_email="zryuichi@gmail.com",
+    url="https://github.com/r9y9/pyopenjtalk",
+    license="MIT",
     packages=find_packages(),
-    package_data={'': ['htsvoice/*']},
+    package_data={"": ["htsvoice/*"]},
     ext_modules=ext_modules,
     cmdclass=cmdclass,
     install_requires=[
-        'numpy >= 1.8.0',
-        'cython >= ' + min_cython_ver,
-        'six',
+        "numpy >= 1.8.0",
+        "cython >= " + min_cython_ver,
+        "six",
     ],
-    tests_require=['nose', 'coverage'],
+    tests_require=["nose", "coverage"],
     extras_require={
-        'docs': ['sphinx_rtd_theme'],
-        'test': ['nose', 'scipy'],
+        "docs": ["sphinx_rtd_theme"],
+        "test": ["nose", "scipy"],
     },
     classifiers=[
         "Operating System :: POSIX",
@@ -168,5 +193,5 @@ def run(self):
         "Intended Audience :: Science/Research",
         "Intended Audience :: Developers",
     ],
-    keywords=["OpenJTalk", "Research"]
+    keywords=["OpenJTalk", "Research"],
 )