Update cpp, jieba still buggy

.gitignore

@@ -0,0 +1,6 @@
+/cpp/ax650n_bsp_sdk
+/cpp/install
+__pycache__
+.vscode
+/cpp/build
+*.wav

cpp/.gitattributes

@@ -0,0 +1,3 @@
+third_party/onnxruntime/lib/libonnxruntime_providers_shared.so filter=lfs diff=lfs merge=lfs -text
+third_party/onnxruntime/lib/libonnxruntime.so filter=lfs diff=lfs merge=lfs -text
+third_party/onnxruntime/lib/libonnxruntime.so.1.14.0 filter=lfs diff=lfs merge=lfs -text

cpp/CMakeLists.txt

@@ -0,0 +1,65 @@
+cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+project(kokoro)
+
+set(CMAKE_CXX_STANDARD 17)
+
+if (CMAKE_BUILD_TYPE MATCHES Debug)
+    set(CMAKE_CXX_FLAGS "-fvisibility=hidden -g -O0")
+elseif (CMAKE_BUILD_TYPE MATCHES Release)
+    set(CMAKE_CXX_FLAGS "-fvisibility=hidden -O2")
+endif()
+
+include(cmake/msp_dependencies.cmake)
+add_definitions(-DENV_HAS_STD_FILESYSTEM)
+add_definitions(-DENV_HAS_POSIX_FILE_STAT)
+
+include_directories(${MSP_INC_DIR})
+link_directories(${MSP_LIB_DIR})
+
+# onnxruntime
+include_directories(third_party/onnxruntime/include)
+include_directories(third_party/onnxruntime/include/onnxruntime/core/session)
+link_directories(third_party/onnxruntime/lib)
+list(APPEND ORT_LIBS onnxruntime onnxruntime_providers_shared)
+
+# limonp
+include_directories(src/limonp/include)
+
+# Eigen
+include_directories(src/librosa/eigen3)
+
+# librosa
+include_directories(src/librosa/)
+
+include_directories(src)
+aux_source_directory(src SRC)
+aux_source_directory(src/ax_model_runner SRC)
+
+add_executable(kokoro main.cpp ${SRC})
+target_link_libraries(kokoro ${MSP_LIBS} ${ORT_LIBS})
+
+add_executable(test_ax_model tests/test_ax_model.cpp ${SRC})
+target_link_libraries(test_ax_model ${MSP_LIBS} ${ORT_LIBS})
+
+add_executable(test_jieba tests/test_jieba.cpp ${SRC})
+target_link_libraries(test_jieba ${MSP_LIBS} ${ORT_LIBS})
+
+install(TARGETS 
+        kokoro 
+        test_ax_model
+        test_jieba
+    RUNTIME
+        DESTINATION .)
+
+set_target_properties(kokoro
+    PROPERTIES
+    INSTALL_RPATH "$ORIGIN/../third_party/onnxruntime/lib"
+)
+set_target_properties(test_ax_model
+    PROPERTIES
+    INSTALL_RPATH "$ORIGIN/../third_party/onnxruntime/lib"
+)  
+set_target_properties(test_jieba
+    PROPERTIES
+    INSTALL_RPATH "$ORIGIN/../third_party/onnxruntime/lib"
+)  

cpp/build.sh

@@ -0,0 +1,8 @@
+mkdir -p build && cd build
+cmake ..  \
+  -DCHIP_AX650=ON  \
+  -DCMAKE_TOOLCHAIN_FILE=../toolchains/aarch64-none-linux-gnu.toolchain.cmake \
+  -DCMAKE_INSTALL_PREFIX=../install \
+  -DCMAKE_BUILD_TYPE=Release
+make -j4
+make install

cpp/cmake/msp_dependencies.cmake

@@ -0,0 +1,24 @@
+# bsp
+if(NOT BSP_MSP_DIR)
+    if (CHIP_AX650)
+        add_definitions(-DCHIP_AX650)
+        set(BSP_MSP_DIR ${CMAKE_SOURCE_DIR}/ax650n_bsp_sdk/msp/out)
+    else()
+        add_definitions(-DCHIP_AX630C)
+        set(BSP_MSP_DIR ${CMAKE_SOURCE_DIR}/ax620e_bsp_sdk/msp/out/arm64_glibc)
+    endif()
+endif()
+message(STATUS "BSP_MSP_DIR = ${BSP_MSP_DIR}")
+
+# check bsp exist
+if(NOT EXISTS ${BSP_MSP_DIR})
+    message(FATAL_ERROR "FATAL: BSP_MSP_DIR ${BSP_MSP_DIR} not exist")
+endif()
+
+set(MSP_INC_DIR ${BSP_MSP_DIR}/include)
+set(MSP_LIB_DIR ${BSP_MSP_DIR}/lib)
+
+list(APPEND MSP_LIBS
+        ax_sys
+        ax_engine
+        ax_interpreter)

cpp/dict/cmudict-0.7b/LICENSE

@@ -0,0 +1,33 @@
+Copyright (C) 1993-2015 Carnegie Mellon University. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+   The contents of this file are deemed to be source code.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+This work was supported in part by funding from the Defense Advanced
+Research Projects Agency, the Office of Naval Research and the National
+Science Foundation of the United States of America, and by member
+companies of the Carnegie Mellon Sphinx Speech Consortium. We acknowledge
+the contributions of many volunteers to the expansion and improvement of
+this dictionary.
+
+THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND
+ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
+NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cpp/dict/cmudict-0.7b/README

@@ -0,0 +1,32 @@
+
+CMUdict
+-------
+
+CMUdict (the Carnegie Mellon Pronouncing Dictionary) is a free
+pronouncing dictionary of English, suitable for uses in speech
+technology and is maintained by the Speech Group in the School of
+Computer Science at Carnegie Mellon University.
+
+The Carnegie Mellon Speech Group does not guarantee the accuracy of
+this dictionary, nor its suitability for any specific purpose. In
+fact, we expect a number of errors, omissions and inconsistencies to
+remain in the dictionary. We intend to continually update the
+dictionary by correction existing entries and by adding new ones. From
+time to time a new major version will be released.
+
+We welcome input from users: Please send email to Alex Rudnicky
+(air+cmudict@cs.cmu.edu).
+
+The Carnegie Mellon Pronouncing Dictionary, in its current and
+previous versions is Copyright (C) 1993-2014 by Carnegie Mellon
+University.  Use of this dictionary for any research or commercial
+purpose is completely unrestricted.  If you make use of or
+redistribute this material we request that you acknowledge its
+origin in your descriptions.
+
+If you add words to or correct words in your version of this
+dictionary, we would appreciate it if you could send these additions
+and corrections to us (air+cmudict@cs.cmu.edu) for consideration in a
+subsequent version. All submissions will be reviewed and approved by
+the current maintainer, Alex Rudnicky at Carnegie Mellon.
+

cpp/dict/cmudict-0.7b/README.developer

@@ -0,0 +1,66 @@
+Development and maintenance for cmudict
+---------------------------------------
+[20100118] (air)
+
+The maintainer is responsible for acquiring and vetting new entries,
+and for fixing errors that they otherwise encounter.
+
+At this point, the cmudict project has been incrementally
+re-organized; maintenance has been simplified and several aspects have
+been automated. The scripts/ folder contains instructions and scripts
+for routine maintenance. It has everything you should need to get
+started.
+
+Version numbers and files
+-------------------------
+There is no particular rule for incrementing the version number. To
+date the minor version (letter suffix) has been incremented to reflect
+changes in maintainers. Major version increments (right now, the
+decimal) are incurred when some (subjectively) large change
+occurs. For example, the 0.6-->0.7 increment was marked by a large
+number of new entries and by the removal of many incorrect entries
+from the preceeding 0.6e version.
+
+The cmudict.*.phones file lists all legal phones, plus their phonetic class.
+The cmudict.*.symbols file lists all legal phonetic symbols (the only
+substantive difference is that stress combinations are explicitly noted).
+
+Projects for the ambitious
+--------------------------
+
+1. Change the current flat-file version to a database format. This
+should still allow producing a flat file, but it will simplify adding
+useful information to the dictionary. Some possible data includes:
+
+a. part-of-speech information
+b. domain information (e.g., location, medical, non-english, etc)
+c. spelling variants
+d. source information (who, when, ...)
+e. probabilities for pronunciation variants
+
+There's additional stuff that can be done but the above bits seem the
+most useful ones. I also have ideas on how to do it, so feel free to
+get in touch (air at cs cmu edu).
+
+2. Create an OS independent GUI for managing the database. This should
+allow the maintainer to view and modify entries, while dealing with
+bookkeeping. It would be nice if the GUI included a synthesizer so
+that entries can be checked by listening.
+
+Reductions
+----------
+
+CMUDict tries to be phonetic dictionary and account for possible phonetic
+reductions like
+
+N T -> N   intersomething countersomething
+IH -> AH lots of examples
+EH -> AH lots of examples
+AE -> EH happens sometimes
+
+However, this is not done in a consistent way yet. So sometimes both
+reduced and original version is present in the dictionary, sometimes
+only original or only reduced based on perceived frequency in read speech.
+
+This situation might improve in the future
+

cpp/dict/cmudict-0.7b/cmudict.phones

@@ -0,0 +1,39 @@
+AA	vowel
+AE	vowel
+AH	vowel
+AO	vowel
+AW	vowel
+AY	vowel
+B	stop
+CH	affricate
+D	stop
+DH	fricative
+EH	vowel
+ER	vowel
+EY	vowel
+F	fricative
+G	stop
+HH	aspirate
+IH	vowel
+IY	vowel
+JH	affricate
+K	stop
+L	liquid
+M	nasal
+N	nasal
+NG	nasal
+OW	vowel
+OY	vowel
+P	stop
+R	liquid
+S	fricative
+SH	fricative
+T	stop
+TH	fricative
+UH	vowel
+UW	vowel
+V	fricative
+W	semivowel
+Y	semivowel
+Z	fricative
+ZH	fricative

cpp/dict/cmudict-0.7b/cmudict.symbols

@@ -0,0 +1,84 @@
+AA
+AA0
+AA1
+AA2
+AE
+AE0
+AE1
+AE2
+AH
+AH0
+AH1
+AH2
+AO
+AO0
+AO1
+AO2
+AW
+AW0
+AW1
+AW2
+AY
+AY0
+AY1
+AY2
+B
+CH
+D
+DH
+EH
+EH0
+EH1
+EH2
+ER
+ER0
+ER1
+ER2
+EY
+EY0
+EY1
+EY2
+F
+G
+HH
+IH
+IH0
+IH1
+IH2
+IY
+IY0
+IY1
+IY2
+JH
+K
+L
+M
+N
+NG
+OW
+OW0
+OW1
+OW2
+OY
+OY0
+OY1
+OY2
+P
+R
+S
+SH
+T
+TH
+UH
+UH0
+UH1
+UH2
+UW
+UW0
+UW1
+UW2
+V
+W
+Y
+Z
+ZH

cpp/dict/cmudict-0.7b/cmudict.vp

@@ -0,0 +1,54 @@
+!exclamation-point EH2 K S K L AH0 M EY1 SH AH0 N P OY2 N T
+"close-quote K L OW1 Z K W OW1 T
+"double-quote D AH1 B AH0 L K W OW1 T
+"end-of-quote EH1 N D AH0 V K W OW1 T
+"end-quote EH1 N D K W OW1 T
+"in-quotes IH1 N K W OW1 T S
+"quote K W OW1 T
+"unquote AH1 N K W OW1 T
+#sharp-sign SH AA1 R P S AY1 N
+%percent P ER0 S EH1 N T
+&ampersand AE1 M P ER0 S AE2 N D
+(begin-parens B IH0 G IH1 N P ER0 EH1 N Z
+(in-parentheses IH1 N P ER0 EH1 N TH AH0 S IY2 Z
+(left-paren L EH1 F T P ER0 EH1 N
+(open-parentheses OW1 P AH0 N P ER0 EH1 N TH AH0 S IY2 Z
+(paren P ER0 EH1 N
+(parens P ER0 EH1 N Z
+(parentheses P ER0 EH1 N TH AH0 S IY2 Z
+)close-paren K L OW1 Z P ER0 EH1 N
+)close-parentheses K L OW1 Z P ER0 EH1 N TH AH0 S IY2 Z
+)end-paren EH1 N D P ER0 EH1 N
+)end-parens EH1 N D P ER0 EH1 N Z
+)end-parentheses EH1 N D P ER0 EH1 N TH AH0 S IY2 Z
+)end-the-paren EH1 N D DH AH0 P ER0 EH1 N
+)paren P ER0 EH1 N
+)parens P ER0 EH1 N Z
+)right-paren R AY1 T P ER0 EH1 N
+)right-paren(1) R AY1 T P EH1 R AH0 N
+)un-parentheses AH1 N P ER0 EH1 N TH AH0 S IY1 Z
+,comma K AA1 M AH0
+-dash D AE1 SH
+-hyphen HH AY1 F AH0 N
+...ellipsis IH0 L IH1 P S IH0 S
+.decimal D EH1 S AH0 M AH0 L
+.dot D AA1 T
+.full-stop F UH1 L S T AA1 P
+.period P IH1 R IY0 AH0 D
+.point P OY1 N T
+/slash S L AE1 SH
+:colon K OW1 L AH0 N
+;semi-colon S EH1 M IY0 K OW1 L AH0 N
+;semi-colon(1) S EH1 M IH0 K OW2 L AH0 N
+?question-mark K W EH1 S CH AH0 N M AA1 R K
+{brace B R EY1 S
+{left-brace L EH1 F T B R EY1 S
+{open-brace OW1 P EH0 N B R EY1 S
+}close-brace K L OW1 Z B R EY1 S
+}right-brace R AY1 T B R EY1 S
+'end-inner-quote EH1 N D IH1 N ER0 K W OW1 T
+'end-quote EH1 N D K W OW1 T
+'inner-quote IH1 N ER0 K W OW1 T
+'single-quote S IH1 NG G AH0 L K W OW1 T
+'quote K W OW1 T
+'apostrophe AH0 P AA1 S T R AH0 F IY0

cpp/dict/cmudict-0.7b/make_ps_dict.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Convert CMU Pronouncing Dictionary to PocketSphinx format.
+
+This script strips stress markers (0, 1, 2) from phonemes and deduplicates
+pronunciations that become identical after stress removal.
+
+Example:
+    interest    IH1 N T R AH0 S T     ->  interest    IH N T R AH S T
+    interest(2) IH1 N T R IH0 S T     ->  interest(2) IH N T R IH S T
+"""
+
+import argparse
+import re
+import sys
+from collections import defaultdict
+from typing import TextIO, Dict, List
+
+
+def strip_stress(phoneme: str) -> str:
+    """
+    Remove stress markers from a phoneme.
+
+    CMUdict uses digits 0, 1, 2 at the end of vowel phonemes to indicate stress:
+        0 = no stress
+        1 = primary stress
+        2 = secondary stress
+
+    Args:
+        phoneme: A phoneme string (e.g., 'AH0', 'T', 'IH1')
+
+    Returns:
+        The phoneme without stress markers (e.g., 'AH', 'T', 'IH')
+    """
+    return re.sub(r'[012]$', '', phoneme)
+
+
+def parse_cmudict_line(line: str) -> tuple[str, List[str]] | None:
+    """
+    Parse a single line from CMUdict.
+
+    Args:
+        line: A line from the dictionary file
+
+    Returns:
+        Tuple of (base_word, phonemes) or None if line should be skipped
+
+    Examples:
+        "hello HH AH0 L OW1" -> ("hello", ["HH", "AH0", "L", "OW1"])
+        "world(2) W ER1 L D" -> ("world", ["W", "ER1", "L", "D"])
+        ";;; comment" -> None
+    """
+    line = line.strip()
+
+    # Skip empty lines and comments
+    if not line or line.startswith(';;;'):
+        return None
+
+    # Remove inline comments
+    if '#' in line:
+        line = line.split('#')[0].strip()
+
+    # Split into word and phonemes
+    parts = line.split()
+    if len(parts) < 2:
+        return None
+
+    word_with_variant = parts[0]
+    phonemes = parts[1:]
+
+    # Extract base word by removing variant marker like (2), (3), etc.
+    base_word = re.sub(r'\(\d+\)$', '', word_with_variant)
+
+    return base_word, phonemes
+
+
+def convert_dict(infile: TextIO, outfile: TextIO) -> int:
+    """
+    Convert CMUdict to PocketSphinx format by stripping stress markers.
+
+    The function:
+    1. Reads all pronunciations from the input
+    2. Strips stress markers from phonemes
+    3. Groups pronunciations by base word
+    4. Removes duplicate pronunciations (same after stress removal)
+    5. Writes sorted output with proper variant numbering
+
+    Args:
+        infile: Input file stream (CMUdict format)
+        outfile: Output file stream (PocketSphinx format)
+
+    Returns:
+        Number of entries written
+    """
+    # Dictionary to store unique pronunciations for each word
+    # Key: base word, Value: list of unique stress-free pronunciations
+    word_pronunciations: Dict[str, List[str]] = defaultdict(list)
+
+    # Read and process all lines
+    for line in infile:
+        result = parse_cmudict_line(line)
+        if result is None:
+            continue
+
+        base_word, phonemes = result
+
+        # Strip stress from all phonemes
+        phonemes_no_stress = [strip_stress(p) for p in phonemes]
+        pronunciation = ' '.join(phonemes_no_stress)
+
+        # Only keep unique pronunciations (deduplication)
+        if pronunciation not in word_pronunciations[base_word]:
+            word_pronunciations[base_word].append(pronunciation)
+
+    # Write output in sorted order
+    entries_written = 0
+    for base_word in sorted(word_pronunciations):
+        pronunciations = word_pronunciations[base_word]
+
+        for idx, pronunciation in enumerate(pronunciations):
+            # First pronunciation has no suffix, subsequent ones get (2), (3), etc.
+            if idx == 0:
+                word_variant = base_word
+            else:
+                word_variant = f"{base_word}({idx + 1})"
+
+            print(f"{word_variant} {pronunciation}", file=outfile)
+            entries_written += 1
+
+    return entries_written
+
+
+def main() -> None:
+    """
+    Main entry point for the script.
+
+    Parses command-line arguments and orchestrates the conversion process.
+    """
+    parser = argparse.ArgumentParser(
+        description="Convert CMUdict to PocketSphinx format (strip stress markers)",
+        epilog="Example: python make_ps_dict.py cmudict.dict -o pocketsphinx.dict"
+    )
+    parser.add_argument(
+        "input",
+        nargs="?",
+        default="cmudict.dict",
+        help="input CMUdict file (default: cmudict.dict)"
+    )
+    parser.add_argument(
+        "-o", "--output",
+        type=str,
+        help="output file (default: stdout)"
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="print progress information to stderr"
+    )
+
+    args = parser.parse_args()
+
+    # Log input file if verbose
+    if args.verbose:
+        print(f"Reading from: {args.input}", file=sys.stderr)
+
+    # Read input and write output
+    try:
+        with open(args.input, 'r', encoding='latin-1') as infile:
+            if args.output:
+                with open(args.output, 'w', encoding='utf-8') as outfile:
+                    count = convert_dict(infile, outfile)
+            else:
+                count = convert_dict(infile, sys.stdout)
+
+        # Log success if verbose
+        if args.verbose:
+            print(f"Successfully wrote {count:,} entries", file=sys.stderr)
+
+    except FileNotFoundError:
+        print(f"Error: Input file '{args.input}' not found", file=sys.stderr)
+        sys.exit(1)
+    except IOError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cpp/dict/pos_dict/prob_start.utf8

@@ -0,0 +1,259 @@
+#初始状态的概率
+#格式
+#状态:概率
+B,a:-4.7623052146
+B,ad:-6.68006603678
+B,ag:-3.14e+100
+B,an:-8.69708322302
+B,b:-5.01837436211
+B,bg:-3.14e+100
+B,c:-3.42388018495
+B,d:-3.97504752976
+B,df:-8.88897423083
+B,dg:-3.14e+100
+B,e:-8.56355183039
+B,en:-3.14e+100
+B,f:-5.49163041848
+B,g:-3.14e+100
+B,h:-13.53336513
+B,i:-6.11578472756
+B,in:-3.14e+100
+B,j:-5.05761912847
+B,jn:-3.14e+100
+B,k:-3.14e+100
+B,l:-4.90588358466
+B,ln:-3.14e+100
+B,m:-3.6524299819
+B,mg:-3.14e+100
+B,mq:-6.7869530014
+B,n:-1.69662577975
+B,ng:-3.14e+100
+B,nr:-2.23104959138
+B,nrfg:-5.87372217541
+B,nrt:-4.98564273352
+B,ns:-2.8228438315
+B,nt:-4.84609166818
+B,nz:-3.94698846058
+B,o:-8.43349870215
+B,p:-4.20098413209
+B,q:-6.99812385896
+B,qe:-3.14e+100
+B,qg:-3.14e+100
+B,r:-3.40981877908
+B,rg:-3.14e+100
+B,rr:-12.4347528413
+B,rz:-7.94611647157
+B,s:-5.52267359084
+B,t:-3.36474790945
+B,tg:-3.14e+100
+B,u:-9.1639172775
+B,ud:-3.14e+100
+B,ug:-3.14e+100
+B,uj:-3.14e+100
+B,ul:-3.14e+100
+B,uv:-3.14e+100
+B,uz:-3.14e+100
+B,v:-2.67405848743
+B,vd:-9.04472876024
+B,vg:-3.14e+100
+B,vi:-12.4347528413
+B,vn:-4.33156108902
+B,vq:-12.1470707689
+B,w:-3.14e+100
+B,x:-3.14e+100
+B,y:-9.84448567586
+B,yg:-3.14e+100
+B,z:-7.04568111149
+B,zg:-3.14e+100
+E,a:-3.14e+100
+E,ad:-3.14e+100
+E,ag:-3.14e+100
+E,an:-3.14e+100
+E,b:-3.14e+100
+E,bg:-3.14e+100
+E,c:-3.14e+100
+E,d:-3.14e+100
+E,df:-3.14e+100
+E,dg:-3.14e+100
+E,e:-3.14e+100
+E,en:-3.14e+100
+E,f:-3.14e+100
+E,g:-3.14e+100
+E,h:-3.14e+100
+E,i:-3.14e+100
+E,in:-3.14e+100
+E,j:-3.14e+100
+E,jn:-3.14e+100
+E,k:-3.14e+100
+E,l:-3.14e+100
+E,ln:-3.14e+100
+E,m:-3.14e+100
+E,mg:-3.14e+100
+E,mq:-3.14e+100
+E,n:-3.14e+100
+E,ng:-3.14e+100
+E,nr:-3.14e+100
+E,nrfg:-3.14e+100
+E,nrt:-3.14e+100
+E,ns:-3.14e+100
+E,nt:-3.14e+100
+E,nz:-3.14e+100
+E,o:-3.14e+100
+E,p:-3.14e+100
+E,q:-3.14e+100
+E,qe:-3.14e+100
+E,qg:-3.14e+100
+E,r:-3.14e+100
+E,rg:-3.14e+100
+E,rr:-3.14e+100
+E,rz:-3.14e+100
+E,s:-3.14e+100
+E,t:-3.14e+100
+E,tg:-3.14e+100
+E,u:-3.14e+100
+E,ud:-3.14e+100
+E,ug:-3.14e+100
+E,uj:-3.14e+100
+E,ul:-3.14e+100
+E,uv:-3.14e+100
+E,uz:-3.14e+100
+E,v:-3.14e+100
+E,vd:-3.14e+100
+E,vg:-3.14e+100
+E,vi:-3.14e+100
+E,vn:-3.14e+100
+E,vq:-3.14e+100
+E,w:-3.14e+100
+E,x:-3.14e+100
+E,y:-3.14e+100
+E,yg:-3.14e+100
+E,z:-3.14e+100
+E,zg:-3.14e+100
+M,a:-3.14e+100
+M,ad:-3.14e+100
+M,ag:-3.14e+100
+M,an:-3.14e+100
+M,b:-3.14e+100
+M,bg:-3.14e+100
+M,c:-3.14e+100
+M,d:-3.14e+100
+M,df:-3.14e+100
+M,dg:-3.14e+100
+M,e:-3.14e+100
+M,en:-3.14e+100
+M,f:-3.14e+100
+M,g:-3.14e+100
+M,h:-3.14e+100
+M,i:-3.14e+100
+M,in:-3.14e+100
+M,j:-3.14e+100
+M,jn:-3.14e+100
+M,k:-3.14e+100
+M,l:-3.14e+100
+M,ln:-3.14e+100
+M,m:-3.14e+100
+M,mg:-3.14e+100
+M,mq:-3.14e+100
+M,n:-3.14e+100
+M,ng:-3.14e+100
+M,nr:-3.14e+100
+M,nrfg:-3.14e+100
+M,nrt:-3.14e+100
+M,ns:-3.14e+100
+M,nt:-3.14e+100
+M,nz:-3.14e+100
+M,o:-3.14e+100
+M,p:-3.14e+100
+M,q:-3.14e+100
+M,qe:-3.14e+100
+M,qg:-3.14e+100
+M,r:-3.14e+100
+M,rg:-3.14e+100
+M,rr:-3.14e+100
+M,rz:-3.14e+100
+M,s:-3.14e+100
+M,t:-3.14e+100
+M,tg:-3.14e+100
+M,u:-3.14e+100
+M,ud:-3.14e+100
+M,ug:-3.14e+100
+M,uj:-3.14e+100
+M,ul:-3.14e+100
+M,uv:-3.14e+100
+M,uz:-3.14e+100
+M,v:-3.14e+100
+M,vd:-3.14e+100
+M,vg:-3.14e+100
+M,vi:-3.14e+100
+M,vn:-3.14e+100
+M,vq:-3.14e+100
+M,w:-3.14e+100
+M,x:-3.14e+100
+M,y:-3.14e+100
+M,yg:-3.14e+100
+M,z:-3.14e+100
+M,zg:-3.14e+100
+S,a:-3.90253968313
+S,ad:-11.0484584802
+S,ag:-6.95411391796
+S,an:-12.8402179494
+S,b:-6.47288876397
+S,bg:-3.14e+100
+S,c:-4.78696679586
+S,d:-3.90391976418
+S,df:-3.14e+100
+S,dg:-8.9483976513
+S,e:-5.94251300628
+S,en:-3.14e+100
+S,f:-5.19482024998
+S,g:-6.50782681533
+S,h:-8.65056320738
+S,i:-3.14e+100
+S,in:-3.14e+100
+S,j:-4.91199211964
+S,jn:-3.14e+100
+S,k:-6.94032059583
+S,l:-3.14e+100
+S,ln:-3.14e+100
+S,m:-3.26920065212
+S,mg:-10.8253149289
+S,mq:-3.14e+100
+S,n:-3.85514838976
+S,ng:-4.9134348611
+S,nr:-4.48366310396
+S,nrfg:-3.14e+100
+S,nrt:-3.14e+100
+S,ns:-3.14e+100
+S,nt:-12.1470707689
+S,nz:-3.14e+100
+S,o:-8.46446092775
+S,p:-2.98684018136
+S,q:-4.88865861826
+S,qe:-3.14e+100
+S,qg:-3.14e+100
+S,r:-2.76353367841
+S,rg:-10.2752685919
+S,rr:-3.14e+100
+S,rz:-3.14e+100
+S,s:-3.14e+100
+S,t:-3.14e+100
+S,tg:-6.27284253188
+S,u:-6.94032059583
+S,ud:-7.72823016105
+S,ug:-7.53940370266
+S,uj:-6.85251045118
+S,ul:-8.41537131755
+S,uv:-8.15808672229
+S,uz:-9.29925862537
+S,v:-3.05329230341
+S,vd:-3.14e+100
+S,vg:-5.94301818437
+S,vi:-3.14e+100
+S,vn:-11.4539235883
+S,vq:-3.14e+100
+S,w:-3.14e+100
+S,x:-8.42741965607
+S,y:-6.19707946995
+S,yg:-13.53336513
+S,z:-3.14e+100
+S,zg:-3.14e+100

cpp/dict/stop_words.utf8

@@ -0,0 +1,1534 @@
+"
+.
+。
+,
+、
+！
+？
+：
+；
+`
+﹑
+•
+＂
+^
+…
+‘
+’
+“
+”
+〝
+〞
+~
+\
+∕
+|
+¦
+‖
+—　
+(
+)
+〈
+〉
+﹞
+﹝
+「
+」
+‹
+›
+〖
+〗
+】
+【
+»
+«
+』
+『
+〕
+〔
+》
+《
+}
+{
+]
+[
+﹐
+¸
+﹕
+︰
+﹔
+;
+！
+¡
+？
+¿
+﹖
+﹌
+﹏
+﹋
+＇
+´
+ˊ
+ˋ
+-
+―
+﹫
+@
+︳
+︴
+_
+¯
+＿
+￣
+﹢
++
+﹦
+=
+﹤
+‐
+<
+­
+˜
+~
+﹟
+#
+﹩
+$
+﹠
+&
+﹪
+%
+﹡
+*
+﹨
+\
+﹍
+﹉
+﹎
+﹊
+ˇ
+︵
+︶
+︷
+︸
+︹
+︿
+﹀
+︺
+︽
+︾
+_
+ˉ
+﹁
+﹂
+﹃
+﹄
+︻
+︼
+的
+了
+the
+a
+an
+that
+those
+this
+that
+$
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+?
+_
+“
+”
+、
+。
+《
+》
+一
+一些
+一何
+一切
+一则
+一方面
+一旦
+一来
+一样
+一般
+一转眼
+万一
+上
+上下
+下
+不
+不仅
+不但
+不光
+不单
+不只
+不外乎
+不如
+不妨
+不尽
+不尽然
+不得
+不怕
+不惟
+不成
+不拘
+不料
+不是
+不比
+不然
+不特
+不独
+不管
+不至于
+不若
+不论
+不过
+不问
+与
+与其
+与其说
+与否
+与此同时
+且
+且不说
+且说
+两者
+个
+个别
+临
+为
+为了
+为什么
+为何
+为止
+为此
+为着
+乃
+乃至
+乃至于
+么
+之
+之一
+之所以
+之类
+乌乎
+乎
+乘
+也
+也好
+也罢
+了
+二来
+于
+于是
+于是乎
+云云
+云尔
+些
+亦
+人
+人们
+人家
+什么
+什么样
+今
+介于
+仍
+仍旧
+从
+从此
+从而
+他
+他人
+他们
+以
+以上
+以为
+以便
+以免
+以及
+以故
+以期
+以来
+以至
+以至于
+以致
+们
+任
+任何
+任凭
+似的
+但
+但凡
+但是
+何
+何以
+何况
+何处
+何时
+余外
+作为
+你
+你们
+使
+使得
+例如
+依
+依据
+依照
+便于
+俺
+俺们
+倘
+倘使
+倘或
+倘然
+倘若
+借
+假使
+假如
+假若
+傥然
+像
+儿
+先不先
+光是
+全体
+全部
+兮
+关于
+其
+其一
+其中
+其二
+其他
+其余
+其它
+其次
+具体地说
+具体说来
+兼之
+内
+再
+再其次
+再则
+再有
+再者
+再者说
+再说
+冒
+冲
+况且
+几
+几时
+凡
+凡是
+凭
+凭借
+出于
+出来
+分别
+则
+则甚
+别
+别人
+别处
+别是
+别的
+别管
+别说
+到
+前后
+前此
+前者
+加之
+加以
+即
+即令
+即使
+即便
+即如
+即或
+即若
+却
+去
+又
+又及
+及
+及其
+及至
+反之
+反而
+反过来
+反过来说
+受到
+另
+另一方面
+另外
+另悉
+只
+只当
+只怕
+只是
+只有
+只消
+只要
+只限
+叫
+叮咚
+可
+可以
+可是
+可见
+各
+各个
+各位
+各种
+各自
+同
+同时
+后
+后者
+向
+向使
+向着
+吓
+吗
+否则
+吧
+吧哒
+吱
+呀
+呃
+呕
+呗
+呜
+呜呼
+呢
+呵
+呵呵
+呸
+呼哧
+咋
+和
+咚
+咦
+咧
+咱
+咱们
+咳
+哇
+哈
+哈哈
+哉
+哎
+哎呀
+哎哟
+哗
+哟
+哦
+哩
+哪
+哪个
+哪些
+哪儿
+哪天
+哪年
+哪怕
+哪样
+哪边
+哪里
+哼
+哼唷
+唉
+唯有
+啊
+啐
+啥
+啦
+啪达
+啷当
+喂
+喏
+喔唷
+喽
+嗡
+嗡嗡
+嗬
+嗯
+嗳
+嘎
+嘎登
+嘘
+嘛
+嘻
+嘿
+嘿嘿
+因
+因为
+因了
+因此
+因着
+因而
+固然
+在
+在下
+在于
+地
+基于
+处在
+多
+多么
+多少
+大
+大家
+她
+她们
+好
+如
+如上
+如上所述
+如下
+如何
+如其
+如同
+如是
+如果
+如此
+如若
+始而
+孰料
+孰知
+宁
+宁可
+宁愿
+宁肯
+它
+它们
+对
+对于
+对待
+对方
+对比
+将
+小
+尔
+尔后
+尔尔
+尚且
+就
+就是
+就是了
+就是说
+就算
+就要
+尽
+尽管
+尽管如此
+岂但
+己
+已
+已矣
+巴
+巴巴
+并
+并且
+并非
+庶乎
+庶几
+开外
+开始
+归
+归齐
+当
+当地
+当然
+当着
+彼
+彼时
+彼此
+往
+待
+很
+得
+得了
+怎
+怎么
+怎么办
+怎么样
+怎奈
+怎样
+总之
+总的来看
+总的来说
+总的说来
+总而言之
+恰恰相反
+您
+惟其
+慢说
+我
+我们
+或
+或则
+或是
+或曰
+或者
+截至
+所
+所以
+所在
+所幸
+所有
+才
+才能
+打
+打从
+把
+抑或
+拿
+按
+按照
+换句话说
+换言之
+据
+据此
+接着
+故
+故此
+故而
+旁人
+无
+无宁
+无论
+既
+既往
+既是
+既然
+时候
+是
+是以
+是的
+曾
+替
+替代
+最
+有
+有些
+有关
+有及
+有时
+有的
+望
+朝
+朝着
+本
+本人
+本地
+本着
+本身
+来
+来着
+来自
+来说
+极了
+果然
+果真
+某
+某个
+某些
+某某
+根据
+欤
+正值
+正如
+正巧
+正是
+此
+此地
+此处
+此外
+此时
+此次
+此间
+毋宁
+每
+每当
+比
+比及
+比如
+比方
+没奈何
+沿
+沿着
+漫说
+焉
+然则
+然后
+然而
+照
+照着
+犹且
+犹自
+甚且
+甚么
+甚或
+甚而
+甚至
+甚至于
+用
+用来
+由
+由于
+由是
+由此
+由此可见
+的
+的确
+的话
+直到
+相对而言
+省得
+看
+眨眼
+着
+着呢
+矣
+矣乎
+矣哉
+离
+竟而
+第
+等
+等到
+等等
+简言之
+管
+类如
+紧接着
+纵
+纵令
+纵使
+纵然
+经
+经过
+结果
+给
+继之
+继后
+继而
+综上所述
+罢了
+者
+而
+而且
+而况
+而后
+而外
+而已
+而是
+而言
+能
+能否
+腾
+自
+自个儿
+自从
+自各儿
+自后
+自家
+自己
+自打
+自身
+至
+至于
+至今
+至若
+致
+般的
+若
+若夫
+若是
+若果 
+若非
+莫不然
+莫如
+莫若
+虽
+虽则
+虽然
+虽说
+被
+要
+要不
+要不是
+要不然
+要么
+要是
+譬喻
+譬如
+让
+许多
+论
+设使
+设或
+设若
+诚如
+诚然
+该
+说来
+诸
+诸位
+诸如
+谁
+谁人
+谁料
+谁知
+贼死
+赖以
+赶
+起
+起见
+趁
+趁着
+越是
+距
+跟
+较
+较之
+边
+过
+还
+还是
+还有
+还要
+这
+这一来
+这个
+这么
+这么些
+这么样
+这么点儿
+这些
+这会儿
+这儿
+这就是说
+这时
+这样
+这次
+这般
+这边
+这里
+进而
+连
+连同
+逐步
+通过
+遵循
+遵照
+那
+那个
+那么
+那么些
+那么样
+那些
+那会儿
+那儿
+那时
+那样
+那般
+那边
+那里
+都
+鄙人
+鉴于
+针对
+阿
+除
+除了
+除外
+除开
+除此之外
+除非
+随
+随后
+随时
+随着
+难道说
+非但
+非徒
+非特
+非独
+靠
+顺
+顺着
+首先
+！
+，
+：
+；
+？
+to
+can
+could
+dare
+do
+did
+does
+may
+might
+would
+should
+must
+will
+ought
+shall
+need
+is
+a
+am
+are
+about
+according
+after
+against
+all
+almost
+also
+although
+among
+an
+and
+another
+any
+anything
+approximately
+as
+asked
+at
+back
+because
+before
+besides
+between
+both
+but
+by
+call
+called
+currently
+despite
+did
+do
+dr
+during
+each
+earlier
+eight
+even
+eventually
+every
+everything
+five
+for
+four
+from
+he
+her
+here
+his
+how
+however
+i
+if
+in
+indeed
+instead
+it
+its
+just
+last
+like
+major
+many
+may
+maybe
+meanwhile
+more
+moreover
+most
+mr
+mrs
+ms
+much
+my
+neither
+net
+never
+nevertheless
+nine
+no
+none
+not
+nothing
+now
+of
+on
+once
+one
+only
+or
+other
+our
+over
+partly
+perhaps
+prior
+regarding
+separately
+seven
+several
+she
+should
+similarly
+since
+six
+so
+some
+somehow
+still
+such
+ten
+that
+the
+their
+then
+there
+therefore
+these
+they
+this
+those
+though
+three
+to
+two
+under
+unless
+unlike
+until
+volume
+we
+what
+whatever
+whats
+when
+where
+which
+while
+why
+with
+without
+yesterday
+yet
+you
+your
+aboard
+about
+above
+according to
+across
+afore
+after
+against
+agin
+along
+alongside
+amid
+amidst
+among
+amongst
+anent
+around
+as
+aslant
+astride
+at
+athwart
+bar
+because of
+before
+behind
+below
+beneath
+beside
+besides
+between
+betwixt
+beyond
+but
+by
+circa
+despite
+down
+during
+due to
+ere
+except
+for
+from
+in
+inside
+into
+less
+like
+mid
+midst
+minus
+near
+next
+nigh
+nigher
+nighest
+notwithstanding
+of
+off
+on
+on to
+onto
+out
+out of
+outside
+over
+past
+pending
+per
+plus
+qua
+re
+round
+sans
+save
+since
+through
+throughout
+thru
+till
+to
+toward
+towards
+under
+underneath
+unlike
+until
+unto
+up
+upon
+versus
+via
+vice
+with
+within
+without
+he
+her
+herself
+hers
+him
+himself
+his
+I
+it
+its
+itself
+me
+mine
+my
+myself
+ours
+she
+their
+theirs
+them
+themselves
+they
+us
+we
+our
+ourselves
+you
+your
+yours
+yourselves
+yourself
+this
+that
+these
+those
+"
+'
+''
+(
+)
+*LRB*
+*RRB*
+<dquote>
+<ldquo>
+<lsquo>
+<rdquo>
+<rsquo>
+@
+&
+[
+]
+`
+``
+e.g.,
+{
+}
+&quot;
+&ldquo;
+&rdquo;
+-RRB-
+-LRB-
+--
+a
+about
+above
+across
+after
+afterwards
+again
+against
+all
+almost
+alone
+along
+already
+also
+although
+always
+am
+among
+amongst
+amoungst
+amount
+an
+and
+another
+any
+anyhow
+anyone
+anything
+anyway
+anywhere
+are
+around
+as
+at
+back
+be
+became
+because
+become
+becomes
+becoming
+been
+before
+beforehand
+behind
+being
+below
+beside
+besides
+between
+beyond
+bill
+both
+bottom
+but
+by
+call
+can
+cannot
+cant
+co
+computer
+con
+could
+couldnt
+cry
+de
+describe
+detail
+do
+done
+down
+due
+during
+each
+eg
+eight
+either
+eleven
+else
+elsewhere
+empty
+enough
+etc
+even
+ever
+every
+everyone
+everything
+everywhere
+except
+few
+fifteen
+fify
+fill
+find
+fire
+first
+five
+for
+former
+formerly
+forty
+found
+four
+from
+front
+full
+further
+get
+give
+go
+had
+has
+hasnt
+have
+he
+hence
+her
+here
+hereafter
+hereby
+herein
+hereupon
+hers
+herself
+him
+himself
+his
+how
+however
+hundred
+i
+ie
+if
+in
+inc
+indeed
+interest
+into
+is
+it
+its
+itself
+keep
+last
+latter
+latterly
+least
+less
+ltd
+made
+many
+may
+me
+meanwhile
+might
+mill
+mine
+more
+moreover
+most
+mostly
+move
+much
+must
+my
+myself
+name
+namely
+neither
+never
+nevertheless
+next
+nine
+no
+nobody
+none
+noone
+nor
+not
+nothing
+now
+nowhere
+of
+off
+often
+on
+once
+one
+only
+onto
+or
+other
+others
+otherwise
+our
+ours
+ourselves
+out
+over
+own
+part
+per
+perhaps
+please
+put
+rather
+re
+same
+see
+seem
+seemed
+seeming
+seems
+serious
+several
+she
+should
+show
+side
+since
+sincere
+six
+sixty
+so
+some
+somehow
+someone
+something
+sometime
+sometimes
+somewhere
+still
+such
+system
+take
+ten
+than
+that
+the
+their
+them
+themselves
+then
+thence
+there
+thereafter
+thereby
+therefore
+therein
+thereupon
+these
+they
+thick
+thin
+third
+this
+those
+though
+three
+through
+throughout
+thru
+thus
+to
+together
+too
+top
+toward
+towards
+twelve
+twenty
+two
+un
+under
+until
+up
+upon
+us
+very
+via
+was
+we
+well
+were
+what
+whatever
+when
+whence
+whenever
+where
+whereafter
+whereas
+whereby
+wherein
+whereupon
+wherever
+whether
+which
+while
+whither
+who
+whoever
+whole
+whom
+whose
+why
+will
+with
+within
+without
+would
+yet
+you
+your
+yours
+yourself
+yourselves
+ 
+	
+:
+/
+（
+>
+）
+<
+!

cpp/dict/user.dict.utf8

@@ -0,0 +1,4 @@
+云计算
+韩玉鉴赏
+蓝翔 nz
+区块链 10 nz

cpp/dict/vocab.txt

@@ -0,0 +1,114 @@
+;	1
+:	2
+,	3
+.	4
+!	5
+?	6
+—	9
+…	10
+"	11
+(	12
+)	13
+“	14
+”	15
+ 	16
+̃	17
+ʣ	18
+ʥ	19
+ʦ	20
+ʨ	21
+ᵝ	22
+ꭧ	23
+A	24
+I	25
+O	31
+Q	33
+S	35
+T	36
+W	39
+Y	41
+ᵊ	42
+a	43
+b	44
+c	45
+d	46
+e	47
+f	48
+h	50
+i	51
+j	52
+k	53
+l	54
+m	55
+n	56
+o	57
+p	58
+q	59
+r	60
+s	61
+t	62
+u	63
+v	64
+w	65
+x	66
+y	67
+z	68
+ɑ	69
+ɐ	70
+ɒ	71
+æ	72
+β	75
+ɔ	76
+ɕ	77
+ç	78
+ɖ	80
+ð	81
+ʤ	82
+ə	83
+ɚ	85
+ɛ	86
+ɜ	87
+ɟ	90
+ɡ	92
+ɥ	99
+ɨ	101
+ɪ	102
+ʝ	103
+ɯ	110
+ɰ	111
+ŋ	112
+ɳ	113
+ɲ	114
+ɴ	115
+ø	116
+ɸ	118
+θ	119
+œ	120
+ɹ	123
+ɾ	125
+ɻ	126
+ʁ	128
+ɽ	129
+ʂ	130
+ʃ	131
+ʈ	132
+ʧ	133
+ʊ	135
+ʋ	136
+ʌ	138
+ɣ	139
+ɤ	140
+χ	142
+ʎ	143
+ʒ	147
+ʔ	148
+ˈ	156
+ˌ	157
+ː	158
+ʰ	162
+ʲ	164
+↓	169
+→	171
+↗	172
+↘	173
+ᵻ	177

cpp/download_bsp.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+if [ ! -d ax650n_bsp_sdk ]; then
+  echo "clone ax650 bsp to ax650n_bsp_sdk, please wait..."
+  git clone https://github.com/AXERA-TECH/ax650n_bsp_sdk.git
+fi

cpp/main.cpp

@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <vector>
+#include <fstream>
+#include <ax_sys_api.h>
+#include <ctime>
+#include <sys/time.h>
+#include <locale>
+
+#include "utils/cmdline.hpp"
+#include "AudioFile.h"
+#include "utils/timer.hpp"
+#include "utils/logger.hpp"
+#include "Kokoro.h"
+
+
+int main(int argc, char** argv) {
+    // 设置locale为UTF-8
+    std::setlocale(LC_ALL, "en_US.UTF-8");
+
+    cmdline::parser cmd;
+    cmd.add<std::string>("axmodel_dir", 0, "model path", false, "../models");
+    cmd.add<std::string>("text", 't', "Text to be generated", false, "我想留在大家身边，从过去，一同迈向明天");
+    cmd.add<std::string>("lang", 'l', "Language code, Only support a(American English) or z(Chinese) currently", false, "z");
+    cmd.add<std::string>("voice_path", 0, "Binary voices store path", false, "./voices");
+    cmd.add<std::string>("voice_name", 'v', "Speaker voice name, check possible choices from voices/", false, "zf_xiaoxiao");
+    cmd.add<std::string>("output", 'o', "Output file path", false, "output.wav");
+    cmd.add<float>("fade_out", 'f', "Fade out ratio between sentences", false, 0.0f);
+    cmd.add<int>("max_len", 'm', "Max input token num, fixed by model, no need to change usually", false, 96);
+    cmd.parse_check(argc, argv);
+
+    // 0. get app args, can be removed from user's app
+    auto axmodel_dir = cmd.get<std::string>("axmodel_dir");
+    auto text = cmd.get<std::string>("text");
+    auto lang = cmd.get<std::string>("lang");
+    auto voice_path = cmd.get<std::string>("voice_path");
+    auto voice_name = cmd.get<std::string>("voice_name");
+    auto output = cmd.get<std::string>("output");
+    auto fade_out = cmd.get<float>("fade_out");
+    auto max_len = cmd.get<int>("max_len");
+
+    ALOGI("Args:");
+    ALOGI("axmodel_dir: %s", axmodel_dir.c_str());
+    ALOGI("text: %s", text.c_str());
+    ALOGI("lang: %s", lang.c_str());
+    ALOGI("voice_path: %s", voice_path.c_str());
+    ALOGI("voice_name: %s", voice_name.c_str());
+    ALOGI("output: %s", output.c_str());
+    ALOGI("fade_out: %.2f", fade_out);
+    ALOGI("max_len: %d", max_len);
+
+    const float SPEED = 1.0f;
+    const float PAUSE = 0.0f;
+    const int sample_rate = 24000;
+
+    int ret = AX_SYS_Init();
+    if (0 != ret) {
+        fprintf(stderr, "AX_SYS_Init failed! ret = 0x%x\n", ret);
+        return -1;
+    }
+
+#if defined(CHIP_AX650)
+    AX_ENGINE_NPU_ATTR_T npu_attr;
+    memset(&npu_attr, 0, sizeof(npu_attr));
+    npu_attr.eHardMode = static_cast<AX_ENGINE_NPU_MODE_T>(0);
+    ret = AX_ENGINE_Init(&npu_attr);
+    if (0 != ret) {
+        fprintf(stderr, "Init ax-engine failed{0x%8x}.\n", ret);
+        return -1;
+    }
+#else
+    AX_ENGINE_NPU_ATTR_T npu_attr;
+    memset(&npu_attr, 0, sizeof(npu_attr));
+    npu_attr.eHardMode = AX_ENGINE_VIRTUAL_NPU_DISABLE;
+    ret = AX_ENGINE_Init(&npu_attr);
+    if (0 != ret) {
+        fprintf(stderr, "Init ax-engine failed{0x%8x}.\n", ret);
+        return -1;
+    }
+#endif   
+
+    Timer timer;
+
+    timer.start();
+    Kokoro kokoro;
+    if (!kokoro.init(axmodel_dir, max_len, voice_path, voice_name)) {
+        ALOGE("Init kokoro failed!");
+        return -1;
+    }
+    timer.stop();
+    ALOGI("Init kokoro take %.4f seconds", timer.elapsed<std::chrono::seconds>());
+
+    timer.start();
+    std::vector<float> audio;
+    if (!kokoro.tts(text, lang, voice_name, SPEED, sample_rate, fade_out, PAUSE, audio)) {
+        printf("run whisper failed!\n");
+        return -1;
+    }
+    timer.stop();
+
+    AudioFile<float> audio_file;
+    std::vector<std::vector<float> > audio_samples{audio};
+    audio_file.setAudioBuffer(audio_samples);
+    audio_file.setSampleRate(sample_rate);
+    if (!audio_file.save(output)) {
+        ALOGE("Save audio file failed!\n");
+        return -1;
+    }
+
+    ALOGI("Audio save to %s", output.c_str());
+
+    float elapsed = timer.elapsed<std::chrono::seconds>();
+    float duration = audio.size() * 1.f / sample_rate;
+    ALOGI("RTF: %.4f, process_time: %.4f seconds, audio duration: %.2f seconds\n", elapsed / duration, elapsed, duration);
+    return 0;
+}

cpp/scripts/compare.py

@@ -0,0 +1,14 @@
+import numpy as np
+import sys
+
+def cos_sim(A, B):
+    dot_product = np.dot(A, B)
+    norm_A = np.linalg.norm(A)
+    norm_B = np.linalg.norm(B)
+    cosine_sim = dot_product / (norm_A * norm_B)
+    return cosine_sim
+
+A = np.fromfile(sys.argv[1], dtype=np.int32)
+B = np.fromfile(sys.argv[2], dtype=np.int32)
+np.testing.assert_allclose(A, B)
+print(cos_sim(A, B))

cpp/scripts/convert_dict.py

@@ -0,0 +1,122 @@
+import os
+
+# Tone mapping dictionary
+TONE_MAP = {
+    'ā': ('a', 1), 'á': ('a', 2), 'ǎ': ('a', 3), 'à': ('a', 4),
+    'ē': ('e', 1), 'é': ('e', 2), 'ě': ('e', 3), 'è': ('e', 4),
+    'ī': ('i', 1), 'í': ('i', 2), 'ǐ': ('i', 3), 'ì': ('i', 4),
+    'ō': ('o', 1), 'ó': ('o', 2), 'ǒ': ('o', 3), 'ò': ('o', 4),
+    'ū': ('u', 1), 'ú': ('u', 2), 'ǔ': ('u', 3), 'ù': ('u', 4),
+    'ü': ('v', 0), 'ǖ': ('v', 1), 'ǘ': ('v', 2), 'ǚ': ('v', 3), 'ǜ': ('v', 4),
+    'ń': ('n', 2), 'ň': ('n', 3), 'ǹ': ('n', 4), 'ḿ': ('m', 2),
+    'm̀': ('m', 4)
+}
+
+def convert_tone(pinyin):
+    if not pinyin: return ""
+    tone = 5  # Default neutral tone
+    base = ""
+    
+    for char in pinyin:
+        if char in TONE_MAP:
+            base_char, t = TONE_MAP[char]
+            base += base_char
+            tone = t
+        else:
+            base += char
+            
+    if tone != 5:
+        return f"{base}{tone}"
+    else:
+        return f"{base}5"
+
+def process_char_dict(input_file, out_file):
+    print(f"Processing char dict: {input_file} -> {out_file}")
+    with open(input_file, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+    
+    new_lines = []
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('#'):
+            new_lines.append(line)
+            continue
+        
+        # Expected format: U+XXXX: pinyin,pinyin # char
+        if ':' not in line:
+            new_lines.append(line)
+            continue
+            
+        part1, part2 = line.split(':', 1) # U+XXXX, " pinyin,pinyin # char"
+        
+        char_comment = ""
+        if '#' in part2:
+            pinyins_part, char_comment = part2.split('#', 1)
+            char_comment = " #" + char_comment
+        else:
+            pinyins_part = part2
+            
+        # Split by comma for polyphones
+        pinyins = [p.strip() for p in pinyins_part.split(',')]
+        numeric_pinyins = [convert_tone(p) for p in pinyins if p]
+        
+        new_pinyins_str = ",".join(numeric_pinyins)
+        
+        # Reconstruct line
+        new_line = f"{part1}: {new_pinyins_str}{char_comment}"
+        new_lines.append(new_line)
+
+    with open(out_file, 'w', encoding='utf-8') as f:
+        f.write("\n".join(new_lines))
+    print(f"Done. Wrote {len(new_lines)} lines.")
+
+def process_phrase_dict(input_file, out_file):
+    print(f"Processing phrase dict: {input_file} -> {out_file}")
+    with open(input_file, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    phrase_entries = []
+
+    for line in lines:
+        line = line.strip()
+        if not line or ':' not in line:
+            continue
+            
+        word, pinyins_str = line.split(':', 1)
+        word = word.strip()
+        pinyins = [p.strip() for p in pinyins_str.split()]
+        
+        # Skip single char entries in phrase dict if any
+        if len(word) == 1:
+            continue
+
+        numeric_pinyins = [convert_tone(p) for p in pinyins]
+        pinyins_joined = " ".join(numeric_pinyins)
+
+        phrase_entries.append(f"{word}: {pinyins_joined}")
+
+    with open(out_file, 'w', encoding='utf-8') as f:
+        f.write("\n".join(phrase_entries))
+    print(f"Done. Wrote {len(phrase_entries)} phrases.")
+
+if __name__ == "__main__":
+    # Input files
+    input_char_path = r"g:\work\misaki\cpp\dict2\pinyin.txt"
+    input_phrase_path = r"g:\work\misaki\cpp\dict2\large_pinyin.txt"
+    
+    # Output directory
+    output_dir = r"g:\work\misaki\cpp\dict" 
+    
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Process both
+    if os.path.exists(input_char_path):
+        process_char_dict(input_char_path, os.path.join(output_dir, "pinyin.txt"))
+    else:
+        print(f"Warning: {input_char_path} not found.")
+        
+    if os.path.exists(input_phrase_path):
+        process_phrase_dict(input_phrase_path, os.path.join(output_dir, "pinyin_phrase.txt"))
+    else:
+        print(f"Warning: {input_phrase_path} not found.")

cpp/scripts/export_vocab.py

@@ -0,0 +1,38 @@
+import json
+import sys
+import os
+from pathlib import Path
+
+# Add src to sys.path to import kokoro_onnx
+sys.path.append(str(Path(__file__).parent.parent / "src"))
+
+try:
+    from kokoro_onnx.config import get_vocab
+except ImportError:
+    print("Error: Could not import kokoro_onnx.config. Make sure you are in the root of the repo.")
+    sys.exit(1)
+
+def export_vocab(output_path):
+    try:
+        vocab = get_vocab()
+    except Exception as e:
+        print(f"Error loading vocab: {e}")
+        return
+
+    print(f"Loaded {len(vocab)} tokens.")
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        for token, idx in vocab.items():
+            # Escape special characters to keep the file parseable line by line
+            # We use tab as separator
+            safe_token = token.replace('\n', '\\n').replace('\r', '\\r').replace('\t', '\\t')
+            f.write(f"{safe_token}\t{idx}\n")
+    
+    print(f"Exported vocab to {output_path}")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python export_vocab.py <output_vocab.txt>")
+        sys.exit(1)
+    
+    export_vocab(sys.argv[1])

cpp/scripts/export_voices.py

@@ -0,0 +1,18 @@
+import numpy as np
+import struct
+import sys
+import os
+import torch
+import glob
+from tqdm import tqdm
+
+def export_voices(voices_path, output_path):
+    os.makedirs(output_path, exist_ok=True)
+    for pt_path in tqdm(glob.glob(voices_path + "/*.pt")):
+        voice = torch.load(pt_path, weights_only=True)
+        voice_name = os.path.splitext(os.path.basename(pt_path))[0]
+        voice_npy = voice.numpy()
+        voice_npy.tofile(os.path.join(output_path, voice_name + ".bin"))
+
+if __name__ == "__main__":
+    export_voices("../checkpoints/voices", "voices")

cpp/src/AudioFile.h

@@ -0,0 +1,1293 @@
+//=======================================================================
+/** @file AudioFile.h
+ *  @author Adam Stark
+ *  @copyright Copyright (C) 2017  Adam Stark
+ *
+ * This file is part of the 'AudioFile' library
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+//=======================================================================
+
+#ifndef _AS_AudioFile_h
+#define _AS_AudioFile_h
+
+#include <iostream>
+#include <vector>
+#include <cassert>
+#include <string>
+#include <cstring>
+#include <fstream>
+#include <unordered_map>
+#include <iterator>
+#include <algorithm>
+
+// disable some warnings on Windows
+#if defined (_MSC_VER)
+    __pragma(warning (push))
+    __pragma(warning (disable : 4244))
+    __pragma(warning (disable : 4457))
+    __pragma(warning (disable : 4458))
+    __pragma(warning (disable : 4389))
+    __pragma(warning (disable : 4996))
+#elif defined (__GNUC__)
+    _Pragma("GCC diagnostic push")
+    _Pragma("GCC diagnostic ignored \"-Wconversion\"")
+    _Pragma("GCC diagnostic ignored \"-Wsign-compare\"")
+    _Pragma("GCC diagnostic ignored \"-Wshadow\"")
+#endif
+
+//=============================================================
+/** The different types of audio file, plus some other types to 
+ * indicate a failure to load a file, or that one hasn't been
+ * loaded yet
+ */
+enum class AudioFileFormat
+{
+    Error,
+    NotLoaded,
+    Wave,
+    Aiff
+};
+
+//=============================================================
+template <class T>
+class AudioFile
+{
+public:
+    
+    //=============================================================
+    typedef std::vector<std::vector<T> > AudioBuffer;
+    
+    //=============================================================
+    /** Constructor */
+    AudioFile();
+    
+    /** Constructor, using a given file path to load a file */
+    AudioFile (std::string filePath);
+        
+    //=============================================================
+    /** Loads an audio file from a given file path.
+     * @Returns true if the file was successfully loaded
+     */
+    bool load (std::string filePath);
+    
+    /** Saves an audio file to a given file path.
+     * @Returns true if the file was successfully saved
+     */
+    bool save (std::string filePath, AudioFileFormat format = AudioFileFormat::Wave);
+        
+    //=============================================================
+    /** @Returns the sample rate */
+    uint32_t getSampleRate() const;
+    
+    /** @Returns the number of audio channels in the buffer */
+    int getNumChannels() const;
+
+    /** @Returns true if the audio file is mono */
+    bool isMono() const;
+    
+    /** @Returns true if the audio file is stereo */
+    bool isStereo() const;
+    
+    /** @Returns the bit depth of each sample */
+    int getBitDepth() const;
+    
+    /** @Returns the number of samples per channel */
+    int getNumSamplesPerChannel() const;
+    
+    /** @Returns the length in seconds of the audio file based on the number of samples and sample rate */
+    double getLengthInSeconds() const;
+    
+    /** Prints a summary of the audio file to the console */
+    void printSummary() const;
+    
+    //=============================================================
+    
+    /** Set the audio buffer for this AudioFile by copying samples from another buffer.
+     * @Returns true if the buffer was copied successfully.
+     */
+    bool setAudioBuffer (AudioBuffer& newBuffer);
+    
+    /** Sets the audio buffer to a given number of channels and number of samples per channel. This will try to preserve
+     * the existing audio, adding zeros to any new channels or new samples in a given channel.
+     */
+    void setAudioBufferSize (int numChannels, int numSamples);
+    
+    /** Sets the number of samples per channel in the audio buffer. This will try to preserve
+     * the existing audio, adding zeros to new samples in a given channel if the number of samples is increased.
+     */
+    void setNumSamplesPerChannel (int numSamples);
+    
+    /** Sets the number of channels. New channels will have the correct number of samples and be initialised to zero */
+    void setNumChannels (int numChannels);
+    
+    /** Sets the bit depth for the audio file. If you use the save() function, this bit depth rate will be used */
+    void setBitDepth (int numBitsPerSample);
+    
+    /** Sets the sample rate for the audio file. If you use the save() function, this sample rate will be used */
+    void setSampleRate (uint32_t newSampleRate);
+    
+    //=============================================================
+    /** Sets whether the library should log error messages to the console. By default this is true */
+    void shouldLogErrorsToConsole (bool logErrors);
+    
+    //=============================================================
+    /** A vector of vectors holding the audio samples for the AudioFile. You can 
+     * access the samples by channel and then by sample index, i.e:
+     *
+     *      samples[channel][sampleIndex]
+     */
+    AudioBuffer samples;
+    
+    //=============================================================
+    /** An optional iXML chunk that can be added to the AudioFile. 
+     */
+    std::string iXMLChunk;
+    
+private:
+    
+    //=============================================================
+    enum class Endianness
+    {
+        LittleEndian,
+        BigEndian
+    };
+    
+    //=============================================================
+    AudioFileFormat determineAudioFileFormat (std::vector<uint8_t>& fileData);
+    bool decodeWaveFile (std::vector<uint8_t>& fileData);
+    bool decodeAiffFile (std::vector<uint8_t>& fileData);
+    
+    //=============================================================
+    bool saveToWaveFile (std::string filePath);
+    bool saveToAiffFile (std::string filePath);
+    
+    //=============================================================
+    void clearAudioBuffer();
+    
+    //=============================================================
+    int32_t fourBytesToInt (std::vector<uint8_t>& source, int startIndex, Endianness endianness = Endianness::LittleEndian);
+    int16_t twoBytesToInt (std::vector<uint8_t>& source, int startIndex, Endianness endianness = Endianness::LittleEndian);
+    int getIndexOfString (std::vector<uint8_t>& source, std::string s);
+    int getIndexOfChunk (std::vector<uint8_t>& source, const std::string& chunkHeaderID, int startIndex, Endianness endianness = Endianness::LittleEndian);
+    
+    //=============================================================
+    T sixteenBitIntToSample (int16_t sample);
+    int16_t sampleToSixteenBitInt (T sample);
+    
+    //=============================================================
+    uint8_t sampleToSingleByte (T sample);
+    T singleByteToSample (uint8_t sample);
+    
+    uint32_t getAiffSampleRate (std::vector<uint8_t>& fileData, int sampleRateStartIndex);
+    bool tenByteMatch (std::vector<uint8_t>& v1, int startIndex1, std::vector<uint8_t>& v2, int startIndex2);
+    void addSampleRateToAiffData (std::vector<uint8_t>& fileData, uint32_t sampleRate);
+    T clamp (T v1, T minValue, T maxValue);
+    
+    //=============================================================
+    void addStringToFileData (std::vector<uint8_t>& fileData, std::string s);
+    void addInt32ToFileData (std::vector<uint8_t>& fileData, int32_t i, Endianness endianness = Endianness::LittleEndian);
+    void addInt16ToFileData (std::vector<uint8_t>& fileData, int16_t i, Endianness endianness = Endianness::LittleEndian);
+    
+    //=============================================================
+    bool writeDataToFile (std::vector<uint8_t>& fileData, std::string filePath);
+    
+    //=============================================================
+    void reportError (std::string errorMessage);
+    
+    //=============================================================
+    AudioFileFormat audioFileFormat;
+    uint32_t sampleRate;
+    int bitDepth;
+    bool logErrorsToConsole {true};
+};
+
+
+//=============================================================
+// Pre-defined 10-byte representations of common sample rates
+static std::unordered_map <uint32_t, std::vector<uint8_t>> aiffSampleRateTable = {
+    {8000, {64, 11, 250, 0, 0, 0, 0, 0, 0, 0}},
+    {11025, {64, 12, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {16000, {64, 12, 250, 0, 0, 0, 0, 0, 0, 0}},
+    {22050, {64, 13, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {32000, {64, 13, 250, 0, 0, 0, 0, 0, 0, 0}},
+    {37800, {64, 14, 147, 168, 0, 0, 0, 0, 0, 0}},
+    {44056, {64, 14, 172, 24, 0, 0, 0, 0, 0, 0}},
+    {44100, {64, 14, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {47250, {64, 14, 184, 146, 0, 0, 0, 0, 0, 0}},
+    {48000, {64, 14, 187, 128, 0, 0, 0, 0, 0, 0}},
+    {50000, {64, 14, 195, 80, 0, 0, 0, 0, 0, 0}},
+    {50400, {64, 14, 196, 224, 0, 0, 0, 0, 0, 0}},
+    {88200, {64, 15, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {96000, {64, 15, 187, 128, 0, 0, 0, 0, 0, 0}},
+    {176400, {64, 16, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {192000, {64, 16, 187, 128, 0, 0, 0, 0, 0, 0}},
+    {352800, {64, 17, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {2822400, {64, 20, 172, 68, 0, 0, 0, 0, 0, 0}},
+    {5644800, {64, 21, 172, 68, 0, 0, 0, 0, 0, 0}}
+};
+
+//=============================================================
+enum WavAudioFormat
+{
+    PCM = 0x0001,
+    IEEEFloat = 0x0003,
+    ALaw = 0x0006,
+    MULaw = 0x0007,
+    Extensible = 0xFFFE
+};
+
+//=============================================================
+enum AIFFAudioFormat
+{
+    Uncompressed,
+    Compressed,
+    Error
+};
+
+//=============================================================
+/* IMPLEMENTATION */
+//=============================================================
+
+//=============================================================
+template <class T>
+AudioFile<T>::AudioFile()
+{
+    static_assert(std::is_floating_point<T>::value, "ERROR: This version of AudioFile only supports floating point sample formats");
+
+    bitDepth = 16;
+    sampleRate = 44100;
+    samples.resize (1);
+    samples[0].resize (0);
+    audioFileFormat = AudioFileFormat::NotLoaded;
+}
+
+//=============================================================
+template <class T>
+AudioFile<T>::AudioFile (std::string filePath)
+ :  AudioFile<T>()
+{
+    load (filePath);
+}
+
+//=============================================================
+template <class T>
+uint32_t AudioFile<T>::getSampleRate() const
+{
+    return sampleRate;
+}
+
+//=============================================================
+template <class T>
+int AudioFile<T>::getNumChannels() const
+{
+    return (int)samples.size();
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::isMono() const
+{
+    return getNumChannels() == 1;
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::isStereo() const
+{
+    return getNumChannels() == 2;
+}
+
+//=============================================================
+template <class T>
+int AudioFile<T>::getBitDepth() const
+{
+    return bitDepth;
+}
+
+//=============================================================
+template <class T>
+int AudioFile<T>::getNumSamplesPerChannel() const
+{
+    if (samples.size() > 0)
+        return (int) samples[0].size();
+    else
+        return 0;
+}
+
+//=============================================================
+template <class T>
+double AudioFile<T>::getLengthInSeconds() const
+{
+    return (double)getNumSamplesPerChannel() / (double)sampleRate;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::printSummary() const
+{
+    std::cout << "|======================================|" << std::endl;
+    std::cout << "Num Channels: " << getNumChannels() << std::endl;
+    std::cout << "Num Samples Per Channel: " << getNumSamplesPerChannel() << std::endl;
+    std::cout << "Sample Rate: " << sampleRate << std::endl;
+    std::cout << "Bit Depth: " << bitDepth << std::endl;
+    std::cout << "Length in Seconds: " << getLengthInSeconds() << std::endl;
+    std::cout << "|======================================|" << std::endl;
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::setAudioBuffer (AudioBuffer& newBuffer)
+{
+    int numChannels = (int)newBuffer.size();
+    
+    if (numChannels <= 0)
+    {
+        assert (false && "The buffer your are trying to use has no channels");
+        return false;
+    }
+    
+    size_t numSamples = newBuffer[0].size();
+    
+    // set the number of channels
+    samples.resize (newBuffer.size());
+    
+    for (int k = 0; k < getNumChannels(); k++)
+    {
+        assert (newBuffer[k].size() == numSamples);
+        
+        samples[k].resize (numSamples);
+        
+        for (size_t i = 0; i < numSamples; i++)
+        {
+            samples[k][i] = newBuffer[k][i];
+        }
+    }
+    
+    return true;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::setAudioBufferSize (int numChannels, int numSamples)
+{
+    samples.resize (numChannels);
+    setNumSamplesPerChannel (numSamples);
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::setNumSamplesPerChannel (int numSamples)
+{
+    int originalSize = getNumSamplesPerChannel();
+    
+    for (int i = 0; i < getNumChannels();i++)
+    {
+        samples[i].resize (numSamples);
+        
+        // set any new samples to zero
+        if (numSamples > originalSize)
+            std::fill (samples[i].begin() + originalSize, samples[i].end(), (T)0.);
+    }
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::setNumChannels (int numChannels)
+{
+    int originalNumChannels = getNumChannels();
+    int originalNumSamplesPerChannel = getNumSamplesPerChannel();
+    
+    samples.resize (numChannels);
+    
+    // make sure any new channels are set to the right size
+    // and filled with zeros
+    if (numChannels > originalNumChannels)
+    {
+        for (int i = originalNumChannels; i < numChannels; i++)
+        {
+            samples[i].resize (originalNumSamplesPerChannel);
+            std::fill (samples[i].begin(), samples[i].end(), (T)0.);
+        }
+    }
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::setBitDepth (int numBitsPerSample)
+{
+    bitDepth = numBitsPerSample;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::setSampleRate (uint32_t newSampleRate)
+{
+    sampleRate = newSampleRate;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::shouldLogErrorsToConsole (bool logErrors)
+{
+    logErrorsToConsole = logErrors;
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::load (std::string filePath)
+{
+    std::ifstream file (filePath, std::ios::binary);
+    
+    // check the file exists
+    if (! file.good())
+    {
+        reportError ("ERROR: File doesn't exist or otherwise can't load file\n"  + filePath);
+        return false;
+    }
+    
+    std::vector<uint8_t> fileData;
+
+	file.unsetf (std::ios::skipws);
+
+	file.seekg (0, std::ios::end);
+	size_t length = file.tellg();
+	file.seekg (0, std::ios::beg);
+
+	// allocate
+	fileData.resize (length);
+
+	file.read(reinterpret_cast<char*> (fileData.data()), length);
+	file.close();
+
+	if (file.gcount() != length)
+	{
+		reportError ("ERROR: Couldn't read entire file\n" + filePath);
+		return false;
+	}
+    
+    // get audio file format
+    audioFileFormat = determineAudioFileFormat (fileData);
+    
+    if (audioFileFormat == AudioFileFormat::Wave)
+    {
+        return decodeWaveFile (fileData);
+    }
+    else if (audioFileFormat == AudioFileFormat::Aiff)
+    {
+        return decodeAiffFile (fileData);
+    }
+    else
+    {
+        reportError ("Audio File Type: Error");
+        return false;
+    }
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::decodeWaveFile (std::vector<uint8_t>& fileData)
+{
+    // -----------------------------------------------------------
+    // HEADER CHUNK
+    std::string headerChunkID (fileData.begin(), fileData.begin() + 4);
+    //int32_t fileSizeInBytes = fourBytesToInt (fileData, 4) + 8;
+    std::string format (fileData.begin() + 8, fileData.begin() + 12);
+    
+    // -----------------------------------------------------------
+    // try and find the start points of key chunks
+    int indexOfDataChunk = getIndexOfChunk (fileData, "data", 12);
+    int indexOfFormatChunk = getIndexOfChunk (fileData, "fmt ", 12);
+    int indexOfXMLChunk = getIndexOfChunk (fileData, "iXML", 12);
+    
+    // if we can't find the data or format chunks, or the IDs/formats don't seem to be as expected
+    // then it is unlikely we'll able to read this file, so abort
+    if (indexOfDataChunk == -1 || indexOfFormatChunk == -1 || headerChunkID != "RIFF" || format != "WAVE")
+    {
+        reportError ("ERROR: this doesn't seem to be a valid .WAV file");
+        return false;
+    }
+    
+    // -----------------------------------------------------------
+    // FORMAT CHUNK
+    int f = indexOfFormatChunk;
+    std::string formatChunkID (fileData.begin() + f, fileData.begin() + f + 4);
+    //int32_t formatChunkSize = fourBytesToInt (fileData, f + 4);
+    uint16_t audioFormat = twoBytesToInt (fileData, f + 8);
+    uint16_t numChannels = twoBytesToInt (fileData, f + 10);
+    sampleRate = (uint32_t) fourBytesToInt (fileData, f + 12);
+    uint32_t numBytesPerSecond = fourBytesToInt (fileData, f + 16);
+    uint16_t numBytesPerBlock = twoBytesToInt (fileData, f + 20);
+    bitDepth = (int) twoBytesToInt (fileData, f + 22);
+    
+    uint16_t numBytesPerSample = static_cast<uint16_t> (bitDepth) / 8;
+    
+    // check that the audio format is PCM or Float or extensible
+    if (audioFormat != WavAudioFormat::PCM && audioFormat != WavAudioFormat::IEEEFloat && audioFormat != WavAudioFormat::Extensible)
+    {
+        reportError ("ERROR: this .WAV file is encoded in a format that this library does not support at present");
+        return false;
+    }
+    
+    // check the number of channels is mono or stereo
+    if (numChannels < 1 || numChannels > 128)
+    {
+        reportError ("ERROR: this WAV file seems to be an invalid number of channels (or corrupted?)");
+        return false;
+    }
+    
+    // check header data is consistent
+    if (numBytesPerSecond != static_cast<uint32_t> ((numChannels * sampleRate * bitDepth) / 8) || numBytesPerBlock != (numChannels * numBytesPerSample))
+    {
+        reportError ("ERROR: the header data in this WAV file seems to be inconsistent");
+        return false;
+    }
+    
+    // check bit depth is either 8, 16, 24 or 32 bit
+    if (bitDepth != 8 && bitDepth != 16 && bitDepth != 24 && bitDepth != 32)
+    {
+        reportError ("ERROR: this file has a bit depth that is not 8, 16, 24 or 32 bits");
+        return false;
+    }
+    
+    // -----------------------------------------------------------
+    // DATA CHUNK
+    int d = indexOfDataChunk;
+    std::string dataChunkID (fileData.begin() + d, fileData.begin() + d + 4);
+    int32_t dataChunkSize = fourBytesToInt (fileData, d + 4);
+    
+    int numSamples = dataChunkSize / (numChannels * bitDepth / 8);
+    int samplesStartIndex = indexOfDataChunk + 8;
+    
+    clearAudioBuffer();
+    samples.resize (numChannels);
+    
+    for (int i = 0; i < numSamples; i++)
+    {
+        for (int channel = 0; channel < numChannels; channel++)
+        {
+            int sampleIndex = samplesStartIndex + (numBytesPerBlock * i) + channel * numBytesPerSample;
+            
+            if ((sampleIndex + (bitDepth / 8) - 1) >= fileData.size())
+            {
+                reportError ("ERROR: read file error as the metadata indicates more samples than there are in the file data");
+                return false;
+            }
+            
+            if (bitDepth == 8)
+            {
+                T sample = singleByteToSample (fileData[sampleIndex]);
+                samples[channel].push_back (sample);
+            }
+            else if (bitDepth == 16)
+            {
+                int16_t sampleAsInt = twoBytesToInt (fileData, sampleIndex);
+                T sample = sixteenBitIntToSample (sampleAsInt);
+                samples[channel].push_back (sample);
+            }
+            else if (bitDepth == 24)
+            {
+                int32_t sampleAsInt = 0;
+                sampleAsInt = (fileData[sampleIndex + 2] << 16) | (fileData[sampleIndex + 1] << 8) | fileData[sampleIndex];
+                
+                if (sampleAsInt & 0x800000) //  if the 24th bit is set, this is a negative number in 24-bit world
+                    sampleAsInt = sampleAsInt | ~0xFFFFFF; // so make sure sign is extended to the 32 bit float
+
+                T sample = (T)sampleAsInt / (T)8388608.;
+                samples[channel].push_back (sample);
+            }
+            else if (bitDepth == 32)
+            {
+                int32_t sampleAsInt = fourBytesToInt (fileData, sampleIndex);
+                T sample;
+                
+                if (audioFormat == WavAudioFormat::IEEEFloat)
+                    sample = (T)reinterpret_cast<float&> (sampleAsInt);
+                else // assume PCM
+                    sample = (T) sampleAsInt / static_cast<float> (std::numeric_limits<std::int32_t>::max());
+                
+                samples[channel].push_back (sample);
+            }
+            else
+            {
+                assert (false);
+            }
+        }
+    }
+
+    // -----------------------------------------------------------
+    // iXML CHUNK
+    if (indexOfXMLChunk != -1)
+    {
+        int32_t chunkSize = fourBytesToInt (fileData, indexOfXMLChunk + 4);
+        iXMLChunk = std::string ((const char*) &fileData[indexOfXMLChunk + 8], chunkSize);
+    }
+
+    return true;
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::decodeAiffFile (std::vector<uint8_t>& fileData)
+{
+    // -----------------------------------------------------------
+    // HEADER CHUNK
+    std::string headerChunkID (fileData.begin(), fileData.begin() + 4);
+    //int32_t fileSizeInBytes = fourBytesToInt (fileData, 4, Endianness::BigEndian) + 8;
+    std::string format (fileData.begin() + 8, fileData.begin() + 12);
+    
+    int audioFormat = format == "AIFF" ? AIFFAudioFormat::Uncompressed : format == "AIFC" ? AIFFAudioFormat::Compressed : AIFFAudioFormat::Error;
+    
+    // -----------------------------------------------------------
+    // try and find the start points of key chunks
+    int indexOfCommChunk = getIndexOfChunk (fileData, "COMM", 12, Endianness::BigEndian);
+    int indexOfSoundDataChunk = getIndexOfChunk (fileData, "SSND", 12, Endianness::BigEndian);
+    int indexOfXMLChunk = getIndexOfChunk (fileData, "iXML", 12, Endianness::BigEndian);
+    
+    // if we can't find the data or format chunks, or the IDs/formats don't seem to be as expected
+    // then it is unlikely we'll able to read this file, so abort
+    if (indexOfSoundDataChunk == -1 || indexOfCommChunk == -1 || headerChunkID != "FORM" || audioFormat == AIFFAudioFormat::Error)
+    {
+        reportError ("ERROR: this doesn't seem to be a valid AIFF file");
+        return false;
+    }
+
+    // -----------------------------------------------------------
+    // COMM CHUNK
+    int p = indexOfCommChunk;
+    std::string commChunkID (fileData.begin() + p, fileData.begin() + p + 4);
+    //int32_t commChunkSize = fourBytesToInt (fileData, p + 4, Endianness::BigEndian);
+    int16_t numChannels = twoBytesToInt (fileData, p + 8, Endianness::BigEndian);
+    int32_t numSamplesPerChannel = fourBytesToInt (fileData, p + 10, Endianness::BigEndian);
+    bitDepth = (int) twoBytesToInt (fileData, p + 14, Endianness::BigEndian);
+    sampleRate = getAiffSampleRate (fileData, p + 16);
+    
+    // check the sample rate was properly decoded
+    if (sampleRate == 0)
+    {
+        reportError ("ERROR: this AIFF file has an unsupported sample rate");
+        return false;
+    }
+    
+    // check the number of channels is mono or stereo
+    if (numChannels < 1 ||numChannels > 2)
+    {
+        reportError ("ERROR: this AIFF file seems to be neither mono nor stereo (perhaps multi-track, or corrupted?)");
+        return false;
+    }
+    
+    // check bit depth is either 8, 16, 24 or 32-bit
+    if (bitDepth != 8 && bitDepth != 16 && bitDepth != 24 && bitDepth != 32)
+    {
+        reportError ("ERROR: this file has a bit depth that is not 8, 16, 24 or 32 bits");
+        return false;
+    }
+    
+    // -----------------------------------------------------------
+    // SSND CHUNK
+    int s = indexOfSoundDataChunk;
+    std::string soundDataChunkID (fileData.begin() + s, fileData.begin() + s + 4);
+    int32_t soundDataChunkSize = fourBytesToInt (fileData, s + 4, Endianness::BigEndian);
+    int32_t offset = fourBytesToInt (fileData, s + 8, Endianness::BigEndian);
+    //int32_t blockSize = fourBytesToInt (fileData, s + 12, Endianness::BigEndian);
+    
+    int numBytesPerSample = bitDepth / 8;
+    int numBytesPerFrame = numBytesPerSample * numChannels;
+    int totalNumAudioSampleBytes = numSamplesPerChannel * numBytesPerFrame;
+    int samplesStartIndex = s + 16 + (int)offset;
+        
+    // sanity check the data
+    if ((soundDataChunkSize - 8) != totalNumAudioSampleBytes || totalNumAudioSampleBytes > static_cast<long>(fileData.size() - samplesStartIndex))
+    {
+        reportError ("ERROR: the metadatafor this file doesn't seem right");
+        return false;
+    }
+    
+    clearAudioBuffer();
+    samples.resize (numChannels);
+    
+    for (int i = 0; i < numSamplesPerChannel; i++)
+    {
+        for (int channel = 0; channel < numChannels; channel++)
+        {
+            int sampleIndex = samplesStartIndex + (numBytesPerFrame * i) + channel * numBytesPerSample;
+            
+            if ((sampleIndex + (bitDepth / 8) - 1) >= fileData.size())
+            {
+                reportError ("ERROR: read file error as the metadata indicates more samples than there are in the file data");
+                return false;
+            }
+            
+            if (bitDepth == 8)
+            {
+                int8_t sampleAsSigned8Bit = (int8_t)fileData[sampleIndex];
+                T sample = (T)sampleAsSigned8Bit / (T)128.;
+                samples[channel].push_back (sample);
+            }
+            else if (bitDepth == 16)
+            {
+                int16_t sampleAsInt = twoBytesToInt (fileData, sampleIndex, Endianness::BigEndian);
+                T sample = sixteenBitIntToSample (sampleAsInt);
+                samples[channel].push_back (sample);
+            }
+            else if (bitDepth == 24)
+            {
+                int32_t sampleAsInt = 0;
+                sampleAsInt = (fileData[sampleIndex] << 16) | (fileData[sampleIndex + 1] << 8) | fileData[sampleIndex + 2];
+                
+                if (sampleAsInt & 0x800000) //  if the 24th bit is set, this is a negative number in 24-bit world
+                    sampleAsInt = sampleAsInt | ~0xFFFFFF; // so make sure sign is extended to the 32 bit float
+                
+                T sample = (T)sampleAsInt / (T)8388608.;
+                samples[channel].push_back (sample);
+            }
+            else if (bitDepth == 32)
+            {
+                int32_t sampleAsInt = fourBytesToInt (fileData, sampleIndex, Endianness::BigEndian);
+                T sample;
+                
+                if (audioFormat == AIFFAudioFormat::Compressed)
+                    sample = (T)reinterpret_cast<float&> (sampleAsInt);
+                else // assume uncompressed
+                    sample = (T) sampleAsInt / static_cast<float> (std::numeric_limits<std::int32_t>::max());
+                    
+                samples[channel].push_back (sample);
+            }
+            else
+            {
+                assert (false);
+            }
+        }
+    }
+
+    // -----------------------------------------------------------
+    // iXML CHUNK
+    if (indexOfXMLChunk != -1)
+    {
+        int32_t chunkSize = fourBytesToInt (fileData, indexOfXMLChunk + 4);
+        iXMLChunk = std::string ((const char*) &fileData[indexOfXMLChunk + 8], chunkSize);
+    }
+    
+    return true;
+}
+
+//=============================================================
+template <class T>
+uint32_t AudioFile<T>::getAiffSampleRate (std::vector<uint8_t>& fileData, int sampleRateStartIndex)
+{
+    for (auto it : aiffSampleRateTable)
+    {
+        if (tenByteMatch (fileData, sampleRateStartIndex, it.second, 0))
+            return it.first;
+    }
+    
+    return 0;
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::tenByteMatch (std::vector<uint8_t>& v1, int startIndex1, std::vector<uint8_t>& v2, int startIndex2)
+{
+    for (int i = 0; i < 10; i++)
+    {
+        if (v1[startIndex1 + i] != v2[startIndex2 + i])
+            return false;
+    }
+    
+    return true;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::addSampleRateToAiffData (std::vector<uint8_t>& fileData, uint32_t sampleRate)
+{
+    if (aiffSampleRateTable.count (sampleRate) > 0)
+    {
+        for (int i = 0; i < 10; i++)
+            fileData.push_back (aiffSampleRateTable[sampleRate][i]);
+    }
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::save (std::string filePath, AudioFileFormat format)
+{
+    if (format == AudioFileFormat::Wave)
+    {
+        return saveToWaveFile (filePath);
+    }
+    else if (format == AudioFileFormat::Aiff)
+    {
+        return saveToAiffFile (filePath);
+    }
+    
+    return false;
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::saveToWaveFile (std::string filePath)
+{
+    std::vector<uint8_t> fileData;
+    
+    int32_t dataChunkSize = getNumSamplesPerChannel() * (getNumChannels() * bitDepth / 8);
+    int16_t audioFormat = bitDepth == 32 ? WavAudioFormat::IEEEFloat : WavAudioFormat::PCM;
+    int32_t formatChunkSize = audioFormat == WavAudioFormat::PCM ? 16 : 18;
+    int32_t iXMLChunkSize = static_cast<int32_t> (iXMLChunk.size());
+    
+    // -----------------------------------------------------------
+    // HEADER CHUNK
+    addStringToFileData (fileData, "RIFF");
+    
+    // The file size in bytes is the header chunk size (4, not counting RIFF and WAVE) + the format
+    // chunk size (24) + the metadata part of the data chunk plus the actual data chunk size
+    int32_t fileSizeInBytes = 4 + formatChunkSize + 8 + 8 + dataChunkSize;
+    if (iXMLChunkSize > 0)
+    {
+        fileSizeInBytes += (8 + iXMLChunkSize);
+    }
+
+    addInt32ToFileData (fileData, fileSizeInBytes);
+    
+    addStringToFileData (fileData, "WAVE");
+    
+    // -----------------------------------------------------------
+    // FORMAT CHUNK
+    addStringToFileData (fileData, "fmt ");
+    addInt32ToFileData (fileData, formatChunkSize); // format chunk size (16 for PCM)
+    addInt16ToFileData (fileData, audioFormat); // audio format
+    addInt16ToFileData (fileData, (int16_t)getNumChannels()); // num channels
+    addInt32ToFileData (fileData, (int32_t)sampleRate); // sample rate
+    
+    int32_t numBytesPerSecond = (int32_t) ((getNumChannels() * sampleRate * bitDepth) / 8);
+    addInt32ToFileData (fileData, numBytesPerSecond);
+    
+    int16_t numBytesPerBlock = getNumChannels() * (bitDepth / 8);
+    addInt16ToFileData (fileData, numBytesPerBlock);
+    
+    addInt16ToFileData (fileData, (int16_t)bitDepth);
+    
+    if (audioFormat == WavAudioFormat::IEEEFloat)
+        addInt16ToFileData (fileData, 0); // extension size
+    
+    // -----------------------------------------------------------
+    // DATA CHUNK
+    addStringToFileData (fileData, "data");
+    addInt32ToFileData (fileData, dataChunkSize);
+    
+    for (int i = 0; i < getNumSamplesPerChannel(); i++)
+    {
+        for (int channel = 0; channel < getNumChannels(); channel++)
+        {
+            if (bitDepth == 8)
+            {
+                uint8_t byte = sampleToSingleByte (samples[channel][i]);
+                fileData.push_back (byte);
+            }
+            else if (bitDepth == 16)
+            {
+                int16_t sampleAsInt = sampleToSixteenBitInt (samples[channel][i]);
+                addInt16ToFileData (fileData, sampleAsInt);
+            }
+            else if (bitDepth == 24)
+            {
+                int32_t sampleAsIntAgain = (int32_t) (samples[channel][i] * (T)8388608.);
+                
+                uint8_t bytes[3];
+                bytes[2] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF;
+                bytes[1] = (uint8_t) (sampleAsIntAgain >>  8) & 0xFF;
+                bytes[0] = (uint8_t) sampleAsIntAgain & 0xFF;
+                
+                fileData.push_back (bytes[0]);
+                fileData.push_back (bytes[1]);
+                fileData.push_back (bytes[2]);
+            }
+            else if (bitDepth == 32)
+            {
+                int32_t sampleAsInt;
+                
+                if (audioFormat == WavAudioFormat::IEEEFloat)
+                    sampleAsInt = (int32_t) reinterpret_cast<int32_t&> (samples[channel][i]);
+                else // assume PCM
+                    sampleAsInt = (int32_t) (samples[channel][i] * std::numeric_limits<int32_t>::max());
+                
+                addInt32ToFileData (fileData, sampleAsInt, Endianness::LittleEndian);
+            }
+            else
+            {
+                assert (false && "Trying to write a file with unsupported bit depth");
+                return false;
+            }
+        }
+    }
+    
+    // -----------------------------------------------------------
+    // iXML CHUNK
+    if (iXMLChunkSize > 0) 
+    {
+        addStringToFileData (fileData, "iXML");
+        addInt32ToFileData (fileData, iXMLChunkSize);
+        addStringToFileData (fileData, iXMLChunk);
+    }
+    
+    // check that the various sizes we put in the metadata are correct
+    if (fileSizeInBytes != static_cast<int32_t> (fileData.size() - 8) || dataChunkSize != (getNumSamplesPerChannel() * getNumChannels() * (bitDepth / 8)))
+    {
+        reportError ("ERROR: couldn't save file to " + filePath);
+        return false;
+    }
+    
+    // try to write the file
+    return writeDataToFile (fileData, filePath);
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::saveToAiffFile (std::string filePath)
+{
+    std::vector<uint8_t> fileData;
+    
+    int32_t numBytesPerSample = bitDepth / 8;
+    int32_t numBytesPerFrame = numBytesPerSample * getNumChannels();
+    int32_t totalNumAudioSampleBytes = getNumSamplesPerChannel() * numBytesPerFrame;
+    int32_t soundDataChunkSize = totalNumAudioSampleBytes + 8;
+    int32_t iXMLChunkSize = static_cast<int32_t> (iXMLChunk.size());
+    
+    // -----------------------------------------------------------
+    // HEADER CHUNK
+    addStringToFileData (fileData, "FORM");
+    
+    // The file size in bytes is the header chunk size (4, not counting FORM and AIFF) + the COMM
+    // chunk size (26) + the metadata part of the SSND chunk plus the actual data chunk size
+    int32_t fileSizeInBytes = 4 + 26 + 16 + totalNumAudioSampleBytes;
+    if (iXMLChunkSize > 0)
+    {
+        fileSizeInBytes += (8 + iXMLChunkSize);
+    }
+
+    addInt32ToFileData (fileData, fileSizeInBytes, Endianness::BigEndian);
+    
+    addStringToFileData (fileData, "AIFF");
+    
+    // -----------------------------------------------------------
+    // COMM CHUNK
+    addStringToFileData (fileData, "COMM");
+    addInt32ToFileData (fileData, 18, Endianness::BigEndian); // commChunkSize
+    addInt16ToFileData (fileData, getNumChannels(), Endianness::BigEndian); // num channels
+    addInt32ToFileData (fileData, getNumSamplesPerChannel(), Endianness::BigEndian); // num samples per channel
+    addInt16ToFileData (fileData, bitDepth, Endianness::BigEndian); // bit depth
+    addSampleRateToAiffData (fileData, sampleRate);
+    
+    // -----------------------------------------------------------
+    // SSND CHUNK
+    addStringToFileData (fileData, "SSND");
+    addInt32ToFileData (fileData, soundDataChunkSize, Endianness::BigEndian);
+    addInt32ToFileData (fileData, 0, Endianness::BigEndian); // offset
+    addInt32ToFileData (fileData, 0, Endianness::BigEndian); // block size
+    
+    for (int i = 0; i < getNumSamplesPerChannel(); i++)
+    {
+        for (int channel = 0; channel < getNumChannels(); channel++)
+        {
+            if (bitDepth == 8)
+            {
+                uint8_t byte = sampleToSingleByte (samples[channel][i]);
+                fileData.push_back (byte);
+            }
+            else if (bitDepth == 16)
+            {
+                int16_t sampleAsInt = sampleToSixteenBitInt (samples[channel][i]);
+                addInt16ToFileData (fileData, sampleAsInt, Endianness::BigEndian);
+            }
+            else if (bitDepth == 24)
+            {
+                int32_t sampleAsIntAgain = (int32_t) (samples[channel][i] * (T)8388608.);
+                
+                uint8_t bytes[3];
+                bytes[0] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF;
+                bytes[1] = (uint8_t) (sampleAsIntAgain >>  8) & 0xFF;
+                bytes[2] = (uint8_t) sampleAsIntAgain & 0xFF;
+                
+                fileData.push_back (bytes[0]);
+                fileData.push_back (bytes[1]);
+                fileData.push_back (bytes[2]);
+            }
+            else if (bitDepth == 32)
+            {
+                // write samples as signed integers (no implementation yet for floating point, but looking at WAV implementation should help)
+                int32_t sampleAsInt = (int32_t) (samples[channel][i] * std::numeric_limits<int32_t>::max());
+                addInt32ToFileData (fileData, sampleAsInt, Endianness::BigEndian);
+            }
+            else
+            {
+                assert (false && "Trying to write a file with unsupported bit depth");
+                return false;
+            }
+        }
+    }
+
+    // -----------------------------------------------------------
+    // iXML CHUNK
+    if (iXMLChunkSize > 0)
+    {
+        addStringToFileData (fileData, "iXML");
+        addInt32ToFileData (fileData, iXMLChunkSize, Endianness::BigEndian);
+        addStringToFileData (fileData, iXMLChunk);
+    }
+    
+    // check that the various sizes we put in the metadata are correct
+    if (fileSizeInBytes != static_cast<int32_t> (fileData.size() - 8) || soundDataChunkSize != getNumSamplesPerChannel() *  numBytesPerFrame + 8)
+    {
+        reportError ("ERROR: couldn't save file to " + filePath);
+        return false;
+    }
+    
+    // try to write the file
+    return writeDataToFile (fileData, filePath);
+}
+
+//=============================================================
+template <class T>
+bool AudioFile<T>::writeDataToFile (std::vector<uint8_t>& fileData, std::string filePath)
+{
+    std::ofstream outputFile (filePath, std::ios::binary);
+    
+    if (outputFile.is_open())
+    {
+        for (size_t i = 0; i < fileData.size(); i++)
+        {
+            char value = (char) fileData[i];
+            outputFile.write (&value, sizeof (char));
+        }
+        
+        outputFile.close();
+        
+        return true;
+    }
+    
+    return false;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::addStringToFileData (std::vector<uint8_t>& fileData, std::string s)
+{
+    for (size_t i = 0; i < s.length();i++)
+        fileData.push_back ((uint8_t) s[i]);
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::addInt32ToFileData (std::vector<uint8_t>& fileData, int32_t i, Endianness endianness)
+{
+    uint8_t bytes[4];
+    
+    if (endianness == Endianness::LittleEndian)
+    {
+        bytes[3] = (i >> 24) & 0xFF;
+        bytes[2] = (i >> 16) & 0xFF;
+        bytes[1] = (i >> 8) & 0xFF;
+        bytes[0] = i & 0xFF;
+    }
+    else
+    {
+        bytes[0] = (i >> 24) & 0xFF;
+        bytes[1] = (i >> 16) & 0xFF;
+        bytes[2] = (i >> 8) & 0xFF;
+        bytes[3] = i & 0xFF;
+    }
+    
+    for (int i = 0; i < 4; i++)
+        fileData.push_back (bytes[i]);
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::addInt16ToFileData (std::vector<uint8_t>& fileData, int16_t i, Endianness endianness)
+{
+    uint8_t bytes[2];
+    
+    if (endianness == Endianness::LittleEndian)
+    {
+        bytes[1] = (i >> 8) & 0xFF;
+        bytes[0] = i & 0xFF;
+    }
+    else
+    {
+        bytes[0] = (i >> 8) & 0xFF;
+        bytes[1] = i & 0xFF;
+    }
+    
+    fileData.push_back (bytes[0]);
+    fileData.push_back (bytes[1]);
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::clearAudioBuffer()
+{
+    for (size_t i = 0; i < samples.size();i++)
+    {
+        samples[i].clear();
+    }
+    
+    samples.clear();
+}
+
+//=============================================================
+template <class T>
+AudioFileFormat AudioFile<T>::determineAudioFileFormat (std::vector<uint8_t>& fileData)
+{
+    std::string header (fileData.begin(), fileData.begin() + 4);
+    
+    if (header == "RIFF")
+        return AudioFileFormat::Wave;
+    else if (header == "FORM")
+        return AudioFileFormat::Aiff;
+    else
+        return AudioFileFormat::Error;
+}
+
+//=============================================================
+template <class T>
+int32_t AudioFile<T>::fourBytesToInt (std::vector<uint8_t>& source, int startIndex, Endianness endianness)
+{
+    int32_t result;
+    
+    if (endianness == Endianness::LittleEndian)
+        result = (source[startIndex + 3] << 24) | (source[startIndex + 2] << 16) | (source[startIndex + 1] << 8) | source[startIndex];
+    else
+        result = (source[startIndex] << 24) | (source[startIndex + 1] << 16) | (source[startIndex + 2] << 8) | source[startIndex + 3];
+    
+    return result;
+}
+
+//=============================================================
+template <class T>
+int16_t AudioFile<T>::twoBytesToInt (std::vector<uint8_t>& source, int startIndex, Endianness endianness)
+{
+    int16_t result;
+    
+    if (endianness == Endianness::LittleEndian)
+        result = (source[startIndex + 1] << 8) | source[startIndex];
+    else
+        result = (source[startIndex] << 8) | source[startIndex + 1];
+    
+    return result;
+}
+
+//=============================================================
+template <class T>
+int AudioFile<T>::getIndexOfString (std::vector<uint8_t>& source, std::string stringToSearchFor)
+{
+    int index = -1;
+    int stringLength = (int)stringToSearchFor.length();
+    
+    for (size_t i = 0; i < source.size() - stringLength;i++)
+    {
+        std::string section (source.begin() + i, source.begin() + i + stringLength);
+        
+        if (section == stringToSearchFor)
+        {
+            index = static_cast<int> (i);
+            break;
+        }
+    }
+    
+    return index;
+}
+
+//=============================================================
+template <class T>
+int AudioFile<T>::getIndexOfChunk (std::vector<uint8_t>& source, const std::string& chunkHeaderID, int startIndex, Endianness endianness)
+{
+    constexpr int dataLen = 4;
+    if (chunkHeaderID.size() != dataLen)
+    {
+        assert (false && "Invalid chunk header ID string");
+        return -1;
+    }
+
+    int i = startIndex;
+    while (i < source.size() - dataLen)
+    {
+        if (memcmp (&source[i], chunkHeaderID.data(), dataLen) == 0)
+        {
+            return i;
+        }
+
+        i += dataLen;
+        auto chunkSize = fourBytesToInt (source, i, endianness);
+        i += (dataLen + chunkSize);
+    }
+
+    return -1;
+}
+
+//=============================================================
+template <class T>
+T AudioFile<T>::sixteenBitIntToSample (int16_t sample)
+{
+    return static_cast<T> (sample) / static_cast<T> (32768.);
+}
+
+//=============================================================
+template <class T>
+int16_t AudioFile<T>::sampleToSixteenBitInt (T sample)
+{
+    sample = clamp (sample, -1., 1.);
+    return static_cast<int16_t> (sample * 32767.);
+}
+
+//=============================================================
+template <class T>
+uint8_t AudioFile<T>::sampleToSingleByte (T sample)
+{
+    sample = clamp (sample, -1., 1.);
+    sample = (sample + 1.) / 2.;
+    return static_cast<uint8_t> (sample * 255.);
+}
+
+//=============================================================
+template <class T>
+T AudioFile<T>::singleByteToSample (uint8_t sample)
+{
+    return static_cast<T> (sample - 128) / static_cast<T> (128.);
+}
+
+//=============================================================
+template <class T>
+T AudioFile<T>::clamp (T value, T minValue, T maxValue)
+{
+    value = std::min (value, maxValue);
+    value = std::max (value, minValue);
+    return value;
+}
+
+//=============================================================
+template <class T>
+void AudioFile<T>::reportError (std::string errorMessage)
+{
+    if (logErrorsToConsole)
+        std::cout << errorMessage << std::endl;
+}
+
+#if defined (_MSC_VER)
+    __pragma(warning (pop))
+#elif defined (__GNUC__)
+    _Pragma("GCC diagnostic pop")
+#endif
+
+#endif /* AudioFile_h */

cpp/src/EnG2P.h

@@ -0,0 +1,138 @@
+#pragma once
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+
+class EnG2P {
+public:
+    EnG2P(const std::string& dict_path) {
+        load_dict(dict_path);
+        init_arpabet_map();
+    }
+
+    std::string convert(const std::string& word) {
+        std::string upper_word = word;
+        // Simple strip of punctuation if needed? 
+        // But let's just assume the input is somewhat clean or strict match first.
+        
+        // Trim common punctuation from ends just in case
+        size_t start = 0;
+        while (start < upper_word.size() && !isalnum((unsigned char)upper_word[start])) start++;
+        size_t end = upper_word.size();
+        while (end > start && !isalnum((unsigned char)upper_word[end-1])) end--;
+        
+        std::string clean_word = upper_word.substr(start, end - start);
+        std::string prefix = upper_word.substr(0, start);
+        std::string suffix = upper_word.substr(end);
+        
+        std::transform(clean_word.begin(), clean_word.end(), clean_word.begin(), ::toupper);
+        
+        // std::cout << "Debug EnG2P: Query [" << clean_word << "]" << std::endl;
+        
+        if (dict_.count(clean_word)) {
+            return prefix + arpabet_to_ipa(dict_.at(clean_word)) + suffix;
+        }
+        
+        // Fallback: return original
+        return word; 
+    }
+
+private:
+    std::unordered_map<std::string, std::vector<std::string>> dict_;
+    std::unordered_map<std::string, std::string> arpabet_map_;
+
+    void load_dict(const std::string& path) {
+        std::ifstream file(path);
+        if (!file.is_open()) {
+            // Silent fail or log?
+            std::cerr << "[EnG2P] Warning: Failed to open CMU dict: " << path << std::endl;
+            return;
+        }
+        std::string line;
+        int count = 0;
+        while (std::getline(file, line)) {
+            if (line.empty()) continue;
+            // CMU dict lines start with word, possibly with symbols like !EXCLAMATION-POINT
+            // Standard format: WORD  PH ON E M ES
+            if (!isalpha(line[0]) && line[0] != '\'') continue; // Basic filtering
+
+            std::stringstream ss(line);
+            std::string word, ph;
+            ss >> word;
+            
+            // Handle variants like WORD(1)
+            size_t paren = word.find('(');
+            if (paren != std::string::npos) {
+                word = word.substr(0, paren);
+            }
+
+            // Normalize to UPPERCASE
+            std::transform(word.begin(), word.end(), word.begin(), ::toupper);
+
+            std::vector<std::string> phonemes;
+            while (ss >> ph) {
+                phonemes.push_back(ph);
+            }
+            
+            // Only keep first variant if multiple exist (CMU dict is sorted, usually main first)
+            if (!dict_.count(word)) {
+                dict_[word] = phonemes;
+                count++;
+                // if (count < 5) std::cout << "Debug CMU: Loaded [" << word << "]" << std::endl;
+            }
+        }
+        std::cout << "[EnG2P] Loaded " << dict_.size() << " words from CMU dict." << std::endl;
+        
+    }
+
+    void init_arpabet_map() {
+        // Mapping ARPABET to IPA
+        // Note: This is a simplified mapping.
+        // Stress: 1 (primary) -> ˈ, 2 (secondary) -> ˌ, 0 (unstressed) -> nothing/schwa
+        arpabet_map_ = {
+            {"AA0", "ɑ"}, {"AA1", "ˈɑ"}, {"AA2", "ˌɑ"},
+            {"AE0", "æ"}, {"AE1", "ˈæ"}, {"AE2", "ˌæ"},
+            {"AH0", "ə"}, {"AH1", "ˈʌ"}, {"AH2", "ˌʌ"},
+            {"AO0", "ɔ"}, {"AO1", "ˈɔ"}, {"AO2", "ˌɔ"},
+            {"AW0", "aʊ"}, {"AW1", "ˈaʊ"}, {"AW2", "ˌaʊ"},
+            {"AY0", "aɪ"}, {"AY1", "ˈaɪ"}, {"AY2", "ˌaɪ"},
+            {"B", "b"}, {"CH", "tʃ"}, {"D", "d"}, {"DH", "ð"},
+            {"EH0", "ɛ"}, {"EH1", "ˈɛ"}, {"EH2", "ˌɛ"},
+            {"ER0", "ɚ"}, {"ER1", "ˈɝ"}, {"ER2", "ˌɝ"},
+            {"EY0", "eɪ"}, {"EY1", "ˈeɪ"}, {"EY2", "ˌeɪ"},
+            {"F", "f"}, {"G", "ɡ"}, {"HH", "h"},
+            {"IH0", "ɪ"}, {"IH1", "ˈɪ"}, {"IH2", "ˌɪ"},
+            {"IY0", "i"}, {"IY1", "ˈi"}, {"IY2", "ˌi"},
+            {"JH", "dʒ"}, {"K", "k"}, {"L", "l"},
+            {"M", "m"}, {"N", "n"}, {"NG", "ŋ"},
+            {"OW0", "oʊ"}, {"OW1", "ˈoʊ"}, {"OW2", "ˌoʊ"},
+            {"OY0", "ɔɪ"}, {"OY1", "ˈɔɪ"}, {"OY2", "ˌɔɪ"},
+            {"P", "p"}, {"R", "r"}, {"S", "s"}, {"SH", "ʃ"},
+            {"T", "t"}, {"TH", "θ"},
+            {"UH0", "ʊ"}, {"UH1", "ˈʊ"}, {"UH2", "ˌʊ"},
+            {"UW0", "u"}, {"UW1", "ˈu"}, {"UW2", "ˌu"},
+            {"V", "v"}, {"W", "w"}, {"Y", "j"}, {"Z", "z"}, {"ZH", "ʒ"}
+        };
+    }
+
+    std::string arpabet_to_ipa(const std::vector<std::string>& phonemes) {
+        std::string res;
+        for (const auto& p : phonemes) {
+            if (arpabet_map_.count(p)) {
+                res += arpabet_map_.at(p);
+            } else {
+                // Fallback: try removing digit
+                std::string base = p;
+                if (!base.empty() && isdigit(base.back())) base.pop_back();
+                if (arpabet_map_.count(base)) {
+                     res += arpabet_map_.at(base);
+                }
+            }
+        }
+        return res;
+    }
+};

cpp/src/JiebaProcessor.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include "ZHG2P.h"
+#include "PinyinFinder.h"
+#include "cppjieba/Jieba.hpp"
+#include "Utils.h"
+#include <regex>
+
+class JiebaProcessor : public TextProcessor {
+public:
+    JiebaProcessor(const std::string& dict_path, 
+                   const std::string& hmm_path, 
+                   const std::string& user_dict_path,
+                   const std::string& idf_path, 
+                   const std::string& stop_word_path,
+                   const std::string& pinyin_char_path,
+                   const std::string& pinyin_word_path) 
+        : jieba(dict_path, hmm_path, user_dict_path, idf_path, stop_word_path) 
+    {
+        finder = std::make_shared<PinyinFinder>();
+        if (!finder->init(pinyin_char_path, pinyin_word_path)) {
+            std::cerr << "Failed to init PinyinFinder" << std::endl;
+        }
+    }
+
+    std::vector<std::pair<std::string, std::string>> cut(const std::string& text) override {
+        std::vector<std::pair<std::string, std::string>> result;
+        std::vector<std::pair<std::string, std::string>> tag_words;
+        
+        // Use cppjieba Tagging
+        jieba.Tag(text, tag_words);
+        
+        for (const auto& w : tag_words) {
+            std::string word = w.first;
+            std::string tag = w.second;
+            
+            // Ensure punctuation is 'x' (jieba might return 'w' for punct)
+            if (tag == "w") tag = "x";
+            
+            // FIX: If tag is 'x' but contains Chinese characters, force it to a valid tag (e.g. 'n')
+            // This prevents words like "我要" being tagged as 'x' and skipped by G2P.
+            if (tag == "x") {
+                bool has_cn = false;
+                for (unsigned char c : word) {
+                    if (c >= 0xE4 && c <= 0xE9) {
+                        has_cn = true; 
+                        break;
+                    }
+                }
+                if (has_cn) tag = "n";
+            }
+            
+            result.push_back({word, tag});
+        }
+        return result;
+    }
+
+    std::vector<std::string> word_to_pinyin(const std::string& word) override {
+        std::vector<std::string> pinyins;
+        if (finder) {
+            finder->find_best_pinyin(word, pinyins);
+        }
+        return pinyins;
+    }
+
+    std::string convert_numbers(const std::string& text) override {
+        // Regex to find numbers: integers, floats, and IP-like strings
+        // Examples: 123, -123, 3.14, 192.168.0.1
+        // Pattern: [-+]?\d+(?:\.\d+)*
+        
+        std::regex num_regex("[-+]?\\d+(?:\\.\\d+)*");
+        std::string result;
+        
+        auto words_begin = std::sregex_iterator(text.begin(), text.end(), num_regex);
+        auto words_end = std::sregex_iterator();
+        
+        size_t last_pos = 0;
+        
+        for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
+            std::smatch match = *i;
+            std::string match_str = match.str();
+            
+            // Append text before the number
+            result += text.substr(last_pos, match.position() - last_pos);
+            
+            // Convert number to Chinese
+            result += BasicStringUtil::NumberToChinese(match_str);
+            
+            last_pos = match.position() + match.length();
+        }
+        
+        // Append remaining text
+        if (last_pos < text.length()) {
+            result += text.substr(last_pos);
+        }
+        
+        return result;
+    }
+
+private:
+    cppjieba::Jieba jieba;
+    std::shared_ptr<PinyinFinder> finder;
+};

cpp/src/Kokoro.cpp

@@ -0,0 +1,1216 @@
+#include "Kokoro.h"
+#include "Tokenizer.h"
+#include <fstream>
+#include <sstream>
+#include <regex>
+#include <numeric>
+#include <cstring>
+#include <algorithm>
+#include <math.h>
+#include <locale>
+#include <codecvt>
+#include "utils/logger.hpp"
+#include "librosa/eigen3/Eigen/Dense"
+#include "librosa/librosa.h"
+#include "split_utils.hpp"
+
+using namespace std;
+
+typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> DynMat;
+
+typedef std::vector<std::vector<std::complex<float>>> FFT_RESULT;
+
+// DEBUG
+template <typename T>
+static void save_file(const std::vector<T>& data, const char* filename) {
+    FILE* fp = fopen(filename, "wb");
+    fwrite(data.data(), sizeof(T), data.size(), fp);
+    fclose(fp);
+}
+
+void save_fft_result(const FFT_RESULT& f, const char* filename) {
+    FILE* fp = fopen(filename, "wb");
+    for (size_t i = 0; i < f.size(); i++) {
+        for (size_t j = 0; j < f[0].size(); j++) {
+            float real = f[i][j].real();
+            float imag = f[i][j].imag();
+            fwrite(&real, sizeof(float), 1, fp);
+            fwrite(&imag, sizeof(float), 1, fp);
+        }
+    }
+    fclose(fp);
+}
+
+// Helper functions
+static std::vector<float> sigmoid(const std::vector<float>& x) {
+    std::vector<float> result(x.size());
+    for (int i = 0; i < x.size(); i++) {
+        result[i] = 1.0f / (1.0f + expf(-x[i]));
+    }
+    return result;
+}
+
+template <typename T>
+std::vector<T> load_file(const char* filename) {
+    // 打开文件（二进制模式）
+    std::ifstream file(filename, std::ios::binary);
+    
+    // 获取文件大小
+    file.seekg(0, std::ios::end);
+    size_t file_size = file.tellg();
+    file.seekg(0, std::ios::beg);
+    
+    // 计算float数量
+    size_t num_floats = file_size / sizeof(T);
+    
+    // 创建向量并读取数据
+    std::vector<T> result;
+    result.resize(num_floats);
+    file.read(reinterpret_cast<char*>(result.data()), file_size);
+    
+    file.close();
+    return result;
+}
+
+template <typename T>
+vector<size_t> argsort(const vector<T> &v, int len, bool reverse) {
+    // initialize original index locations
+    vector<size_t> idx(len);
+    iota(idx.begin(), idx.end(), 0);
+
+    // sort indexes based on comparing values in v
+    // using std::stable_sort instead of std::sort
+    // to avoid unnecessary index re-orderings
+    // when v contains elements of equal values 
+    if (!reverse)
+        stable_sort(idx.begin(), idx.end(),
+            [&v](size_t i1, size_t i2) {return v[i1] < v[i2];});
+    else
+        stable_sort(idx.begin(), idx.end(),
+            [&v](size_t i1, size_t i2) {return v[i1] > v[i2];});
+
+    return idx;
+}
+
+template <typename T>
+vector<T> np_repeat(const vector<T> &v, const vector<int>& times) {
+    vector<T> result;
+    for (size_t i = 0; i < times.size(); i++) {
+        for (int n = 0; n < times[i]; n++)
+            result.push_back(v[i]);
+    }
+    return result;
+}
+
+template <typename T>
+std::vector<T> linspace(T a, T b, size_t N) {
+    T h = (b - a) / static_cast<T>(N-1);
+    std::vector<T> xs(N);
+    typename std::vector<T>::iterator x;
+    T val;
+    for (x = xs.begin(), val = a; x != xs.end(); ++x, val += h)
+        *x = val;
+    return xs;
+}
+
+/**
+ * 清理文本：移除多余空格、控制字符等
+ * @param text 输入文本
+ * @return 清理后的文本
+ */
+string clean_text(const string& text) {
+    if (text.empty()) return "";
+    
+    string result;
+    result.reserve(text.length());
+    
+    // 第一步：处理空格和替换控制字符
+    bool last_was_space = false;
+    for (char c : text) {
+        // 保留换行符、回车符、制表符
+        if (c == '\n' || c == '\r' || c == '\t') {
+            result.push_back(c);
+            last_was_space = false;
+        }
+        // 处理普通空格
+        else if (isspace(static_cast<unsigned char>(c))) {
+            if (!last_was_space) {
+                result.push_back(' ');
+                last_was_space = true;
+            }
+        }
+        // 保留可打印字符（ASCII >= 32）
+        else if (static_cast<unsigned char>(c) >= 32) {
+            result.push_back(c);
+            last_was_space = false;
+        }
+        // 其他控制字符被忽略
+    }
+    
+    // 第二步：去除首尾空格
+    // 去除开头的空格
+    size_t start = 0;
+    while (start < result.length() && result[start] == ' ') {
+        start++;
+    }
+    
+    // 去除结尾的空格
+    size_t end = result.length();
+    while (end > start && result[end - 1] == ' ') {
+        end--;
+    }
+    
+    return result.substr(start, end - start);
+}
+
+/**
+ * 拼接音频片段
+ * @param segment_data_list 音频片段列表（每个片段是float向量）
+ * @param sample_rate 采样率，默认24000
+ * @param speed 语速，默认1.0
+ * @param pause_duration 停顿时长（秒），默认0.5
+ * @return 拼接后的音频数据（std::vector<float>）
+ */
+std::vector<float> audio_numpy_concat(
+    const std::vector<std::vector<float>>& segment_data_list,
+    int sample_rate = 24000,
+    float speed = 1.0f,
+    float pause_duration = 0.5f
+) {
+    // 如果输入为空，返回空向量
+    if (segment_data_list.empty()) {
+        return std::vector<float>();
+    }
+    
+    // 计算停顿的样本数
+    int pause_samples = 0;
+    if (pause_duration > 0.0f && speed > 0.0f) {
+        pause_samples = static_cast<int>((sample_rate * pause_duration) / speed);
+        if (pause_samples < 0) {
+            pause_samples = 0;
+        }
+    }
+    
+    // 首先计算总长度，预分配内存（提高性能）
+    size_t total_length = 0;
+    for (const auto& segment : segment_data_list) {
+        total_length += segment.size();
+    }
+    
+    // 添加停顿的长度（在片段之间）
+    size_t num_pauses = 0;
+    if (segment_data_list.size() > 1 && pause_samples > 0) {
+        num_pauses = segment_data_list.size() - 1;
+        total_length += pause_samples * num_pauses;
+    }
+    
+    // 创建结果向量并预分配内存
+    std::vector<float> result;
+    result.reserve(total_length);
+    
+    // 拼接所有片段
+    for (size_t i = 0; i < segment_data_list.size(); ++i) {
+        // 添加当前音频片段
+        const auto& current_segment = segment_data_list[i];
+        result.insert(result.end(), 
+                     current_segment.begin(), 
+                     current_segment.end());
+        
+        // 如果不是最后一个片段，添加停顿
+        if (i < segment_data_list.size() - 1 && pause_samples > 0) {
+            result.insert(result.end(), pause_samples, 0.0f);
+        }
+    }
+    
+    return result;
+}
+
+
+Kokoro::Kokoro() 
+{
+    
+}
+
+Kokoro::~Kokoro() {
+    // Resources cleaned up by wrappers
+}
+
+bool Kokoro::init(const std::string& model_path, int max_seq_len, const std::string& voices_path, const std::string& voice_name, const std::string& vocab_path) {
+    max_seq_len_ = max_seq_len;
+    voices_path_ = voices_path;
+    voice_name_ = voice_name;
+
+    env_ = Ort::Env(ORT_LOGGING_LEVEL_WARNING, "Kokoro");
+    // Initialize session options
+    Ort::SessionOptions session_options;
+    session_options.SetIntraOpNumThreads(1);
+    // session_options.SetLogSeverityLevel(ORT_LOGGING_LEVEL_VERBOSE);
+    session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);
+
+    // Load models
+    std::string model1_path = model_path + "/kokoro_part1_96.axmodel";
+    std::string model2_path = model_path + "/kokoro_part2_96.axmodel";
+    std::string model3_path = model_path + "/kokoro_part3_96.axmodel";
+    std::string model4_path = model_path + "/model4_har_sim.onnx";
+
+    // Load voice
+    if (!get_voice_style(voices_path, voice_name)) {
+        ALOGE("Load voice failed!");
+        return false;
+    }
+
+    int ret = model1_.load_model(model1_path.c_str());
+    if (0 != ret) {
+        ALOGE("load model1 %s failed! ret=0x%x", model1_path.c_str(), ret);
+        return false;
+    }
+
+    ret = model2_.load_model(model2_path.c_str());
+    if (0 != ret) {
+        ALOGE("load model2 %s failed! ret=0x%x", model2_path.c_str(), ret);
+        return false;
+    }
+
+    ret = model3_.load_model(model3_path.c_str());
+    if (0 != ret) {
+        ALOGE("load model3 %s failed! ret=0x%x", model3_path.c_str(), ret);
+        return false;
+    }
+
+    model4_ = Ort::Session(env_, model4_path.c_str(), session_options);
+
+    // Load vocab
+    std::map<std::string, int> vocab;
+    std::ifstream in(vocab_path);
+    if (in.is_open()) {
+        std::string line;
+        while (std::getline(in, line)) {
+            // Expected format: token<TAB>id
+            size_t tab = line.find('\t');
+            if (tab != std::string::npos) {
+                std::string token = line.substr(0, tab);
+                std::string id_str = line.substr(tab + 1);
+                // Unescape token if needed (\n, \r, \t)
+                size_t pos = 0;
+                while((pos = token.find("\\n", pos)) != std::string::npos) { token.replace(pos, 2, "\n"); pos += 1; }
+                pos = 0;
+                while((pos = token.find("\\r", pos)) != std::string::npos) { token.replace(pos, 2, "\r"); pos += 1; }
+                pos = 0;
+                while((pos = token.find("\\t", pos)) != std::string::npos) { token.replace(pos, 2, "\t"); pos += 1; }
+                
+                try {
+                    vocab[token] = std::stoi(id_str);
+                } catch (...) {}
+            }
+        }
+        ALOGI("Loaded %d tokens from %s", vocab.size(), vocab_path.c_str());
+    } else {
+        ALOGE("Failed to open vocab file %s", vocab_path.c_str());
+        return false;
+    }
+
+    // Initialize Tokenizer
+    tokenizer_ = std::make_unique<Tokenizer>(TokenizerConfig{}, vocab);
+
+    // Prepare model outputs
+    duration_.resize(model1_.get_output_size(0) / sizeof(float));
+    d_.resize(model1_.get_output_size(1) / sizeof(float));
+
+    // F0_pred, N_pred, asr = outputs2
+    F0_pred_.resize(model2_.get_output_size(0) / sizeof(float));
+    N_pred_.resize(model2_.get_output_size(1) / sizeof(float));
+    asr_.resize(model2_.get_output_size(2) / sizeof(float));
+
+    x_.resize(model3_.get_output_size(0) / sizeof(float));
+
+    duration_shape_ = model1_.get_output_shape(0);
+    d_shape_ = model1_.get_output_shape(1);
+
+    F0_pred_shape_ = model2_.get_output_shape(0);
+
+    x_shape_ = model3_.get_output_shape(0);
+
+    return true;
+}
+
+bool Kokoro::get_voice_style(const std::string& voices_path, const std::string& voice_name) {
+    // 打开文件（二进制模式）
+    std::string voice_bin_path = voices_path + "/" + voice_name + ".bin";
+    std::ifstream file(voice_bin_path, std::ios::binary);
+    if (!file.is_open()) {
+        ALOGE("Open file %s failed!", voice_bin_path.c_str());
+        return false;
+    }
+    
+    // 获取文件大小
+    file.seekg(0, std::ios::end);
+    size_t file_size = file.tellg();
+    file.seekg(0, std::ios::beg);
+    
+    // 计算float数量
+    size_t num_floats = file_size / sizeof(float);
+
+    voice_pack_size_ = num_floats / STYLE_DIM;
+    
+    // 创建向量并读取数据
+    voice_tensor_.resize(num_floats);
+    file.read(reinterpret_cast<char*>(voice_tensor_.data()), file_size);
+    
+    file.close();
+    return true;
+}
+
+std::vector<std::string> Kokoro::_split_phonemes(const std::string& phonemes) {
+    std::vector<std::string> batches;
+    std::regex re("([.,!?;])");
+    std::sregex_token_iterator it(phonemes.begin(), phonemes.end(), re, {-1, 0}); // -1 for non-match, 0 for match
+    std::sregex_token_iterator end;
+
+    std::string current_batch;
+    
+    for (; it != end; ++it) {
+        std::string part = *it;
+        // Removing leading/trailing whitespace
+        part = std::regex_replace(part, std::regex("^\\s+|\\s+$"), "");
+        
+        if (part.empty()) continue;
+
+        if (current_batch.length() + part.length() + 1 >= MAX_PHONEME_LENGTH) {
+            batches.push_back(current_batch);
+            current_batch = part;
+        } else {
+             if (std::string(".,!?;").find(part) != std::string::npos) {
+                current_batch += part;
+             } else {
+                if (!current_batch.empty()) current_batch += " ";
+                current_batch += part;
+             }
+        }
+    }
+    if (!current_batch.empty()) {
+        batches.push_back(current_batch);
+    }
+    return batches;
+}
+
+void Kokoro::_prepare_input_ids(std::vector<int>& input_ids, int& actual_len, bool& is_doubled) {
+    // 准备输入ID，对短输入进行复制处理
+    is_doubled = false;
+    int original_actual_len = actual_len;
+
+    // printf("actual_len 3: %d\n", actual_len);
+    if (actual_len <= DOUBLE_INPUT_THRESHOLD) {
+        // printf("doubled!\n");
+        is_doubled = true;
+        // valid_content = input_ids[:, :actual_len]
+        std::vector<int> valid_content(input_ids.begin(), input_ids.begin() + actual_len);
+        // input_ids_doubled = np.concatenate([valid_content, valid_content], axis=1)
+        std::vector<int> input_ids_doubled;
+        // input_ids_doubled.reserve(2 * actual_len);
+        input_ids_doubled.insert(input_ids_doubled.end(), valid_content.begin(), valid_content.end());
+        input_ids_doubled.insert(input_ids_doubled.end(), valid_content.begin(), valid_content.end());
+        
+        // padding_len = self.max_seq_len_ - input_ids_doubled.shape[1]
+        int padding_len = max_seq_len_ - 2 * actual_len;
+        // printf("padding_len: %d\n", padding_len);
+        if (padding_len > 0) {
+            // input_ids = np.concatenate([input_ids_doubled, np.zeros((1, padding_len), dtype=input_ids.dtype)], axis=1)
+            std::vector<int> padding(padding_len, 0);
+            input_ids_doubled.insert(input_ids_doubled.end(), padding.begin(), padding.end());
+        }
+        else {
+            // input_ids = input_ids_doubled[:, :self.max_seq_len_]
+            input_ids_doubled.resize(max_seq_len_);
+        }
+
+        // save_file(input_ids_doubled, "input_ids2_1.bin");
+            
+        input_ids = input_ids_doubled;
+        actual_len = std::min(original_actual_len * 2, max_seq_len_);
+    }
+}
+
+void Kokoro::_compute_external_preprocessing(const std::vector<int>& input_ids, int actual_len, std::vector<int>& input_lengths, std::vector<uint8_t>& text_mask) {
+    // 计算输入预处理：长度和mask
+    // input_lengths = np.full((input_ids.shape[0],), actual_len, dtype=np.int64)
+    input_lengths = std::vector<int>{actual_len};
+    // text_mask = np.arange(self.max_seq_len_)[np.newaxis, :] >= input_lengths[:, np.newaxis]
+    text_mask.resize(max_seq_len_);
+    for (int i = 0; i < max_seq_len_; i++) {
+        text_mask[i] = (i >= actual_len) ? 1 : 0;
+    }
+}
+
+void Kokoro::_process_duration(const std::vector<float>& duration, int actual_len, float speed, std::vector<int>& pred_dur, int& total_frames) {
+    // """处理duration预测，调整到固定帧数"""
+    // duration_processed = 1.0 / (1.0 + np.exp(-duration))
+    // duration_processed = duration_processed.sum(axis=-1) / speed
+    // pred_dur_original = np.round(duration_processed).clip(min=1).astype(np.int64).squeeze()
+    std::vector<int> pred_dur_original(actual_len, 0);
+    std::vector<float> duration_processed = sigmoid(duration);
+    for (int i = 0; i < actual_len; i++) {
+        float sum = 0;
+
+        // duration shape: [1, 96, 50]
+        for (int n = 0; n < duration_shape_[2]; n++) {
+            sum += duration_processed[i * duration_shape_[2] + n];
+        }
+        sum /= speed;
+
+        pred_dur_original[i] = int(std::max(1.f, roundf(sum)));
+    }
+
+    // # 分离实际内容和padding
+    // pred_dur_actual = pred_dur_original[:actual_len]
+    // pred_dur_padding = np.zeros(self.max_seq_len_ - actual_len, dtype=np.int64)
+    // pred_dur = np.concatenate([pred_dur_actual, pred_dur_padding])
+    std::vector<int> pred_dur_padding(max_seq_len_ - actual_len, 0);
+    pred_dur = pred_dur_original;
+    pred_dur.insert(pred_dur.end(), pred_dur_padding.begin(), pred_dur_padding.end());
+
+    
+    // # 调整实际内容部分，只处理长度超出情况
+    // fixed_total_frames = self.max_seq_len_ * 2
+    // diff = fixed_total_frames - pred_dur[:actual_len].sum()
+    
+    // if diff < 0:
+    //     # 减少帧数
+    //     indices = np.argsort(pred_dur[:actual_len])[::-1]
+    //     decreased = 0
+    //     for idx in indices:
+    //         if pred_dur[idx] > 1 and decreased < abs(diff):
+    //             pred_dur[idx] -= 1
+    //             decreased += 1
+    //         if decreased >= abs(diff):
+    //             break
+
+    // 调整实际内容部分，只处理长度超出情况
+    int fixed_total_frames = max_seq_len_ * 2;
+    int actual_frames = std::accumulate(pred_dur.begin(), pred_dur.begin() + actual_len, 0);
+    int diff = fixed_total_frames - actual_frames;
+
+    if (diff < 0) {
+        // 减少帧数
+        auto indices = argsort(pred_dur, actual_len, true);
+        int decreased = 0;
+        for (auto idx : indices) {
+            if (pred_dur[idx] > 1 && decreased < std::abs(diff)) {
+                pred_dur[idx]--;
+                decreased++;
+            }
+            if (decreased >= std::abs(diff))
+                break;
+        }
+    }
+    
+    // # 将剩余帧数分配到padding部分
+    // remaining_frames = fixed_total_frames - pred_dur[:actual_len].sum()
+    // padding_len = self.max_seq_len_ - actual_len
+    // if remaining_frames > 0 and padding_len > 0:
+    //     frames_per_padding = remaining_frames // padding_len
+    //     remainder = remaining_frames % padding_len
+    //     pred_dur[actual_len:] = frames_per_padding
+    //     if remainder > 0:
+    //         pred_dur[actual_len:actual_len+remainder] += 1
+
+    actual_frames = std::accumulate(pred_dur.begin(), pred_dur.begin() + actual_len, 0);
+    int remaining_frames = fixed_total_frames - actual_frames;
+    int padding_len = max_seq_len_ - actual_len;
+    // printf("actual_len 4: %d\n ", actual_len);
+    // printf("remaining_frames 4: %d\n", remaining_frames);
+    // printf("padding_len 4: %d\n", padding_len);
+
+    if (remaining_frames > 0 && padding_len > 0) {
+        int frames_per_padding = remaining_frames / padding_len;
+        int remainder = remaining_frames % padding_len;
+
+        for (int i = actual_len; i < pred_dur.size(); i++)
+            pred_dur[i] = frames_per_padding;
+
+        if (remainder > 0) {
+            for (int i = actual_len; i < actual_len + remainder; i++) 
+                pred_dur[i] += 1;
+        }
+    }
+    
+    // total_frames = pred_dur.sum()
+    total_frames = std::accumulate(pred_dur.begin(), pred_dur.end(), 0);
+    // printf("total_frames: %d\n", total_frames);
+}
+
+std::vector<float> Kokoro::_create_alignment_matrix(const std::vector<int>& pred_dur, int total_frames) {
+    // """创建对齐矩阵"""
+    // indices = np.repeat(np.arange(self.max_seq_len_), pred_dur)
+    // pred_aln_trg = np.zeros((self.max_seq_len_, total_frames), dtype=np.float32)
+    // if len(indices) > 0:
+    //     pred_aln_trg[indices, np.arange(total_frames)] = 1.0
+    // return pred_aln_trg[np.newaxis, ...]
+
+    std::vector<int> seq_range(max_seq_len_);
+    std::iota(seq_range.begin(), seq_range.end(), 0);
+    auto indices = np_repeat(seq_range, pred_dur);
+
+    std::vector<float> pred_aln_trg(max_seq_len_ * total_frames);
+    if (!indices.empty()) {
+        int col = 0;
+        for (auto i : indices) {
+            pred_aln_trg[i * total_frames + col] = 1.0f;
+            col++;
+        }
+    }
+
+    return pred_aln_trg;
+}
+
+void Kokoro::_compute_har_onnx(std::vector<float>& F0_pred, std::vector<float>& har) {
+    // Querying model inputs is possible but let's just assume one set for this translation or use a check.
+    // For brevity, I'll use the older "tokens" set as default or try to match python logic if I can access names.
+    int64_t input_shape[] = {F0_pred_shape_[0], F0_pred_shape_[1]};
+    std::vector<const char*> input_names = {"F0_pred"};
+
+    std::vector<Ort::Value> input_tensors;
+    
+    // Create tensors
+    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);
+    
+    input_tensors.push_back(Ort::Value::CreateTensor<float>(
+        memory_info, F0_pred.data(), F0_pred.size(), input_shape, F0_pred_shape_.size()));
+
+    // Check model output name usually
+    // Or get it from session
+    std::vector<const char*> output_names = {"har"};
+
+    auto output_tensors = model4_.Run(
+        Ort::RunOptions{nullptr},
+        input_names.data(),
+        input_tensors.data(),
+        input_tensors.size(),
+        output_names.data(),
+        output_names.size()
+    );
+
+    auto& output_tensor = output_tensors.front();
+            
+    // 获取输出信息
+    auto tensor_info = output_tensor.GetTensorTypeAndShapeInfo();
+    size_t element_count = tensor_info.GetElementCount();
+    auto output_shape = tensor_info.GetShape();
+    
+    float* output_data = output_tensor.GetTensorMutableData<float>();
+    
+    har.resize(element_count);
+    std::memcpy(har.data(), output_data, element_count * sizeof(float));
+}
+
+void Kokoro::_postprocess_x_to_audio(std::vector<float>& x, std::vector<float>& audio) {
+    // 将频谱转换为音频波形
+    // spec_part = x[:, :self.N_FFT//2+1, :]
+    // phase_part = x[:, self.N_FFT//2+1:, :]
+    int half_n_fft = N_FFT / 2 + 1;
+    int num_frames = x_shape_[2];
+    std::vector<float> spec_part(half_n_fft * num_frames);
+    std::vector<float> phase_part(half_n_fft * num_frames);
+    std::vector<float> cos_part(half_n_fft * num_frames);
+    spec_part.assign(x.begin(), x.begin() + half_n_fft * num_frames);
+    phase_part.assign(x.begin() + half_n_fft * num_frames, x.end());
+    
+    // spec = np.exp(spec_part)
+    // phase = np.sin(phase_part)
+    
+    // spec_torch = torch.from_numpy(spec).float()
+    // phase_torch = torch.from_numpy(phase).float()
+    // cos_part = torch.sqrt(1.0 - phase_torch.pow(2).clamp(0, 1))
+    
+    // real = spec_torch * cos_part
+    // imag = spec_torch * phase_torch
+    // complex_spec = torch.complex(real, imag)
+
+    for (int i = 0; i < half_n_fft * num_frames; i++) {
+        spec_part[i] = expf(spec_part[i]);
+        phase_part[i] = sinf(phase_part[i]);
+        cos_part[i] = sqrtf(1.f - std::max(0.f, std::min(powf(phase_part[i], 2), 1.0f)));
+    }
+
+    // save_file(spec_part, "spec.bin");
+    // save_file(phase_part, "phase.bin");
+    // save_file(cos_part, "cos_part.bin");
+
+    FFT_RESULT complex_spec(half_n_fft, vector<complex<float>>(num_frames));
+    for (int i = 0; i < half_n_fft; i++) {
+        for (int n = 0; n < num_frames; n++) {
+            float spec = spec_part[i * num_frames + n];
+
+            float real_part = spec * cos_part[i * num_frames + n];
+            float imag_part = spec * phase_part[i * num_frames + n];
+
+            complex_spec[i][n] = std::complex<float>(real_part, imag_part);
+        }
+    }
+    
+    // save_fft_result(complex_spec, "complex_spec.bin");
+
+    // audio = torch.istft(
+    //     complex_spec, n_fft=self.N_FFT, hop_length=self.HOP_LENGTH,
+    //     win_length=self.N_FFT, window=torch.hann_window(self.N_FFT),
+    //     center=True, return_complex=False
+    // )
+
+    audio = librosa::Feature::istft(complex_spec, N_FFT, HOP_LENGTH, "hann", true, "reflect", false);
+}
+
+bool Kokoro::inference_single_chunk(
+    std::vector<int>& input_ids,
+    const std::vector<float>& ref_s,
+    int actual_len,
+    float speed,
+    std::vector<float>& audio,
+    int& actual_content_frames,
+    int& total_frames
+) {
+    int ret = 0;
+    // Prepare inputs
+    bool is_doubled = false;
+    // printf("actual_len 2: %d\n", actual_len);
+
+    // save_file(input_ids, "input_ids.bin");
+
+    _prepare_input_ids(input_ids, actual_len, is_doubled);
+
+    // save_file(input_ids, "input_ids2.bin");
+
+    std::vector<int> input_lengths;
+    std::vector<uint8_t> text_mask;
+    _compute_external_preprocessing(input_ids, actual_len, input_lengths, text_mask);
+
+    // save_file(input_ids, "input_ids3.bin");
+
+    // outputs1 = self.session1.run(None, {'input_ids': input_ids.astype(np.int32), 'ref_s': ref_s, 'text_mask': text_mask.astype(np.uint8)})
+    std::vector<void*> model1_inputs{(void*)input_ids.data(), (void*)ref_s.data(), (void*)text_mask.data()};
+    std::vector<void*> model1_outputs{(void*)duration_.data(), (void*)d_.data()};
+
+    // printf("run model 1\n");
+    model1_.set_inputs(model1_inputs);
+    ret = model1_.run();
+    if (0 != ret) {
+        ALOGE("Run model1 failed! ret=0x%x", ret);
+        return false;
+    }
+    model1_.get_outputs(model1_outputs);
+
+    // save_file(input_ids, "input_ids.bin");
+    // save_file(ref_s, "ref_s.bin");
+    // save_file(duration_, "duration.bin");
+
+    // 处理duration并对齐
+    std::vector<int> pred_dur;
+    _process_duration(duration_, actual_len, speed, pred_dur, total_frames);
+    auto pred_aln_trg = _create_alignment_matrix(pred_dur, total_frames);
+
+    // save_file(pred_dur, "pred_dur.bin");
+    // save_file(pred_aln_trg, "pred_aln_trg.bin");
+    // save_file(d_, "d.bin");
+
+    // Model2: 预测F0和ASR特征
+    // d_transposed = np.transpose(d, (0, 2, 1))
+    // en = d_transposed @ pred_aln_trg
+    DynMat M_d = Eigen::Map<DynMat>(
+        d_.data(), 
+        d_shape_[1],  // 96
+        d_shape_[2]   // 640
+    );
+    
+    DynMat M_pred_aln_trg = Eigen::Map<DynMat>(
+        pred_aln_trg.data(), 
+        max_seq_len_,  // 96
+        total_frames   // 192
+    );
+
+    DynMat M_en = M_d.transpose() * M_pred_aln_trg;
+    std::vector<float> en(M_en.size());
+    std::memcpy(en.data(), M_en.data(), M_en.size() * sizeof(float));
+
+    // save_file(en, "en.bin");
+
+    std::vector<float> text_mask_float;
+    std::transform(text_mask.begin(), text_mask.end(),
+                   std::back_inserter(text_mask_float),
+                   [](uint8_t i) { return static_cast<float>(i); });
+
+    // outputs2 = self.session2.run(None, {
+    //     'en': en.astype(np.float32),
+    //     'ref_s': ref_s,
+    //     'input_ids': input_ids.astype(np.int32),
+    //     'text_mask': text_mask.astype(np.float32),
+    //     'pred_aln_trg': pred_aln_trg.astype(np.float32)
+    // })
+    // F0_pred, N_pred, asr = outputs2
+    std::vector<void*> model2_inputs{
+        (void*)en.data(), 
+        (void*)ref_s.data(), 
+        (void*)input_ids.data(),
+        (void*)text_mask_float.data(), 
+        (void*)pred_aln_trg.data()
+    };
+    std::vector<void*> model2_outputs{
+        (void*)F0_pred_.data(),
+        (void*)N_pred_.data(), 
+        (void*)asr_.data()
+    };
+
+    // printf("run model 2\n");
+    // printf("M_en.size(): %d\n", M_en.rows() * M_en.cols());
+    // printf("ref_s.size(): %d\n", ref_s.size());
+    // printf("input_ids.size(): %d\n", input_ids.size());
+    // printf("text_mask_float.size(): %d\n", text_mask_float.size());
+    // printf("pred_aln_trg.size(): %d\n", pred_aln_trg.size());
+    model2_.set_inputs(model2_inputs);
+    ret = model2_.run();
+    if (0 != ret) {
+        ALOGE("Run model2 failed! ret=0x%x", ret);
+        return false;
+    }
+    model2_.get_outputs(model2_outputs);
+
+    // save_file(F0_pred_, "F0_pred.bin");
+    // save_file(N_pred_, "N_pred.bin");
+    // save_file(asr_, "asr.bin");
+    
+    std::vector<float> har;
+    _compute_har_onnx(F0_pred_, har);
+
+    // har = load_file<float>("../har.bin");
+    // save_file(har, "har.bin");
+
+    // outputs3 = self.session3.run(None, {
+    //     'asr': asr, 'F0_pred': F0_pred, 'N_pred': N_pred, 'ref_s': ref_s, 'har': har
+    // })
+    // x = outputs3[0]
+    std::vector<void*> model3_inputs{
+        (void*)asr_.data(), 
+        (void*)F0_pred_.data(), 
+        (void*)N_pred_.data(),
+        (void*)ref_s.data(), 
+        (void*)har.data()
+    };
+
+    // printf("run model 3\n");
+    model3_.set_inputs(model3_inputs);
+    ret = model3_.run();
+    if (0 != ret) {
+        ALOGE("Run model3 failed! ret=0x%x", ret);
+        return false;
+    }
+    model3_.get_output(0, x_.data());
+
+    // save_file(x_, "x.bin");
+
+    // 转换为音频
+    _postprocess_x_to_audio(x_, audio);
+    actual_content_frames = std::accumulate(pred_dur.begin(), pred_dur.begin() + actual_len, 0);
+
+    // 如果输入被复制了，截取前一半音频
+    // if is_doubled:
+    //     audio = audio[:len(audio) // 2]
+    //     actual_content_frames = actual_content_frames // 2
+    //     total_frames = total_frames // 2
+    if (is_doubled) {
+        int audio_len = audio.size();
+        audio.erase(audio.begin() + audio_len / 2, audio.end());
+        actual_content_frames = actual_content_frames / 2;
+        total_frames = total_frames / 2;
+    }
+
+    // save_file(audio, "audio.bin");
+
+    return true;
+}
+
+bool Kokoro::inference(
+    std::vector<int>& input_ids,
+    const std::vector<float>& ref_s,
+    float speed,
+    float fade_out_duration,
+    std::vector<float>& audio
+) {
+    int actual_len = input_ids.size();
+    // 填充到固定长度
+    int padding_len = max_seq_len_ - actual_len;
+    if (padding_len > 0) {
+        std::vector<int> padding(padding_len, 0);
+        input_ids.insert(input_ids.end(), padding.begin(), padding.end());
+    }
+
+    int fade_samples = 0;
+    if (fade_out_duration > 0) {
+        fade_samples = int(SAMPLE_RATE * fade_out_duration);
+    }
+
+    // printf("actual_len 1: %d\n", actual_len);
+    
+    int actual_content_frames;
+    int total_frames;
+    if (!inference_single_chunk(input_ids, ref_s, actual_len, speed, audio, actual_content_frames, total_frames)) {
+        return false;
+    }
+
+    _trim_audio_by_content(
+        audio, actual_content_frames, total_frames, actual_len
+    );
+
+    if (fade_samples > 0)
+        apply_fade_out(audio, fade_samples);
+
+    return true;
+}
+
+bool Kokoro::run_batch_inference(std::vector<MergedGroup>& merged_group, const std::string& voice_name, 
+                       float speed, float fade_out_duration, int sr,
+                       std::vector<std::vector<float>>& audio_list
+) {
+    // 重新加载音色
+    if (voice_name_ != voice_name) {
+        if (!get_voice_style(voices_path_, voice_name)) {
+            ALOGW("Load voice %s failed, fallback to original voice %s", voice_name.c_str(), voice_name_.c_str());
+        }
+    }
+    
+    // 批量推理
+    for (auto& group : merged_group) {
+        if (group.is_long_split) {
+            // 长句分割：对每个子片段推理后拼接
+            std::vector<float> combined_audio;
+            for (auto& sub : group.sub_results) {
+                int phoneme_len = sub.input_ids.size() - 2;
+                auto ref_s = load_voice_embedding(phoneme_len);
+
+                std::vector<float> audio;
+                if (!inference(sub.input_ids, ref_s, speed, 0, audio)) {
+                    return false;
+                }
+                combined_audio.insert(combined_audio.end(), audio.begin(), audio.end());
+            }
+            audio_list.push_back(combined_audio);
+        } else {
+            // 短句或合并句：直接推理
+            // DEBUG
+            // group.input_ids = load_file<int>("../input_ids.bin");
+            // printf("group.input_ids.size() = %d\n", group.input_ids.size());
+            int phoneme_len = group.input_ids.size() - 2;
+
+             auto ref_s = load_voice_embedding(phoneme_len);
+            std::vector<float> audio;
+            if (!inference(group.input_ids, ref_s, speed, fade_out_duration, audio)) {
+                return false;
+            }
+            audio_list.push_back(audio);
+        }
+    }
+
+    return true;
+}
+
+void Kokoro::split_input_ids_semantic(std::vector<int>& input_ids, int max_seq_len_, int& actual_len) {
+    // input_ids分割
+    // content = input_ids[0, 1:-1]
+    // chunk_with_special = np.concatenate([[0], content, [0]])
+    actual_len = input_ids.size();
+
+    // 填充到固定长度
+    int padding_len = max_seq_len_ - actual_len;
+    if (padding_len > 0) {
+        std::vector<int> padding(padding_len, 0);
+        input_ids.insert(input_ids.end(), padding.begin(), padding.end());
+    }
+}
+
+void Kokoro::_trim_audio_by_content(std::vector<float>& audio, int actual_content_frames, int total_frames, int actual_len) {
+    // 根据实际内容比例裁剪音频
+    int padding_len = max_seq_len_ - actual_len;
+    if (padding_len > 0) {
+        float content_ratio = actual_content_frames * 1.0f / total_frames;
+        int audio_len_to_keep = int(audio.size() * content_ratio);
+        audio.resize(audio_len_to_keep);
+    }
+}
+
+void Kokoro::apply_fade_out(std::vector<float>& audio, int fade_samples) {
+    // 末尾淡出音频
+    if (audio.size() <= fade_samples || fade_samples <= 0)
+        return;
+
+    std::vector<float> fade_out = linspace(1.0f, 0.0f, fade_samples);
+    // audio_faded = audio.copy()
+    // audio_faded[-fade_samples:] *= fade_out
+    // return audio_faded
+    for (int i = 0; i < fade_samples; i++) {
+        audio[i - fade_samples + audio.size()] *= fade_out[i];
+    }
+}
+
+bool Kokoro::tts(
+    const std::string& text,
+    const std::string& lang_code,
+    const std::string& voice_name,
+    float speed,
+    int sample_rate,
+    float fade_out,
+    float pause_duration,
+    std::vector<float>& generated_audio
+) {
+    // merged_groups = process_and_merge_sentences(
+    //     args.text, args.lang, g2p, g2p_type, vocab, max_merge_len=args.max_len
+    // )
+    auto merged_groups = process_and_merge_sentences(text, lang_code, max_seq_len_);
+
+    // save_file(merged_groups[0].input_ids, "input_ids.bin");
+
+    // audio_list = run_batch_inference(
+    //     engine, merged_groups, args.voice, vocab, 
+    //     speed=SPEED, fade_out_duration=args.fade_out
+    // )
+    std::vector<std::vector<float>> audio_list;
+    if (!run_batch_inference(merged_groups, voice_name, speed, fade_out, sample_rate, audio_list)) {
+        ALOGE("run_batch_inference failed!");
+        return false;
+    }
+
+    generated_audio = audio_numpy_concat(audio_list, sample_rate, speed, pause_duration);
+
+    return true;
+}
+
+void Kokoro::generate_input_ids_from_text(const std::string& text, std::vector<int>& input_ids, std::string& phonemes) {
+    phonemes = tokenizer_->phonemize(text);
+    input_ids = tokenizer_->tokenize(phonemes);
+    input_ids.insert(input_ids.begin(), 0);
+    input_ids.push_back(0);
+}
+
+// 迭代版本（避免递归栈溢出）
+std::vector<SentenceInfo> Kokoro::split_long_sentence(
+    const std::string& sentence,
+    const std::string& lang_code,
+    int max_merge_len
+) {
+    std::vector<SentenceInfo> result;
+    
+    // 使用栈来模拟递归
+    struct Task {
+        std::string sentence;
+        int depth;
+        
+        Task(const std::string& s, int d) : sentence(s), depth(d) {}
+    };
+    
+    std::vector<Task> stack;
+    stack.emplace_back(sentence, 0);
+    
+    const int MAX_DEPTH = 20;
+    
+    while (!stack.empty()) {
+        Task current = std::move(stack.back());
+        stack.pop_back();
+        
+        if (current.depth > MAX_DEPTH) {
+            continue; // 跳过超过最大深度的任务
+        }
+        
+        try {
+            std::vector<int> input_ids;
+            std::string phonemes;
+  
+            generate_input_ids_from_text(current.sentence, input_ids, phonemes);
+            
+            // 计算内容长度
+            int content_len = input_ids.size();
+            
+            if (content_len <= max_merge_len) {
+                result.emplace_back(current.sentence, input_ids, phonemes, content_len);
+                continue;
+            }
+            
+            // 需要分割
+            std::string first_half, second_half;
+            
+            if (lang_code == std::string("z") || lang_code == std::string("j")) {
+                // 中文/日文分割
+                size_t mid = current.sentence.length() / 2;
+                first_half = current.sentence.substr(0, mid);
+                second_half = current.sentence.substr(mid);
+            } else {
+                // 英文分割
+                std::istringstream iss(current.sentence);
+                std::vector<std::string> words;
+                std::string word;
+                
+                while (iss >> word) {
+                    words.push_back(word);
+                }
+                
+                if (words.size() > 1) {
+                    size_t mid_word = words.size() / 2;
+                    
+                    // 构建前半部分
+                    std::ostringstream oss1;
+                    for (size_t i = 0; i < mid_word; ++i) {
+                        if (i > 0) oss1 << " ";
+                        oss1 << words[i];
+                    }
+                    first_half = oss1.str();
+                    
+                    // 构建后半部分
+                    std::ostringstream oss2;
+                    for (size_t i = mid_word; i < words.size(); ++i) {
+                        if (i > mid_word) oss2 << " ";
+                        oss2 << words[i];
+                    }
+                    second_half = oss2.str();
+                } else {
+                    // 只有一个单词，按字符分割
+                    size_t mid = current.sentence.length() / 2;
+                    first_half = current.sentence.substr(0, mid);
+                    second_half = current.sentence.substr(mid);
+                }
+            }
+            
+            // 将分割后的任务推入栈中（先处理后半部分，再处理前半部分）
+            stack.emplace_back(second_half, current.depth + 1);
+            stack.emplace_back(first_half, current.depth + 1);
+            
+        } catch (...) {
+            // 异常处理
+            continue;
+        }
+    }
+    
+    return result;
+}
+
+std::vector<MergedGroup> Kokoro::process_and_merge_sentences(
+    const std::string& text,
+    const std::string& lang_code,
+    int max_merge_len
+) {
+    // 1. 清理文本
+    std::string cleaned_text = clean_text(text);
+    
+    // 2. 分割句子
+    std::vector<std::string> sentences = split_sentence(cleaned_text, lang_code);
+    // printf("sentence num: %d\n", sentences.size());
+    
+    // 3. 为每个句子生成 input_ids
+    std::vector<SentenceInfo> sentence_data;
+    sentence_data.reserve(sentences.size());
+    
+    for (const auto& sentence : sentences) {
+        try {
+            std::vector<int> input_ids;
+            std::string phonemes;
+
+            // printf("sentence: %s\n", sentence.c_str());
+            
+            generate_input_ids_from_text(sentence, input_ids, phonemes);
+            
+            int content_len = static_cast<int>(input_ids.size());
+            
+            if (content_len <= max_merge_len) {
+                // 短句
+                sentence_data.emplace_back(sentence, input_ids, phonemes, content_len);
+            } else {
+                // 长句，需要分割
+                std::vector<SentenceInfo> sub_results = split_long_sentence(
+                    sentence, lang_code, max_merge_len);
+                
+                sentence_data.emplace_back(sentence, sub_results);
+            }
+            
+        } catch (const std::exception& e) {
+            std::cerr << "错误处理句子 '" << sentence << "': " << e.what() << std::endl;
+        } catch (...) {
+            std::cerr << "未知错误处理句子 '" << sentence << "'" << std::endl;
+        }
+    }
+    
+    // 4. 检查是否生成了任何数据
+    if (sentence_data.empty()) {
+        throw std::runtime_error("没有生成任何 input_ids");
+    }
+    
+    // 5. 长句保持分割，短句合并
+    std::vector<MergedGroup> merged_groups;
+    merged_groups.reserve(sentence_data.size());  // 预分配
+    
+    size_t i = 0;
+    while (i < sentence_data.size()) {
+        const SentenceInfo& current = sentence_data[i];
+        
+        if (current.is_long) {
+            // 长句：直接添加分割结果
+            merged_groups.emplace_back(current.sub_results);
+            ++i;
+        } else {
+            // 短句：尝试合并
+            std::vector<std::string> merged_sentences;
+            int total_len = 0;
+            size_t j = i;
+            
+            // 尝试合并尽可能多的短句
+            while (j < sentence_data.size() && !sentence_data[j].is_long) {
+                int next_len = sentence_data[j].content_len;
+                
+                // 检查是否超过最大长度
+                if (total_len + next_len <= max_merge_len) {
+                    merged_sentences.push_back(sentence_data[j].sentence);
+                    total_len += next_len;
+                    ++j;
+                } else {
+                    break;
+                }
+            }
+            
+            // 如果第一个句子就超过长度，至少包含它
+            if (j == i) {
+                merged_sentences.push_back(sentence_data[i].sentence);
+                ++j;
+            }
+            
+            // 生成合并后的文本
+            std::ostringstream oss;
+            for (size_t k = 0; k < merged_sentences.size(); ++k) {
+                if (k > 0) {
+                    oss << " ";  // 用空格连接句子
+                }
+                oss << merged_sentences[k];
+            }
+            std::string merged_text = oss.str();
+            
+            // 重新生成合并后的 input_ids
+            std::vector<int> merged_input_ids;
+            std::string merged_phonemes;
+            
+            generate_input_ids_from_text(merged_text, merged_input_ids, merged_phonemes);
+            
+            merged_groups.emplace_back(merged_input_ids, merged_phonemes);
+            
+            i = j;  // 移动到下一组
+        }
+    }
+    
+    return merged_groups;    
+}
+
+std::vector<float> Kokoro::load_voice_embedding(int phoneme_len) {
+    // if phoneme_len is not None and phoneme_len < pack.shape[0]:
+    //     ref_s = pack[phoneme_len:phoneme_len+1]
+    // else:
+    //     idx = pack.shape[0] // 2
+    //     ref_s = pack[idx:idx+1]
+    std::vector<float> ref_s(STYLE_DIM);
+    if (phoneme_len < voice_pack_size_) {
+        ref_s.assign(voice_tensor_.begin() + phoneme_len * STYLE_DIM, voice_tensor_.begin() + (phoneme_len + 1) * STYLE_DIM);
+    } else {
+        int idx = voice_pack_size_ / 2;
+        ref_s.assign(voice_tensor_.begin() + idx * STYLE_DIM, voice_tensor_.begin() + (idx + 1) * STYLE_DIM);
+    }
+    return ref_s;
+}

cpp/src/Kokoro.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <map>
+#include <optional>
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+#include "ax_model_runner/ax_model_runner.hpp"
+#include "onnxruntime_cxx_api.h"
+
+// Forward declarations or placeholder for dependencies
+class Tokenizer;
+struct KoKoroConfig;
+
+// Constants from config
+const int MAX_PHONEME_LENGTH = 510; // max position embedding - 2
+const int SAMPLE_RATE = 24000;      // Example value
+
+// Preprocess parameters
+const int FIXED_SEQ_LEN = 96;
+const int N_FFT = 20;
+const int HOP_LENGTH = 5;
+const int DOUBLE_INPUT_THRESHOLD = 32;  // 输入长度小于此值时复制一倍,适配短文本
+const int STYLE_DIM = 256;
+
+const float DEFAULT_SPEED = 1.0;
+const float DEFAULT_FADE_OUT = 0.05;
+const float DEFAULT_PAUSE = 0.05;
+
+
+// 定义结构体来存储句子信息
+struct SentenceInfo {
+    std::string sentence;
+    std::vector<int> input_ids;  
+    std::string phonemes;    
+    int content_len;
+    bool is_long;
+    std::vector<SentenceInfo> sub_results;  // 长句的分割结果
+    
+    // 构造函数：短句
+    SentenceInfo(const std::string& s, 
+                 const std::vector<int>& ids,
+                 const std::string& ph,
+                 int len)
+        : sentence(s), input_ids(ids), phonemes(ph), 
+          content_len(len), is_long(false) {}
+    
+    // 构造函数：长句
+    SentenceInfo(const std::string& s, 
+                 const std::vector<SentenceInfo>& sub)
+        : sentence(s), content_len(0), is_long(true), sub_results(sub) {}
+};
+
+// 合并组的结果
+struct MergedGroup {
+    bool is_long_split = false;
+    std::vector<int> input_ids;
+    std::string phonemes;
+    std::vector<SentenceInfo> sub_results;
+    
+    // 构造函数：短句合并组
+    MergedGroup(const std::vector<int>& ids, const std::string& ph)
+        : is_long_split(false), input_ids(ids), phonemes(ph) {}
+    
+    // 构造函数：长句分割组
+    MergedGroup(const std::vector<SentenceInfo>& sub)
+        : is_long_split(true), sub_results(sub) {}
+};
+
+
+class Kokoro {
+public:
+    Kokoro();
+    ~Kokoro();
+
+    bool init(const std::string& model_path, 
+        int max_seq_len = FIXED_SEQ_LEN, 
+        const std::string& voices_path = "./voices", 
+        const std::string& voice_name = "af_heart",
+        const std::string& vocab_path = "dict/vocab.txt");
+    
+    bool get_voice_style(const std::string& voices_path, const std::string& voice_name);
+
+    bool tts(
+        const std::string& text,
+        const std::string& lang_code,
+        const std::string& voice_name,
+        float speed,
+        int sample_rate,
+        float fade_out,
+        float pause_duration,
+        std::vector<float>& generated_audio
+    );
+
+    bool inference(
+        std::vector<int>& input_ids,
+        const std::vector<float>& ref_s,
+        float speed,
+        float fade_out_duration,
+        std::vector<float>& audio
+    );
+
+    bool run_batch_inference(std::vector<MergedGroup>& merged_group, const std::string& voice_name, 
+                       float speed, float fade_out_duration, int sr,
+                       std::vector<std::vector<float>>& audio_list
+    );
+
+private:
+    // Internal methods
+    bool inference_single_chunk(
+        std::vector<int>& input_ids,
+        const std::vector<float>& ref_s,
+        int actual_len,
+        float speed,
+        std::vector<float>& audio,
+        int& actual_content_frames,
+        int& total_frames
+    );
+
+    void split_input_ids_semantic(std::vector<int>& input_ids, int fixed_seq_len, int& actual_len);
+
+    void _trim_audio_by_content(std::vector<float>& audio, int actual_content_frames, int total_frames, int actual_len);
+
+    void apply_fade_out(std::vector<float>& audio, int fade_samples);
+
+    std::vector<std::string> _split_phonemes(const std::string& phonemes);
+
+    void _prepare_input_ids(std::vector<int>& input_ids, int& actual_len, bool& is_doubled); 
+    
+    void _compute_external_preprocessing(const std::vector<int>& input_ids, int actual_len, std::vector<int>& input_lengths, std::vector<uint8_t>& text_mask);
+
+    // 处理duration并对齐
+    void _process_duration(const std::vector<float>& duration, int actual_len, float speed, std::vector<int>& pred_dur, int& total_frames);
+    std::vector<float> _create_alignment_matrix(const std::vector<int>& pred_dur, int total_frames);
+
+    void _compute_har_onnx(std::vector<float>& F0_pred, std::vector<float>& har);
+
+    void _postprocess_x_to_audio(std::vector<float>& x, std::vector<float>& audio);
+
+    void generate_input_ids_from_text(const std::string& text, std::vector<int>& input_ids, std::string& phonemes);
+    
+    std::vector<SentenceInfo> split_long_sentence(
+        const std::string& sentence,
+        const std::string& lang_code,
+        int max_merge_len = 78
+    );
+
+    std::vector<MergedGroup> process_and_merge_sentences(
+        const std::string& text,
+        const std::string& lang_code,
+        int max_merge_len = 96
+    );
+
+    std::vector<float> load_voice_embedding(int phoneme_len);
+
+private:
+    int max_seq_len_;
+    std::string voices_path_;
+    std::string voice_name_;
+    int voice_pack_size_;
+    std::vector<float> voice_tensor_;
+
+    AxModelRunner model1_, model2_, model3_;
+    Ort::Env env_;
+    Ort::Session model4_{nullptr};
+    Ort::AllocatorWithDefaultOptions allocator_;
+    
+    // Placeholder for voices data: map from name to vector
+    std::map<std::string, std::vector<float>> voices_;
+    
+    std::unique_ptr<Tokenizer> tokenizer_;
+
+    // model outputs data
+    std::vector<float> duration_, d_;
+    std::vector<float> F0_pred_, N_pred_, asr_;
+    std::vector<float> x_;
+
+    // model outputs shape
+    std::vector<int> duration_shape_, d_shape_;
+    std::vector<int> F0_pred_shape_;
+    std::vector<int> x_shape_;
+};

cpp/src/PinyinFinder.cpp

@@ -0,0 +1,194 @@
+#include "PinyinFinder.h"
+
+#include <regex>
+#include <vector>
+#include <locale>
+#include <limits>
+#include <cstring>
+#include <cstdio>
+
+PinyinFinder::PinyinFinder() {}
+
+PinyinFinder::~PinyinFinder() {}
+
+bool PinyinFinder::init(const std::string& singleCharacterDictPath,
+          const std::string& wordsDictPath) {
+  
+  FILE* fp = fopen(singleCharacterDictPath.c_str(), "r");
+  if (fp == NULL) {
+    LOG_WARNING << "Failed to open file: " << singleCharacterDictPath << std::endl;
+    return false;
+  }
+  char line[4096] = {0};
+  int tn = 0;
+  while (fgets(line, sizeof(line) - 1, fp)) {
+    if (line[0] == '#') continue;
+    size_t len = strlen(line);
+    while (len > 0 && (line[len-1] == '\r' || line[len-1] == '\n')) {
+        line[--len] = '\0';
+    }
+    if (len == 0) continue;
+
+    // Format: U+XXXX: pinyin # comment
+    if (strncmp(line, "U+", 2) != 0) continue;
+    
+    char* colon = strchr(line, ':');
+    if (!colon) continue;
+    
+    // Parse Hex
+    // U+ is at line[0], hex starts at line[2], length is colon - line - 2
+    std::string hexStr(line + 2, colon - (line + 2));
+    uint32_t unicode = 0;
+    try {
+        unicode = std::stoul(hexStr, nullptr, 16);
+    } catch(...) { continue; }
+    
+    // Parse Pinyin
+    char* pinyinStart = colon + 1;
+    while (*pinyinStart == ' ' || *pinyinStart == '\t') pinyinStart++;
+    
+    char* hash = strchr(pinyinStart, '#');
+    char* pinyinEnd = hash ? hash : (line + len);
+    while (pinyinEnd > pinyinStart && (*(pinyinEnd-1) == ' ' || *(pinyinEnd-1) == '\t')) {
+        pinyinEnd--;
+    }
+    
+    if (pinyinEnd <= pinyinStart) continue;
+    
+    std::string pinyin(pinyinStart, pinyinEnd - pinyinStart);
+    
+    UnicodeStr ustr;
+    ustr.append(1, static_cast<UnicodeCharT>(unicode));
+    
+    std::vector<std::string> ss;
+    BasicStringUtil::SplitString(pinyin.c_str(), pinyin.size(), ',', &ss);
+    if (!ss.empty()) {
+        word_pinyin_dict_[ustr] = ss[0];
+    }
+    tn += 1;
+  }
+  LOG_INFO << "total pinyin character count: " << tn << std::endl;
+
+  fclose(fp);
+  fp = fopen(wordsDictPath.c_str(), "r");
+  if (fp == NULL) {
+    LOG_WARNING << "Failed to open file: " << wordsDictPath << std::endl;
+    return false;
+  }
+  
+  // Format: word: pinyin1 pinyin2
+  int pc = 0;
+  while (fgets(line, sizeof(line) - 1, fp)) {
+    if (line[0] == '#') continue;
+    
+    // Strip comments
+    char* comment = strchr(line, '#');
+    if (comment) *comment = '\0';
+    
+    size_t len = strlen(line);
+    while (len > 0 && (line[len-1] == '\r' || line[len-1] == '\n')) {
+        line[--len] = '\0';
+    }
+    if (len == 0) continue;
+
+    char* colon = strchr(line, ':');
+    if (!colon) continue;
+    
+    // Parse Word
+    char* wordEnd = colon;
+    while (wordEnd > line && (*(wordEnd-1) == ' ' || *(wordEnd-1) == '\t')) {
+        wordEnd--;
+    }
+    std::string word(line, wordEnd - line);
+    if (word.empty()) continue;
+    
+    // Parse Pinyin
+    char* pinyinStart = colon + 1;
+    while (*pinyinStart == ' ' || *pinyinStart == '\t') pinyinStart++;
+    
+    char* pinyinEnd = line + len;
+    while (pinyinEnd > pinyinStart && (*(pinyinEnd-1) == ' ' || *(pinyinEnd-1) == '\t')) {
+        pinyinEnd--;
+    }
+    
+    std::string pinyin(pinyinStart, pinyinEnd - pinyinStart);
+    
+    UnicodeStr ustr;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), ustr);
+    word_pinyin_dict_[ustr] = pinyin;
+
+    pc += 1;
+  }
+  LOG_INFO << "total pinyin phrase count: " << pc << std::endl;
+  return true;
+}
+
+void PinyinFinder::find_best_pinyin(const std::string& phrasestr, std::vector<std::string>& pinyins) {
+  UnicodeStr phrase;
+  BasicStringUtil::u8tou16(phrasestr.c_str(), phrasestr.size(), phrase);
+  int n = phrase.size();
+  if (n == 0) return;
+
+  std::vector<std::vector<int>> dp(n, std::vector<int>(n, std::numeric_limits<int>::max()));
+  std::vector<std::vector<int>> opts(n, std::vector<int>(n, -1));
+  
+  for (int length = 1; length <= n; ++length) {
+    for (int i = 0; i <= n - length; ++i) {
+      int j = i + length - 1;
+      if (length == 1) {
+        dp[i][j] = 1;
+        opts[i][j] = j;
+      } else {
+        int maxtry = length;
+        if (length > kMaxChars) {
+          maxtry = kMaxChars;
+        }
+        for (int k = maxtry; k >= 1; k--) {
+          int to = i + k - 1;
+          UnicodeStr sub = phrase.substr(i, k);
+          
+          if (word_pinyin_dict_.find(sub) != word_pinyin_dict_.end()) {
+            if (to == j) {
+              dp[i][j] = k == 1 ? 1 : 0; // Preference for longer matches
+              opts[i][j] = j;
+            } else {
+              // Cost calculation logic from original code
+              // k == 1 means we took a single char
+              int cost = (k == 1) ? (dp[to + 1][j] + 1) : dp[to + 1][j];
+              
+              if (dp[i][j] > cost) {
+                dp[i][j] = cost;
+                opts[i][j] = to;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Construct the best pinyin string using dp and opts
+  int i = 0;
+  int j = n - 1;
+  while (i <= j) {
+    int opt = opts[i][j];
+    if(opt == -1){
+      opt = i;
+    }
+    UnicodeStr sub = phrase.substr(i, opt - i + 1);
+    auto it = word_pinyin_dict_.find(sub);
+    
+    if(it == word_pinyin_dict_.end()){
+      std::string tstr;
+      BasicStringUtil::u16tou8(sub.data(), sub.size(), tstr);
+      pinyins.emplace_back(tstr);
+    } else {
+      std::vector<std::string> tmps;
+      BasicStringUtil::SplitString(it->second.c_str(), it->second.size(), ' ', &tmps);
+      for(auto& str: tmps){
+        pinyins.emplace_back(str);
+      }
+    }
+    i = opt + 1;
+  }
+}

cpp/src/PinyinFinder.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include "Utils.h"
+
+class PinyinFinder {
+public:
+    using UnicodeCharT = char16_t;
+    using UnicodeStr = std::u16string;
+
+    PinyinFinder();
+    ~PinyinFinder();
+
+    bool init(const std::string& singleCharacterDictPath, const std::string& wordsDictPath);
+
+    void find_best_pinyin(const std::string& phrasestr, std::vector<std::string>& pinyins);
+
+private:
+    std::unordered_map<UnicodeStr, std::string> word_pinyin_dict_;
+    static const int kMaxChars = 8; // 最大匹配长度，通常不需要太大
+};

cpp/src/Tokenizer.cpp

@@ -0,0 +1,69 @@
+#include "Tokenizer.h"
+#include "JiebaProcessor.h"
+#include "ZHG2P.h"
+#include <iostream>
+#include <vector>
+
+Tokenizer::Tokenizer(const TokenizerConfig& config, const std::map<std::string, int>& vocab) 
+    : vocab_(vocab) {
+    
+    std::string d = config.dict_dir;
+    if (!d.empty() && d.back() != '/') d += "/";
+    
+    std::string jieba_dict = d + config.jieba_dict;
+    std::string hmm_model = d + config.hmm_model;
+    std::string user_dict = d + config.user_dict;
+    std::string idf_path = d + config.idf_path;
+    std::string stop_word_path = d + config.stop_word_path;
+    std::string pinyin_char = d + config.pinyin_char;
+    std::string pinyin_phrase = d + config.pinyin_phrase;
+    std::string cmu_dict = d + config.cmu_dict;
+
+    try {
+        processor_ = std::make_shared<JiebaProcessor>(
+            jieba_dict, hmm_model, user_dict, idf_path, stop_word_path, pinyin_char, pinyin_phrase
+        );
+        g2p_ = std::make_unique<ZHG2P>(processor_, "1.1", "<unk>", cmu_dict);
+    } catch (const std::exception& e) {
+        std::cerr << "Failed to initialize Tokenizer dependencies: " << e.what() << std::endl;
+    }
+}
+
+Tokenizer::~Tokenizer() = default;
+
+static std::vector<std::string> split_utf8(const std::string& str) {
+    std::vector<std::string> chars;
+    for (size_t i = 0; i < str.length();) {
+        unsigned char c = static_cast<unsigned char>(str[i]);
+        size_t char_len = 0;
+        if (c < 0x80) char_len = 1;
+        else if ((c & 0xE0) == 0xC0) char_len = 2;
+        else if ((c & 0xF0) == 0xE0) char_len = 3;
+        else if ((c & 0xF8) == 0xF0) char_len = 4;
+        else char_len = 1; 
+
+        if (i + char_len > str.length()) char_len = str.length() - i;
+        
+        chars.push_back(str.substr(i, char_len));
+        i += char_len;
+    }
+    return chars;
+}
+
+std::vector<int> Tokenizer::tokenize(const std::string& phonemes) {
+    std::vector<int> tokens;
+    std::vector<std::string> chars = split_utf8(phonemes);
+    
+    for (const auto& c : chars) {
+        if (vocab_.count(c)) {
+            tokens.push_back(vocab_.at(c));
+        }
+    }
+    return tokens;
+}
+
+std::string Tokenizer::phonemize(const std::string& text, bool norm) {
+    if (!g2p_) return text;
+    auto result = (*g2p_)(text);
+    return result.first; 
+}

cpp/src/Tokenizer.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+
+class ZHG2P;
+class JiebaProcessor;
+
+struct TokenizerConfig {
+    std::string dict_dir = "dict/";
+    std::string jieba_dict = "jieba.dict.utf8";
+    std::string hmm_model = "hmm_model.utf8";
+    std::string user_dict = "user.dict.utf8";
+    std::string idf_path = "idf.utf8";
+    std::string stop_word_path = "stop_words.utf8";
+    std::string pinyin_char = "pinyin.txt";
+    std::string pinyin_phrase = "pinyin_phrase.txt";
+    std::string cmu_dict = "cmudict-0.7b/cmudict.dict";
+};
+
+class Tokenizer {
+public:
+    Tokenizer(const TokenizerConfig& config = {}, const std::map<std::string, int>& vocab = {});
+    ~Tokenizer();
+    
+    std::vector<int> tokenize(const std::string& phonemes);
+    std::string phonemize(const std::string& text, bool norm = true);
+
+private:
+    std::map<std::string, int> vocab_;
+    std::shared_ptr<JiebaProcessor> processor_;
+    std::unique_ptr<ZHG2P> g2p_;
+};

cpp/src/ToneSandhi.cpp

@@ -0,0 +1,322 @@
+#include "ToneSandhi.h"
+#include "Utils.h"
+#include <iostream>
+#include <algorithm>
+
+// Helper to check if string ends with tone 4 '4'
+static bool is_tone4(const std::string& final) {
+    return !final.empty() && final.back() == '4';
+}
+
+// Helper to check if string ends with tone 3 '3'
+static bool is_tone3(const std::string& final) {
+    return !final.empty() && final.back() == '3';
+}
+
+// Change tone to '2'
+static void to_tone2(std::string& final) {
+    if (!final.empty() && isdigit(final.back())) {
+        final.back() = '2';
+    } else {
+        final += '2';
+    }
+}
+
+// Change tone to '5' (neutral)
+static void to_tone5(std::string& final) {
+    if (!final.empty() && isdigit(final.back())) {
+        final.back() = '5';
+    } else {
+        final += '5';
+    }
+}
+
+ToneSandhi::ToneSandhi() {
+    punc = "、：，；。？！“”‘’':,;.?!" ;
+    
+    must_neural_tone_words = {
+        "麻烦", "麻利", "鸳鸯", "高粱", "骨头", "骆驼", "马虎", "首饰", "馒头", "馄饨", "风筝",
+        "难为", "队伍", "阔气", "闺女", "门道", "锄头", "铺盖", "铃铛", "铁匠", "钥匙", "里脊",
+        "里头", "部分", "那么", "道士", "造化", "迷糊", "连累", "这么", "这个", "运气", "过去",
+        "软和", "转悠", "踏实", "跳蚤", "跟头", "趔趄", "财主", "豆腐", "讲究", "记性", "记号",
+        "认识", "规矩", "见识", "裁缝", "补丁", "衣裳", "衣服", "衙门", "街坊", "行李", "行当",
+        "蛤蟆", "蘑菇", "薄荷", "葫芦", "葡萄", "萝卜", "荸荠", "苗条", "苗头", "苍蝇", "芝麻",
+        "舒服", "舒坦", "舌头", "自在", "膏药", "脾气", "脑袋", "脊梁", "能耐", "胳膊", "胭脂",
+        "胡萝", "胡琴", "胡同", "聪明", "耽误", "耽搁", "耷拉", "耳朵", "老爷", "老实", "老婆",
+        "戏弄", "将军", "翻腾", "罗嗦", "罐头", "编辑", "结实", "红火", "累赘", "糨糊", "糊涂",
+        "精神", "粮食", "簸箕", "篱笆", "算计", "算盘", "答应", "笤帚", "笑语", "笑话", "窟窿",
+        "窝囊", "窗户", "稳当", "稀罕", "称呼", "秧歌", "秀气", "秀才", "福气", "祖宗", "砚台",
+        "码头", "石榴", "石头", "石匠", "知识", "眼睛", "眯缝", "眨巴", "眉毛", "相声", "盘算",
+        "白净", "痢疾", "痛快", "疟疾", "疙瘩", "疏忽", "畜生", "生意", "甘蔗", "琵琶", "琢磨",
+        "琉璃", "玻璃", "玫瑰", "玄乎", "狐狸", "状元", "特务", "牲口", "牙碜", "牌楼", "爽快",
+        "爱人", "热闹", "烧饼", "烟筒", "烂糊", "点心", "炊帚", "灯笼", "火候", "漂亮", "滑溜",
+        "溜达", "温和", "清楚", "消息", "浪头", "活泼", "比方", "正经", "欺负", "模糊", "槟榔",
+        "棺材", "棒槌", "棉花", "核桃", "栅栏", "柴火", "架势", "枕头", "枇杷", "机灵", "本事",
+        "木头", "木匠", "朋友", "月饼", "月亮", "暖和", "明白", "时候", "新鲜", "故事", "收拾",
+        "收成", "提防", "挖苦", "挑剔", "指甲", "指头", "拾掇", "拳头", "拨弄", "招牌", "招呼",
+        "抬举", "护士", "折腾", "扫帚", "打量", "打算", "打扮", "打听", "打发", "扎实", "扁担",
+        "戒指", "懒得", "意识", "意思", "悟性", "怪物", "思量", "怎么", "念头", "念叨", "别人",
+        "快活", "忙活", "志气", "心思", "得罪", "张罗", "弟兄", "开通", "应酬", "庄稼", "干事",
+        "帮手", "帐篷", "希罕", "师父", "师傅", "巴结", "巴掌", "差事", "工夫", "岁数", "屁股",
+        "尾巴", "少爷", "小气", "小伙", "将就", "对头", "对付", "寡妇", "家伙", "客气", "实在",
+        "官司", "学问", "字号", "嫁妆", "媳妇", "媒人", "婆家", "娘家", "委屈", "姑娘", "姐夫",
+        "妯娌", "妥当", "妖精", "奴才", "女婿", "头发", "太阳", "大爷", "大方", "大意", "大夫",
+        "多少", "多么", "外甥", "壮实", "地道", "地方", "在乎", "困难", "嘴巴", "嘱咐", "嘟囔",
+        "嘀咕", "喜欢", "喇嘛", "喇叭", "商量", "唾沫", "哑巴", "哈欠", "哆嗦", "咳嗽", "和尚",
+        "告诉", "告示", "含糊", "吓唬", "后头", "名字", "名堂", "合同", "吆喝", "叫唤", "口袋",
+        "厚道", "厉害", "千斤", "包袱", "包涵", "匀称", "勤快", "动静", "动弹", "功夫", "力气",
+        "前头", "刺猬", "刺激", "别扭", "利落", "利索", "利害", "分析", "出息", "凑合", "凉快",
+        "冷战", "冤枉", "冒失", "养活", "关系", "先生", "兄弟", "便宜", "使唤", "佩服", "作坊",
+        "体面", "位置", "似的", "伙计", "休息", "什么", "人家", "亲戚", "亲家", "交情", "云彩",
+        "事情", "买卖", "主意", "丫头", "丧气", "两口", "东西", "东家", "世故", "不由", "下水",
+        "下巴", "上头", "上司", "丈夫", "丈���", "一辈", "那个", "菩萨", "父亲", "母亲", "咕噜",
+        "邋遢", "费用", "冤家", "甜头", "介绍", "荒唐", "大人", "泥鳅", "幸福", "熟悉", "计划",
+        "扑腾", "蜡烛", "姥爷", "照顾", "喉咙", "吉他", "弄堂", "蚂蚱", "凤凰", "拖沓", "寒碜",
+        "糟蹋", "倒腾", "报复", "逻辑", "盘缠", "喽啰", "牢骚", "咖喱", "扫把", "惦记"
+    };
+
+    must_not_neural_tone_words = {
+        "男子", "女子", "分子", "原子", "量子", "莲子", "石子", "瓜子", "电子", "人人", "虎虎",
+        "幺幺", "干嘛", "学子", "哈哈", "数数", "袅袅", "局地", "以下", "娃哈哈", "花花草草", "留得",
+        "耕地", "想想", "熙熙", "攘攘", "卵子", "死死", "冉冉", "恳恳", "佼佼", "吵吵", "打打",
+        "考考", "整整", "莘莘", "落地", "算子", "家家户户", "青青"
+    };
+}
+
+void ToneSandhi::setPinyinProvider(PinyinProvider provider) {
+    pinyin_provider = provider;
+}
+
+bool ToneSandhi::_all_tone_three(const std::vector<std::string>& finals) {
+    for (const auto& f : finals) {
+        if (!is_tone3(f)) return false;
+    }
+    return true;
+}
+
+std::vector<std::string> ToneSandhi::_split_word(const std::string& word) {
+    std::u16string u16;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), u16);
+    
+    std::vector<std::string> res;
+    if (u16.length() <= 1) {
+        res.push_back(word);
+        return res;
+    }
+    
+    size_t split_idx = 1;
+    if (u16.length() >= 3) split_idx = 2;
+    if (u16.length() >= 4) split_idx = 2;
+
+    std::u16string s1 = u16.substr(0, split_idx);
+    std::u16string s2 = u16.substr(split_idx);
+    
+    std::string u8_1, u8_2;
+    BasicStringUtil::u16tou8(s1.data(), s1.size(), u8_1);
+    BasicStringUtil::u16tou8(s2.data(), s2.size(), u8_2);
+    
+    res.push_back(u8_1);
+    res.push_back(u8_2);
+    return res;
+}
+
+std::vector<std::string> ToneSandhi::_bu_sandhi(const std::string& word, std::vector<std::string> finals) {
+    std::string BU = "不";
+    if (word.length() > BU.length() * 2) { 
+         std::u16string u16;
+         BasicStringUtil::u8tou16(word.c_str(), word.size(), u16);
+         if (u16.length() == 3 && u16[1] == 0x4E0D) { // 不
+             if (finals.size() > 1) to_tone5(finals[1]);
+             return finals;
+         }
+    }
+    
+    std::u16string u16;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), u16);
+    for (size_t i = 0; i < u16.length(); ++i) {
+        if (u16[i] == 0x4E0D && i + 1 < u16.length()) {
+            if (finals.size() > i + 1 && is_tone4(finals[i+1])) {
+                if (finals.size() > i) to_tone2(finals[i]);
+            }
+        }
+    }
+    return finals;
+}
+
+std::vector<std::string> ToneSandhi::_yi_sandhi(const std::string& word, std::vector<std::string> finals) {
+    std::string YI = "一";
+    if (word.find(YI) == std::string::npos) return finals;
+    
+    std::u16string u16;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), u16);
+    
+    bool all_numeric = true;
+    for (auto c : u16) {
+        if (c != 0x4E00 && !(c >= '0' && c <= '9') && 
+            c != 0x96F6 && c != 0x4E8C && c != 0x4E09 && c != 0x56DB && 
+            c != 0x4E94 && c != 0x516D && c != 0x4E03 && c != 0x516B && c != 0x4E5D && c != 0x5341) {
+            all_numeric = false; 
+            break; 
+        }
+    }
+    
+    if (all_numeric) return finals;
+    
+    if (u16.length() == 3 && u16[1] == 0x4E00 && u16[0] == u16[2]) {
+        if (finals.size() > 1) to_tone5(finals[1]);
+    } else if (word.find("第一") == 0) { 
+    } else {
+        for (size_t i = 0; i < u16.length(); ++i) {
+            if (u16[i] == 0x4E00 && i + 1 < u16.length()) {
+                if (finals.size() > i + 1) {
+                    if (is_tone4(finals[i+1]) || finals[i+1].back() == '5') { 
+                         if (finals.size() > i) to_tone2(finals[i]);
+                    } else {
+                         std::string& f = finals[i];
+                         if (isdigit(f.back())) f.back() = '4';
+                         else f += '4';
+                    }
+                }
+            }
+        }
+    }
+    return finals;
+}
+
+std::vector<std::string> ToneSandhi::_neural_sandhi(const std::string& word, const std::string& pos, std::vector<std::string> finals) {
+    if (must_not_neural_tone_words.count(word)) return finals;
+    
+    std::u16string u16;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), u16);
+    
+    if (u16.length() > 1) {
+         for (size_t j = 1; j < u16.length(); ++j) {
+             if (u16[j] == u16[j-1]) {
+                 if (pos.find('n') == 0 || pos.find('v') == 0 || pos.find('a') == 0) {
+                     if (finals.size() > j) to_tone5(finals[j]);
+                 }
+             }
+         }
+    }
+
+    if (u16.length() >= 1) {
+        char16_t last = u16.back();
+        std::u16string particles = u"吧呢啊呐噻嘛吖嗨呐哦哒滴哩哟喽啰耶喔诶";
+        if (particles.find(last) != std::string::npos) {
+            if (!finals.empty()) to_tone5(finals.back());
+        }
+        else if (last == 0x7684 || last == 0x5730 || last == 0x5F97) {
+             if (!finals.empty()) to_tone5(finals.back());
+        }
+        else if (u16.length() == 1 && (last == 0x4E86 || last == 0x7740 || last == 0x8FC7)) {
+             if (pos == "ul" || pos == "uz" || pos == "ug")
+                if (!finals.empty()) to_tone5(finals.back());
+        }
+        else if (u16.length() > 1 && (last == 0x4EEC || last == 0x5B50) && (pos == "r" || pos == "n")) {
+             if (!finals.empty()) to_tone5(finals.back());
+        }
+        else if (u16.length() > 1 && (last == 0x4E0A || last == 0x4E0B) && (pos == "s" || pos == "l" || pos == "f")) {
+             if (!finals.empty()) to_tone5(finals.back());
+        }
+         else if (u16.length() > 1 && (last == 0x6765 || last == 0x53BB)) {
+             char16_t prev = u16[u16.length()-2];
+             std::u16string dirs = u"上下进出回过起开";
+             if (dirs.find(prev) != std::string::npos) {
+                 if (!finals.empty()) to_tone5(finals.back());
+             }
+         }
+    }
+    
+    if (must_neural_tone_words.count(word)) {
+        if (!finals.empty()) to_tone5(finals.back());
+    }
+    
+    return finals;
+}
+
+std::vector<std::string> ToneSandhi::_three_sandhi(const std::string& word, std::vector<std::string> finals) {
+    std::u16string u16;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), u16);
+    
+    if (u16.length() == 2 && _all_tone_three(finals)) {
+        if (finals.size() > 0) to_tone2(finals[0]);
+    } else if (u16.length() == 3) {
+        auto word_list = _split_word(word); 
+        if (_all_tone_three(finals)) {
+             std::u16string p1;
+             BasicStringUtil::u8tou16(word_list[0].c_str(), word_list[0].size(), p1);
+             if (p1.length() == 2) { 
+                 if (finals.size() > 1) {
+                     to_tone2(finals[0]);
+                     to_tone2(finals[1]);
+                 }
+             } else if (p1.length() == 1) { 
+                 if (finals.size() > 1) {
+                     to_tone2(finals[1]);
+                 }
+             }
+        } 
+    }
+    
+    return finals;
+}
+
+std::vector<std::string> ToneSandhi::modified_tone(const std::string& word, const std::string& pos, 
+                                       std::vector<std::string> finals) {
+    finals = _bu_sandhi(word, finals);
+    finals = _yi_sandhi(word, finals);
+    finals = _neural_sandhi(word, pos, finals);
+    finals = _three_sandhi(word, finals);
+    return finals;
+}
+
+std::vector<std::pair<std::string, std::string>> ToneSandhi::_merge_bu(const std::vector<std::pair<std::string, std::string>>& seg) {
+    std::vector<std::pair<std::string, std::string>> new_seg;
+    std::string BU = "不";
+    
+    for (size_t i = 0; i < seg.size(); ++i) {
+        std::string word = seg[i].first;
+        std::string pos = seg[i].second;
+        
+        if (pos != "x" && pos != "eng") {
+             std::string last_word = "";
+             if (!new_seg.empty()) last_word = new_seg.back().first;
+             
+             if (last_word == BU) {
+                 new_seg.back().first += word;
+                 continue;
+             }
+        }
+        new_seg.push_back({word, pos});
+    }
+    return new_seg;
+}
+
+std::vector<std::pair<std::string, std::string>> ToneSandhi::_merge_yi(const std::vector<std::pair<std::string, std::string>>& seg) {
+    return seg;
+}
+
+std::vector<std::pair<std::string, std::string>> ToneSandhi::_merge_reduplication(const std::vector<std::pair<std::string, std::string>>& seg) {
+    return seg;
+}
+
+std::vector<std::pair<std::string, std::string>> ToneSandhi::_merge_er(const std::vector<std::pair<std::string, std::string>>& seg) {
+    std::vector<std::pair<std::string, std::string>> new_seg;
+    for (size_t i = 0; i < seg.size(); ++i) {
+        if (i > 0 && seg[i].first == "儿" && !new_seg.empty() && new_seg.back().second != "x" && new_seg.back().second != "eng") {
+            new_seg.back().first += seg[i].first;
+        } else {
+            new_seg.push_back(seg[i]);
+        }
+    }
+    return new_seg;
+}
+
+std::vector<std::pair<std::string, std::string>> ToneSandhi::pre_merge_for_modify(
+        const std::vector<std::pair<std::string, std::string>>& seg) {
+    auto res = _merge_bu(seg);
+    res = _merge_yi(res);
+    res = _merge_reduplication(res);
+    res = _merge_er(res);
+    return res;
+}

cpp/src/ToneSandhi.h

@@ -0,0 +1,46 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <unordered_set>
+#include <utility>
+#include <memory>
+#include <functional>
+
+class ToneSandhi {
+public:
+    using PinyinProvider = std::function<std::vector<std::string>(const std::string&)>;
+
+    ToneSandhi();
+    
+    void setPinyinProvider(PinyinProvider provider);
+
+    // Core logic: pre-merge
+    std::vector<std::pair<std::string, std::string>> pre_merge_for_modify(
+        const std::vector<std::pair<std::string, std::string>>& seg);
+
+    // Core logic: modify tone
+    std::vector<std::string> modified_tone(const std::string& word, const std::string& pos, 
+                                           std::vector<std::string> finals);
+
+private:
+    // Internal sandhi rules
+    std::vector<std::string> _bu_sandhi(const std::string& word, std::vector<std::string> finals);
+    std::vector<std::string> _yi_sandhi(const std::string& word, std::vector<std::string> finals);
+    std::vector<std::string> _neural_sandhi(const std::string& word, const std::string& pos, std::vector<std::string> finals);
+    std::vector<std::string> _three_sandhi(const std::string& word, std::vector<std::string> finals);
+
+    // Merge rules
+    std::vector<std::pair<std::string, std::string>> _merge_bu(const std::vector<std::pair<std::string, std::string>>& seg);
+    std::vector<std::pair<std::string, std::string>> _merge_yi(const std::vector<std::pair<std::string, std::string>>& seg);
+    std::vector<std::pair<std::string, std::string>> _merge_reduplication(const std::vector<std::pair<std::string, std::string>>& seg);
+    std::vector<std::pair<std::string, std::string>> _merge_er(const std::vector<std::pair<std::string, std::string>>& seg);
+    
+    // Helpers
+    bool _all_tone_three(const std::vector<std::string>& finals);
+    std::vector<std::string> _split_word(const std::string& word); 
+
+    std::unordered_set<std::string> must_neural_tone_words;
+    std::unordered_set<std::string> must_not_neural_tone_words;
+    std::string punc;
+    PinyinProvider pinyin_provider;
+};

cpp/src/Utils.h

@@ -0,0 +1,290 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <sstream>
+#include <iostream>
+#include <codecvt>
+#include <locale>
+#include <cassert>
+
+// 简单的日志宏替代 absl/log
+#define LOG_INFO std::cout << "[INFO] "
+#define LOG_WARNING std::cerr << "[WARN] "
+#define CHECK(condition) \
+    if (!(condition)) { \
+        std::cerr << "[FATAL] Check failed: " << #condition << " at " << __FILE__ << ":" << __LINE__ << std::endl; \
+        std::terminate(); \
+    }
+
+namespace BasicStringUtil {
+
+    // 简单的 UTF-8 <-> UTF-16 转换
+    // 注意: std::codecvt_utf8_utf16 在 C++17 被标记为 deprecated，但它是目前最便携的标准方案。
+    
+    inline void u8tou16(const char* src, size_t len, std::u16string& dst) {
+        if (len == 0) { dst = u""; return; }
+        try {
+            std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
+            dst = converter.from_bytes(src, src + len);
+        } catch (...) {
+            dst = u"";
+        }
+    }
+
+    inline void u16tou8(const char16_t* src, size_t len, std::string& dst) {
+        if (len == 0) { dst = ""; return; }
+        try {
+            std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
+            dst = converter.to_bytes(src, src + len);
+        } catch (...) {
+            dst = "";
+        }
+    }
+
+    inline void SplitString(const std::string& str, char delimiter, std::vector<std::string>* result) {
+        std::stringstream ss(str);
+        std::string item;
+        while (std::getline(ss, item, delimiter)) {
+            if (!item.empty()) {
+                result->push_back(item);
+            }
+        }
+    }
+    
+    inline void SplitString(const char* str, size_t len, char delimiter, std::vector<std::string>* result) {
+        std::string s(str, len);
+        SplitString(s, delimiter, result);
+    }
+
+    inline std::string DigitToChinese(char c) {
+        switch(c) {
+            case '0': return "零";
+            case '1': return "一";
+            case '2': return "二";
+            case '3': return "三";
+            case '4': return "四";
+            case '5': return "五";
+            case '6': return "六";
+            case '7': return "七";
+            case '8': return "八";
+            case '9': return "九";
+            default: return "";
+        }
+    }
+
+    // 简单的数字转中文逻辑
+    // 支持整数和小数
+    // 例如: 123 -> 一百二十三, 3.14 -> 三点一四
+    // 增强: 支持 IP 地址或版本号 (1.2.3.4) -> 一点二点三点四
+    inline std::string NumberToChinese(const std::string& num_str) {
+        if (num_str.empty()) return "";
+        
+        // Check for multiple dots -> IP/Version -> Read digits one by one
+        int dot_count = 0;
+        for (char c : num_str) {
+            if (c == '.') dot_count++;
+        }
+        
+        if (dot_count > 1) {
+            std::string res;
+            for (char c : num_str) {
+                if (c == '.') {
+                    res += "点";
+                } else if (isdigit(c)) {
+                    res += DigitToChinese(c);
+                } else {
+                    // Should not happen if regex is correct, but safe fallback
+                    res += c;
+                }
+            }
+            return res;
+        }
+        
+        std::string res;
+        size_t start = 0;
+        if (num_str[0] == '-') {
+            res += "负";
+            start = 1;
+        } else if (num_str[0] == '+') {
+            start = 1;
+        }
+
+        size_t dot_pos = num_str.find('.');
+        std::string integer_part = num_str.substr(start, dot_pos - start);
+        std::string decimal_part;
+        if (dot_pos != std::string::npos) {
+            decimal_part = num_str.substr(dot_pos + 1);
+        }
+
+        // 处理整数部分
+        if (integer_part.empty()) {
+            res += "零";
+        } else {
+            // 简单的中文数字读法实现
+            // 分组：每4位一组 (个, 万, 亿)
+            // 由于 C++ 处理 UTF-8 字符串比较麻烦，这里尽量简化逻辑
+            // 也可以选择直接按位读（如果是编号），但通常 TTS 需要数值读法。
+            // 简单实现：如果太长（>12位），按位读；否则按数值读。
+            
+            if (integer_part.length() > 12) {
+                for (char c : integer_part) {
+                    res += DigitToChinese(c);
+                }
+            } else {
+                // 数值读法
+                const char* units[] = {"", "十", "百", "千"};
+                const char* big_units[] = {"", "万", "亿", "兆"};
+                
+                // 去除前导零
+                size_t first_nonzero = integer_part.find_first_not_of('0');
+                if (first_nonzero == std::string::npos) {
+                    res += "零";
+                } else {
+                    std::string s = integer_part.substr(first_nonzero);
+                    int len = s.length();
+                    
+                    // 倒序处理，每4位一组
+                    int group_count = (len + 3) / 4;
+                    
+                    bool zero_flag = false; // 前面是否有零需要补
+                    
+                    for (int i = 0; i < group_count; ++i) {
+                        int group_idx = group_count - 1 - i; // 当前处理的是第几组（从高位到低位）
+                        int start_idx = std::max(0, len - (i + 1) * 4);
+                        int end_idx = len - i * 4;
+                        std::string group_str = s.substr(start_idx, end_idx - start_idx);
+                        
+                        std::string group_res;
+                        bool group_has_value = false;
+                        bool last_is_zero = false;
+                        
+                        int g_len = group_str.length();
+                        for (int j = 0; j < g_len; ++j) {
+                            char digit = group_str[j];
+                            int unit_idx = g_len - 1 - j;
+                            
+                            if (digit == '0') {
+                                last_is_zero = true;
+                            } else {
+                                if (last_is_zero) {
+                                    group_res += "零";
+                                    last_is_zero = false;
+                                }
+                                // 处理 "一十" -> "十" 的情况 (仅在首位且值为1且单位为十)
+                                // 但如果是 "一百一十"，中间的 "一" 不能省。
+                                // 这里的逻辑简化：如果是整个数字的开头，且是十位，且是1，则省去一
+                                // e.g. 12 -> 十二, 112 -> 一百一十二
+                                if (digit == '1' && unit_idx == 1 && group_res.empty() && zero_flag == false && i == 0 && g_len == 2) {
+                                     // Don't output "一", just unit
+                                } else {
+                                    group_res += DigitToChinese(digit);
+                                }
+                                group_res += units[unit_idx];
+                                group_has_value = true;
+                            }
+                        }
+                        
+                        if (group_has_value) {
+                            if (zero_flag && group_res.find("零") != 0) {
+                                // 如果前面组有遗留零，或者本组开头不是零（但实际上前面可能有空档），通常由 last_is_zero 控制组内零
+                                // 跨组零比较复杂。简单策略：如果上一组有值，本组不是从千位开始（即不满4位），补零
+                                // 这里简化：如果之前有非零组，且当前组不满4位，或者高位是0，需要补零。
+                                // 为了简化代码，暂不处理复杂的跨组补零，除了最简单的。
+                            }
+                             // 实际上跨组零通常在 "1001" -> "一千零一"
+                             // 如果 s = 10001 (len=5), group 1 = '1', group 0 = '0001'
+                             // group 1 res = "一", big_unit = "万"
+                             // group 0: '0'->zero, '0'->zero, '0'->zero, '1'->'一'
+                             // 应该输出 "一万零一"
+                             // 我们可以在每组输出前，如果组内开头是0，且前面已经有输出了，加个零
+                             if (!res.empty() && group_str[0] == '0') {
+                                 // check if we already ended with zero
+                                 // UTF-8 check is hard, just append and fix later or assume
+                                 // simple: append "零"
+                                 if (res.substr(res.length() - 3) != "零")
+                                     res += "零";
+                             }
+                             
+                             res += group_res;
+                             res += big_units[i]; // big_units index is reversed? No, big_units index should be `i` from the end
+                             // Wait, my `i` loop is from 0 (lowest group) to group_count-1 (highest).
+                             // Actually I want to process from Highest to Lowest.
+                             // Let's restart the loop logic above to be clearer.
+                        }
+                    }
+                    
+                    // Re-implementation with correct order: High to Low
+                    res = ""; // clear and restart
+                    if (num_str[0] == '-') res += "负";
+                    
+                    int remaining = len;
+                    bool need_zero = false;
+                    
+                    for (int i = 0; i < len; ++i) {
+                        int digit = s[i] - '0';
+                        int pos = len - 1 - i; // 10^pos
+                        int unit_idx = pos % 4;
+                        int big_unit_idx = pos / 4;
+                        
+                        if (digit == 0) {
+                            if (unit_idx == 0 && big_unit_idx > 0 && (need_zero || (i > 0 && (s[i-1]-'0')!=0) )) {
+                                // End of a big unit group (万, 亿)
+                                // If the whole group was 0, we don't add unit. 
+                                // But we need to check if this group had any value.
+                                // Complex. Let's fallback to a simpler recursive or chunk-based approach.
+                            }
+                            need_zero = true;
+                        } else {
+                            if (need_zero) {
+                                res += "零";
+                                need_zero = false;
+                            }
+                            // 处理 "一十" -> "十" (仅在值在10-19之间)
+                            // 10-19: s.length() == 2, i=0, digit=1
+                            if (digit == 1 && unit_idx == 1 && len == 2 && i == 0) {
+                                // skip "一"
+                            } else {
+                                res += DigitToChinese(s[i]);
+                            }
+                            res += units[unit_idx];
+                        }
+                        
+                        if (unit_idx == 0 && big_unit_idx > 0) {
+                            // Check if this 4-digit group had any non-zero
+                            // Look back up to 4 chars
+                            bool group_has_value = false;
+                            int start_chk = std::max(0, i - 3);
+                            for(int k=start_chk; k<=i; ++k) if(s[k] != '0') group_has_value = true;
+                            
+                            if (group_has_value) {
+                                res += big_units[big_unit_idx];
+                                need_zero = false; // Unit added, reset zero pending? 
+                                // No, "10001" -> One Wan Zero One. 
+                                // If we finish "Wan", next is "0001". next digit is 0, so need_zero becomes true.
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // 处理小数部分
+        if (!decimal_part.empty()) {
+            res += "点";
+            for (char c : decimal_part) {
+                res += DigitToChinese(c);
+            }
+        }
+        
+        return res;
+    }
+}
+
+class TextProcessor {
+public:
+    virtual ~TextProcessor() = default;
+    // Return pairs of (word, pos_tag)
+    virtual std::vector<std::pair<std::string, std::string>> cut(const std::string& text) = 0;
+    virtual std::vector<std::string> word_to_pinyin(const std::string& word) = 0;
+    virtual std::string convert_numbers(const std::string& text) = 0;
+};

cpp/src/ZHFrontend.cpp

@@ -0,0 +1,182 @@
+#include "ZHFrontend.h"
+#include "ZHG2P.h"
+#include <algorithm>
+#include <iostream>
+
+ZHFrontend::ZHFrontend(std::shared_ptr<TextProcessor> processor, const std::string& unk)
+    : processor(processor), unk(unk) {
+    
+    punc = {";", ":", ",", ".", "!", "?", "—", "…", "\"", "(", ")", "“", "”"}; 
+    must_erhua = {"小院儿", "胡同儿", "范儿", "老汉儿", "撒欢儿", "寻老礼儿", "妥妥儿", "媳妇儿"};
+    not_erhua = {
+        "虐儿", "为儿", "护儿", "瞒儿", "救儿", "替儿", "有儿", "一儿", "我儿", "俺儿", "妻儿",
+        "拐儿", "聋儿", "乞儿", "患儿", "幼儿", "孤儿", "婴儿", "婴幼儿", "连体儿", "脑瘫儿",
+        "流浪儿", "体弱儿", "混血儿", "蜜雪儿", "舫儿", "祖儿", "美儿", "应采儿", "可儿", "侄儿",
+        "孙儿", "侄孙儿", "女儿", "男儿", "红孩儿", "花儿", "虫儿", "马儿", "鸟儿", "猪儿", "猫儿",
+        "狗儿", "少儿"
+    };
+
+    tone_modifier.setPinyinProvider([this](const std::string& word) {
+        return this->processor->word_to_pinyin(word);
+    });
+}
+
+ZHFrontend::InitFinal ZHFrontend::_get_initials_finals(const std::string& word) {
+    InitFinal res;
+    auto pinyins = processor->word_to_pinyin(word);
+    
+    // Handle '嗯' special case check
+    // Check if word contains 嗯 (UTF-8: E5 97 AF)
+    // For simplicity, we iterate pinyins. If pinyin is "n" or "ng", we might need check.
+    // Pypinyin logic: if word has '嗯', set final to 'n2'.
+    // We skip this detailed logic for now.
+
+    for (const auto& py : pinyins) {
+        auto parts = ZHG2P::parse_pinyin(py);
+        
+        std::string final_with_tone = parts.final + std::to_string(parts.tone);
+        
+        // Special handling for zi, ci, si, zhi, chi, shi, ri
+        if (parts.final == "i") {
+            if (parts.initial == "z" || parts.initial == "c" || parts.initial == "s") {
+                final_with_tone = "ii" + std::to_string(parts.tone);
+            } else if (parts.initial == "zh" || parts.initial == "ch" || parts.initial == "sh" || parts.initial == "r") {
+                final_with_tone = "iii" + std::to_string(parts.tone);
+            }
+        }
+        
+        res.initials.push_back(parts.initial);
+        res.finals.push_back(final_with_tone);
+    }
+    return res;
+}
+
+ZHFrontend::InitFinal ZHFrontend::_merge_erhua(const std::vector<std::string>& initials, 
+                       const std::vector<std::string>& finals, 
+                       const std::string& word, const std::string& pos) {
+    
+    std::vector<std::string> new_initials;
+    std::vector<std::string> new_finals = finals;
+    
+    // fix er1 -> er2
+    std::string er = "儿";
+    // Need to match word char index with final index. Assuming 1-to-1.
+    // Since word is UTF-8 string, we need u16 conversion to index it.
+    std::u16string u16word;
+    BasicStringUtil::u8tou16(word.c_str(), word.size(), u16word);
+    
+    if (u16word.size() != finals.size()) {
+        // Mismatch, return as is
+        InitFinal res;
+        res.initials = initials;
+        res.finals = finals;
+        return res;
+    }
+
+    for (size_t i = 0; i < new_finals.size(); ++i) {
+        if (i == new_finals.size() - 1 && u16word[i] == 0x513F && new_finals[i] == "er1") {
+            new_finals[i] = "er2";
+        }
+    }
+
+    if (!must_erhua.count(word) && (not_erhua.count(word) || pos == "a" || pos == "j" || pos == "nr")) {
+        InitFinal res;
+        res.initials = initials;
+        res.finals = new_finals;
+        return res;
+    }
+
+    std::vector<std::string> merged_initials;
+    std::vector<std::string> merged_finals;
+
+    for (size_t i = 0; i < new_finals.size(); ++i) {
+        // er2 or er5
+        if (i == new_finals.size() - 1 && u16word[i] == 0x513F && (new_finals[i] == "er2" || new_finals[i] == "er5")
+            && !merged_finals.empty()) {
+            // Check word[-2:] not in not_erhua. Skipping for simplicity.
+            
+            // Merge: remove last digit of prev final, add 'R', add last digit
+            std::string& prev = merged_finals.back();
+            if (!prev.empty() && isdigit(prev.back())) {
+                char tone = prev.back();
+                prev.pop_back();
+                prev += "R";
+                prev += tone;
+            } else {
+                prev += "R5"; // Fallback
+            }
+        } else {
+            merged_initials.push_back(initials[i]);
+            merged_finals.push_back(new_finals[i]);
+        }
+    }
+    
+    InitFinal res;
+    res.initials = merged_initials;
+    res.finals = merged_finals;
+    return res;
+}
+
+std::vector<MToken> ZHFrontend::operator()(const std::string& text, bool with_erhua) {
+    std::vector<MToken> tokens;
+    
+    auto seg_cut = processor->cut(text);
+    seg_cut = tone_modifier.pre_merge_for_modify(seg_cut);
+
+    for (const auto& pair : seg_cut) {
+        std::string word = pair.first;
+        std::string pos = pair.second;
+        
+        MToken tk;
+        tk.text = word;
+        tk.tag = pos;
+        
+        if (pos == "x" || pos == "eng") {
+            if (pos == "x" && punc.count(word)) {
+                 tk.phonemes.push_back(word);
+            }
+            // If eng, we might want to keep it or transcribe it?
+            // Python code: if pos in ('x', 'eng'): ...
+            // Here we just keep it as text in phonemes if it's punct, else empty?
+            // The prompt example showed: [['w', 'o3', ...]]
+            // For English, maybe we should keep it as is.
+            if (pos == "eng") tk.phonemes.push_back(word);
+
+            tokens.push_back(tk);
+            continue;
+        }
+
+        // g2p
+        auto init_finals = _get_initials_finals(word);
+        
+        // tone sandhi
+        auto modified_finals = tone_modifier.modified_tone(word, pos, init_finals.finals);
+        
+        // er hua
+        if (with_erhua) {
+            init_finals = _merge_erhua(init_finals.initials, modified_finals, word, pos);
+        } else {
+            init_finals.finals = modified_finals;
+        }
+
+        // Zip initials and finals into phonemes
+        for (size_t i = 0; i < init_finals.initials.size(); ++i) {
+            if (i < init_finals.finals.size()) {
+                // We need to handle the mapping back to IPA?
+                // The ZHFrontend returns py-like tokens (initial, final_with_tone).
+                // ZHG2P logic usually takes pinyin string.
+                // Here we return raw components: "z", "hong1".
+                
+                // The prompt says: [['w', 'o3', 'm', 'en2', ' '], ...]
+                // So it splits initial and final.
+                
+                if (!init_finals.initials[i].empty()) {
+                    tk.phonemes.push_back(init_finals.initials[i]);
+                }
+                tk.phonemes.push_back(init_finals.finals[i]);
+            }
+        }
+        tokens.push_back(tk);
+    }
+    return tokens;
+}

cpp/src/ZHFrontend.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <memory>
+#include <unordered_set>
+#include "ToneSandhi.h"
+#include "Utils.h"
+
+struct MToken {
+    std::string text;
+    std::string tag;
+    std::string whitespace;
+    std::vector<std::string> phonemes; 
+};
+
+class ZHFrontend {
+public:
+    ZHFrontend(std::shared_ptr<TextProcessor> processor, const std::string& unk = "?");
+
+    std::vector<MToken> operator()(const std::string& text, bool with_erhua = true);
+
+private:
+    std::string unk;
+    std::shared_ptr<TextProcessor> processor;
+    ToneSandhi tone_modifier;
+    
+    std::unordered_set<std::string> must_erhua;
+    std::unordered_set<std::string> not_erhua;
+    std::unordered_set<std::string> punc;
+
+    struct InitFinal {
+        std::vector<std::string> initials;
+        std::vector<std::string> finals;
+    };
+    
+    InitFinal _get_initials_finals(const std::string& word);
+    InitFinal _merge_erhua(const std::vector<std::string>& initials, 
+                           const std::vector<std::string>& finals, 
+                           const std::string& word, const std::string& pos);
+};

cpp/src/ZHG2P.cpp

@@ -0,0 +1,428 @@
+#include "ZHG2P.h"
+#include <iostream>
+#include <regex>
+#include <sstream>
+#include <algorithm>
+#include <unordered_set>
+
+// ==========================================
+// Data Tables from transcription.py
+// ==========================================
+
+static const std::unordered_map<std::string, std::vector<std::string>> INITIAL_MAPPING = {
+    {"b", {"p"}}, {"c", {"ʦʰ"}}, {"ch", {"ʈʂʰ"}}, {"d", {"t"}},
+    {"f", {"f"}}, {"g", {"k"}}, {"h", {"x"}}, {"j", {"ʨ"}},
+    {"k", {"kʰ"}}, {"l", {"l"}}, {"m", {"m"}}, {"n", {"n"}},
+    {"p", {"pʰ"}}, {"q", {"ʨʰ"}}, {"r", {"ɻ"}}, {"s", {"s"}},
+    {"sh", {"ʂ"}}, {"t", {"tʰ"}}, {"x", {"ɕ"}}, {"z", {"ʦ"}},
+    {"zh", {"ʈʂ"}}
+};
+
+static const std::unordered_map<std::string, std::vector<std::string>> FINAL_MAPPING = {
+    {"a", {"a0"}}, {"ai", {"ai̯0"}}, {"an", {"a0", "n"}}, {"ang", {"a0", "ŋ"}},
+    {"ao", {"au̯0"}}, {"e", {"ɤ0"}}, {"ei", {"ei̯0"}}, {"en", {"ə0", "n"}},
+    {"eng", {"ə0", "ŋ"}}, {"er", {"ɚ0"}}, {"i", {"i0"}}, {"ia", {"j", "a0"}},
+    {"ian", {"j", "ɛ0", "n"}}, {"iang", {"j", "a0", "ŋ"}}, {"iao", {"j", "au̯0"}},
+    {"ie", {"j", "e0"}}, {"in", {"i0", "n"}}, {"ing", {"i0", "ŋ"}},
+    {"iong", {"j", "ʊ0", "ŋ"}}, {"iou", {"j", "ou̯0"}}, {"ong", {"ʊ0", "ŋ"}},
+    {"ou", {"ou̯0"}}, {"o", {"o0"}}, {"u", {"u0"}}, {"ua", {"w", "a0"}},
+    {"uai", {"w", "ai̯0"}}, {"uan", {"w", "a0", "n"}}, {"uang", {"w", "a0", "ŋ"}},
+    {"ui", {"w", "ei̯0"}}, {"un", {"w", "ə0", "n"}}, {"ueng", {"w", "ə0", "ŋ"}},
+    {"uo", {"w", "o0"}}, {"ue", {"ɥ", "e0"}}, {"uen", {"w", "ə0", "n"}}, {"uei", {"w", "ei̯0"}},
+    {"ü", {"y0"}}, {"üe", {"ɥ", "e0"}}, {"üan", {"ɥ", "ɛ0", "n"}}, {"ün", {"y0", "n"}},
+    {"van", {"ɥ", "ɛ0", "n"}}, {"vn", {"y0", "n"}}, {"ve", {"ɥ", "e0"}}, {"v", {"y0"}},
+    // ZHFrontend special finals for apical vowels
+    {"ii", {"ɹ̩0"}},   // for z, c, s
+    {"iii", {"ɻ̩0"}}   // for zh, ch, sh, r
+};
+
+static const std::unordered_map<std::string, std::vector<std::string>> FINAL_MAPPING_ZH_CH_SH_R = {
+    {"i", {"ɻ̩0"}} 
+};
+
+static const std::unordered_map<std::string, std::vector<std::string>> FINAL_MAPPING_Z_C_S = {
+    {"i", {"ɹ̩0"}} 
+};
+
+static const std::unordered_map<int, std::string> TONE_MAPPING = {
+    {1, "˥"}, {2, "˧˥"}, {3, "˧˩˧"}, {4, "˥˩"}, {5, ""}
+};
+
+static const std::unordered_map<std::string, std::pair<std::string, int>> TONE_VOWELS = {
+    {u8"ā", {u8"a", 1}}, {u8"á", {u8"a", 2}}, {u8"ǎ", {u8"a", 3}}, {u8"à", {u8"a", 4}},
+    {u8"ē", {u8"e", 1}}, {u8"é", {u8"e", 2}}, {u8"ě", {u8"e", 3}}, {u8"è", {u8"e", 4}},
+    {u8"ī", {u8"i", 1}}, {u8"í", {u8"i", 2}}, {u8"ǐ", {u8"i", 3}}, {u8"ì", {u8"i", 4}},
+    {u8"ō", {u8"o", 1}}, {u8"ó", {u8"o", 2}}, {u8"ǒ", {u8"o", 3}}, {u8"ò", {u8"o", 4}},
+    {u8"ū", {u8"u", 1}}, {u8"ú", {u8"u", 2}}, {u8"ǔ", {u8"u", 3}}, {u8"ù", {u8"u", 4}},
+    {u8"ǖ", {u8"v", 1}}, {u8"ǘ", {u8"v", 2}}, {u8"ǚ", {u8"v", 3}}, {u8"ǜ", {u8"v", 4}},
+    {u8"ń", {u8"n", 2}}, {u8"ň", {u8"n", 3}}, {u8"ǹ", {u8"n", 4}},
+    {u8"ḿ", {u8"m", 2}}, {u8"m̀", {u8"m", 4}} 
+};
+
+// ==========================================
+// Utility Functions
+// ==========================================
+
+static const std::unordered_map<char, std::string> LETTER_TO_IPA = {
+    {'A', "ei̯"}, {'B', "pi"}, {'C', "si"}, {'D', "ti"}, {'E', "i"},
+    {'F', "ef"}, {'G', "tʂi"}, {'H', "ei̯tʂ"}, {'I', "ai̯"}, {'J', "tʂei̯"},
+    {'K', "kʰei̯"}, {'L', "el"}, {'M', "em"}, {'N', "en"}, {'O', "ou̯"},
+    {'P', "pʰi"}, {'Q', "kʰju"}, {'R', "aɻ"}, {'S', "es"}, {'T', "tʰi"},
+    {'U', "ju"}, {'V', "vi"}, {'W', "tʌplju"}, {'X', "eks"}, {'Y', "wai̯"},
+    {'Z', "zi"},
+    {'a', "ei̯"}, {'b', "pi"}, {'c', "si"}, {'d', "ti"}, {'e', "i"},
+    {'f', "ef"}, {'g', "tʂi"}, {'h', "ei̯tʂ"}, {'i', "ai̯"}, {'j', "tʂei̯"},
+    {'k', "kʰei̯"}, {'l', "el"}, {'m', "em"}, {'n', "en"}, {'o', "ou̯"},
+    {'p', "pʰi"}, {'q', "kʰju"}, {'r', "aɻ"}, {'s', "es"}, {'t', "tʰi"},
+    {'u', "ju"}, {'v', "vi"}, {'w', "tʌplju"}, {'x', "eks"}, {'y', "wai̯"},
+    {'z', "zi"}
+};
+
+static std::string replace_all(std::string str, const std::string& from, const std::string& to) {
+    if (from.empty()) return str;
+    size_t start_pos = 0;
+    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
+        str.replace(start_pos, from.length(), to);
+        start_pos += to.length();
+    }
+    return str;
+}
+
+static std::string join(const std::vector<std::string>& vec, const std::string& delim) {
+    std::string res;
+    for (size_t i = 0; i < vec.size(); ++i) {
+        if (i > 0) res += delim;
+        res += vec[i];
+    }
+    return res;
+}
+
+static std::string trim(const std::string& str) {
+    size_t first = str.find_first_not_of(" \t\n\r");
+    if (std::string::npos == first) return "";
+    size_t last = str.find_last_not_of(" \t\n\r");
+    return str.substr(first, (last - first + 1));
+}
+
+// ==========================================
+// ZHG2P Implementation
+// ==========================================
+
+ZHG2P::ZHG2P(std::shared_ptr<TextProcessor> proc, const std::string& ver, const std::string& u, const std::string& eng_dict_path)
+    : processor(std::move(proc)), version(ver), unk(u) {
+    if (version == "1.1") {
+        frontend = std::make_unique<ZHFrontend>(processor, unk);
+    }
+    if (!eng_dict_path.empty()) {
+        std::cout << "Loading English G2P dict from " << eng_dict_path << "..." << std::endl;
+        eng_g2p = std::make_unique<EnG2P>(eng_dict_path);
+    }
+}
+
+std::string ZHG2P::retone(std::string p) {
+    p = replace_all(p, "˧˩˧", "↓");
+    p = replace_all(p, "˧˥", "↗");
+    p = replace_all(p, "˥˩", "↘");
+    p = replace_all(p, "˥", "→");
+    
+    // ɨ handling
+    p = replace_all(p, "\u027B\u0329", "ɨ"); 
+    p = replace_all(p, "\u0279\u0329", "ɨ"); 
+    p = replace_all(p, "ɻ̩", "ɨ"); 
+    p = replace_all(p, "ɹ̩", "ɨ"); 
+
+    return p;
+}
+
+ZHG2P::PinyinParts ZHG2P::parse_pinyin(const std::string& raw_pinyin) {
+    PinyinParts parts;
+    parts.tone = 5;
+    std::string pinyin = trim(raw_pinyin);
+    
+    if (pinyin.empty()) return parts;
+
+    // Normalize pinyin (handle tone marks like ā -> a, tone=1)
+    std::string base = "";
+    int detected_tone = 5;
+    
+    for (size_t i = 0; i < pinyin.length(); ) {
+        bool matched = false;
+        // Check against TONE_VOWELS keys
+        // Iterate map - not efficient but works given small map and short pinyin string
+        for (const auto& kv : TONE_VOWELS) {
+            if (pinyin.compare(i, kv.first.length(), kv.first) == 0) {
+                 if (detected_tone == 5) detected_tone = kv.second.second; 
+                 base += kv.second.first;
+                 i += kv.first.length();
+                 matched = true;
+                 break;
+            }
+        }
+        if (!matched) {
+            base += pinyin[i];
+            i++;
+        }
+    }
+
+    // Check explicitly written number tone (e.g. zhong1) - overrides mark if present (unlikely mixed)
+    if (!base.empty()) {
+        char last = base.back();
+        if (isdigit(static_cast<unsigned char>(last))) {
+            parts.tone = last - '0';
+            base.pop_back();
+        } else {
+            parts.tone = detected_tone;
+        }
+    }
+
+    base = replace_all(base, "v", "ü");
+
+    // Handle y and w (standard pinyin normalization)
+    if (base.rfind("yi", 0) == 0) {
+        base = base.substr(1); // yi -> i
+    } else if (base.rfind("y", 0) == 0) {
+        if (base.length() > 1 && base[1] == 'u') {
+             base = "ü" + base.substr(2); // yu -> ü
+        } else {
+             base = "i" + base.substr(1); // ya -> ia, you -> iou
+        }
+    } else if (base.rfind("wu", 0) == 0) {
+        base = base.substr(1); // wu -> u
+    } else if (base.rfind("w", 0) == 0) {
+        base = "u" + base.substr(1); // wa -> ua, wo -> uo, wei -> uei
+    }
+
+    std::string p_initial = "";
+    
+    static const std::vector<std::string> multi_initials = {"zh", "ch", "sh"};
+    for (const auto& ini : multi_initials) {
+        if (base.rfind(ini, 0) == 0) { 
+            p_initial = ini;
+            break;
+        }
+    }
+    if (p_initial.empty()) {
+        std::string first_char = base.substr(0, 1);
+        if (INITIAL_MAPPING.count(first_char)) {
+            p_initial = first_char;
+        }
+    }
+
+    parts.initial = p_initial;
+    parts.final = base.substr(p_initial.length());
+    
+    return parts;
+}
+
+std::string ZHG2P::pinyin_to_ipa_convert(const std::string& pinyin) {
+    auto parts = parse_pinyin(pinyin);
+    std::vector<std::string> ipa_segments;
+
+    // 1. Initial
+    if (!parts.initial.empty() && INITIAL_MAPPING.count(parts.initial)) {
+        ipa_segments.push_back(INITIAL_MAPPING.at(parts.initial)[0]);
+    }
+
+    // 2. Final
+    std::vector<std::string> final_phonemes;
+    bool handled = false;
+    bool is_erhua = false;
+
+    if (!parts.final.empty() && parts.final.back() == 'R') {
+        is_erhua = true;
+        parts.final.pop_back();
+    }
+
+    if ((parts.initial == "zh" || parts.initial == "ch" || parts.initial == "sh" || parts.initial == "r") 
+        && FINAL_MAPPING_ZH_CH_SH_R.count(parts.final)) {
+        final_phonemes = FINAL_MAPPING_ZH_CH_SH_R.at(parts.final);
+        handled = true;
+    } else if ((parts.initial == "z" || parts.initial == "c" || parts.initial == "s") 
+        && FINAL_MAPPING_Z_C_S.count(parts.final)) {
+        final_phonemes = FINAL_MAPPING_Z_C_S.at(parts.final);
+        handled = true;
+    }
+
+    if (!handled && FINAL_MAPPING.count(parts.final)) {
+        final_phonemes = FINAL_MAPPING.at(parts.final);
+    }
+
+    if (final_phonemes.empty() && !parts.final.empty()) {
+        final_phonemes.push_back(parts.final); 
+    }
+
+    // 3. Apply Tone
+    std::string tone_mark = (TONE_MAPPING.count(parts.tone)) ? TONE_MAPPING.at(parts.tone) : "";
+    
+    for (const auto& ph : final_phonemes) {
+        std::string processed = ph;
+        processed = replace_all(processed, "0", tone_mark);
+        ipa_segments.push_back(processed);
+    }
+
+    if (is_erhua) {
+        ipa_segments.push_back("ɚ"); // or proper IPA for rhoticity
+    }
+
+    return join(ipa_segments, "");
+}
+
+std::string ZHG2P::py2ipa(const std::string& py) {
+    std::string ipa = pinyin_to_ipa_convert(py);
+    return retone(ipa);
+}
+
+std::string ZHG2P::map_punctuation(std::string text) {
+    // Note: using u8 string literals
+    text = replace_all(text, u8"、", ", ");
+    text = replace_all(text, u8"，", ", ");
+    text = replace_all(text, u8"。", ". ");
+    text = replace_all(text, u8"．", ". ");
+    text = replace_all(text, u8"！", "! ");
+    text = replace_all(text, u8"：", ": ");
+    text = replace_all(text, u8"；", "; ");
+    text = replace_all(text, u8"？", "? ");
+    text = replace_all(text, u8"«", u8" “");
+    text = replace_all(text, u8"»", u8"” ");
+    text = replace_all(text, u8"《", u8" “");
+    text = replace_all(text, u8"》", u8"” ");
+    text = replace_all(text, u8"「", u8" “");
+    text = replace_all(text, u8"」", u8"” ");
+    text = replace_all(text, u8"【", u8" “");
+    text = replace_all(text, u8"】", u8"” ");
+    text = replace_all(text, u8"（", " (");
+    text = replace_all(text, u8"）", ") ");
+    
+    size_t first = text.find_first_not_of(" \t\n\r");
+    if (std::string::npos == first) return text;
+    size_t last = text.find_last_not_of(" \t\n\r");
+    return text.substr(first, (last - first + 1));
+}
+
+bool ZHG2P::is_chinese(const std::string& str) {
+    // Simple heuristic check for CJK range in UTF-8
+    for (unsigned char c : str) {
+        if (c >= 0xE4 && c <= 0xE9) return true;
+    }
+    return false;
+}
+
+std::string ZHG2P::legacy_call(const std::string& text) {
+    std::string result = "";
+    
+    auto words = processor->cut(text);
+    for (const auto& pair : words) {
+        std::string w = pair.first;
+        if (is_chinese(w)) {
+            auto pinyins = processor->word_to_pinyin(w);
+            for (const auto& py : pinyins) {
+                result += py2ipa(py);
+            }
+            // segment = ' '.join(word2ipa(w) for w in words)
+            // So YES, space between words.
+            result += " "; 
+        } else {
+            result += w; 
+        }
+    }
+    
+    // Trim trailing space if needed
+    if (!result.empty() && result.back() == ' ') result.pop_back();
+
+    // Remove \u032F (815)
+    result = replace_all(result, "\u032F", "");
+    return result;
+}
+
+std::pair<std::string, std::string> ZHG2P::operator()(const std::string& text) {
+    if (text.empty()) return {"", ""};
+
+    std::string processed_text = text;
+    if (processor) {
+        processed_text = processor->convert_numbers(processed_text);
+    }
+    processed_text = map_punctuation(processed_text);
+
+    // Default to legacy_call for now as we don't have the 1.1 frontend ported
+    if (frontend) {
+        auto tokens = (*frontend)(processed_text);
+        std::string result;
+        bool last_was_eng = false;
+
+        for (const auto& tk : tokens) {
+             bool is_eng = (tk.tag == "eng");
+
+             // Logic to add spaces around English words
+             // 1. Before English word (if not at start)
+             if (is_eng && !result.empty() && result.back() != ' ') {
+                 result += " ";
+             }
+             // 2. After English word (if next is not punctuation)
+             if (last_was_eng && !is_eng && tk.tag != "x" && !result.empty() && result.back() != ' ') {
+                 result += " ";
+             }
+
+             if (tk.tag == "x" || tk.tag == "eng") {
+                 for (const auto& p : tk.phonemes) {
+                     std::string converted_part;
+                     if (eng_g2p && tk.tag == "eng") {
+                         converted_part = eng_g2p->convert(p);
+                     }
+                     
+                     // Fallback for English words: letter by letter
+                     if ((converted_part.empty() || converted_part == p) && tk.tag == "eng") {
+                         // If conversion failed or returned same (meaning no dict entry found typically),
+                         // try letter mapping for pure alpha strings
+                         bool all_alpha = true;
+                         for(char c : p) {
+                             if(!isalpha(c)) { all_alpha = false; break; }
+                         }
+                         
+                         if (all_alpha) {
+                             converted_part = "";
+                             for(char c : p) {
+                                 if(LETTER_TO_IPA.count(c)) {
+                                     converted_part += LETTER_TO_IPA.at(c);
+                                 } else {
+                                     converted_part += c;
+                                 }
+                             }
+                         } else {
+                             converted_part = p; // keep as is if not all alpha
+                         }
+                     } else if (converted_part.empty()) {
+                         converted_part = p;
+                     }
+
+                     result += converted_part;
+                 }
+             } else {
+                 // Split phonemes into pinyin syllables based on tone digits
+                 std::string pinyin_acc;
+                 for (const auto& p : tk.phonemes) {
+                     pinyin_acc += p;
+                     // Check if p contains a digit
+                     bool has_digit = false;
+                     for (char c : p) {
+                         if (isdigit(static_cast<unsigned char>(c))) {
+                             has_digit = true;
+                             break;
+                         }
+                     }
+                     
+                     if (has_digit) {
+                         result += py2ipa(pinyin_acc);
+                         pinyin_acc.clear();
+                     }
+                 }
+                 // Handle any trailing part
+                 if (!pinyin_acc.empty()) {
+                     result += py2ipa(pinyin_acc);
+                 }
+             }
+             last_was_eng = is_eng;
+        }
+        return {result, ""};
+    }
+    return {legacy_call(processed_text), ""};
+}

cpp/src/ZHG2P.h

@@ -0,0 +1,48 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <memory>
+#include <utility>
+#include "Utils.h"
+#include "ZHFrontend.h"
+#include "EnG2P.h"
+
+// ZHG2P class definition...
+
+class ZHG2P {
+public:
+    // 构造函数注入文本处理器依赖
+    ZHG2P(std::shared_ptr<TextProcessor> processor, const std::string& version = "1.1", const std::string& unk = "<unk>", const std::string& eng_dict_path = "");
+
+    // 主调用接口: 返回 (IPA字符串, 附加信息/None)
+    std::pair<std::string, std::string> operator()(const std::string& text);
+
+    // 静态工具方法
+    static std::string retone(std::string p);
+    static std::string py2ipa(const std::string& py);
+    static std::string map_punctuation(std::string text);
+    
+    // 核心逻辑
+    std::string legacy_call(const std::string& text);
+
+    struct PinyinParts {
+        std::string initial;
+        std::string final;
+        int tone;
+    };
+    static PinyinParts parse_pinyin(const std::string& pinyin);
+
+    bool is_chinese(const std::string& str);
+
+private:
+    std::string version;
+    std::string unk;
+    std::shared_ptr<TextProcessor> processor;
+    std::unique_ptr<ZHFrontend> frontend;
+    std::unique_ptr<EnG2P> eng_g2p;
+
+    // IPA 转换相关的内部结构
+    static std::string pinyin_to_ipa_convert(const std::string& pinyin);
+    
+};

cpp/src/ax_model_runner/ax_model_runner.cpp

@@ -0,0 +1,442 @@
+/**************************************************************************************************
+ *
+ * Copyright (c) 2019-2025 Axera Semiconductor (Ningbo) Co., Ltd. All Rights Reserved.
+ *
+ * This source file is the property of Axera Semiconductor (Ningbo) Co., Ltd. and
+ * may not be copied or distributed in any isomorphic form without the prior
+ * written consent of Axera Semiconductor (Ningbo) Co., Ltd.
+ *
+ **************************************************************************************************/
+
+#include "ax_model_runner/ax_model_runner.hpp"
+#include "utils/logger.hpp"
+
+#include <ax_sys_api.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <vector>
+#include <cstdint>
+
+#define IO_CMM_ALIGN_SIZE   128
+
+AxModelRunner::AxModelRunner():
+    m_handle(nullptr),
+    m_pIOinfo(nullptr),
+    m_input_num(0),
+    m_output_num(0),
+    m_loaded(false) {
+
+    memset(&m_io, 0, sizeof(AX_ENGINE_IO_T));
+}
+
+AxModelRunner::~AxModelRunner() {
+    unload_model();
+}
+
+int AxModelRunner::load_model(const char* model_path, bool use_cmm, IO_BUFFER_STRATEGY_T strategy) {
+    FILE* fp = fopen(model_path, "rb");
+    if (NULL == fp) {
+        ALOGE("open model failed! model_path: %s", model_path);
+        return -1;
+    }
+        
+    fseek(fp, 0, SEEK_END);
+    int model_size = (int)ftell(fp);
+
+    fseek(fp, 0, SEEK_SET);
+
+    void *model_buffer = nullptr;
+    AX_U64 u64ModelBufferPhyAddr = 0;
+    AX_VOID* pModelBufferVirAddr = NULL;
+    std::vector<char> model_data;
+
+    if (use_cmm) {
+        AX_SYS_MemAlloc(&u64ModelBufferPhyAddr, &pModelBufferVirAddr, model_size, IO_CMM_ALIGN_SIZE, (AX_S8 *)model_path);
+        model_buffer = pModelBufferVirAddr;
+    } else {
+        model_data.resize(model_size);
+        model_buffer = model_data.data();
+    }
+    
+    fread(model_buffer, sizeof(char), model_size, fp);
+    fclose(fp);
+
+    auto free_model_buffer = [&]() {
+        if (use_cmm) {
+            if (u64ModelBufferPhyAddr != 0) {
+                AX_SYS_MemFree(u64ModelBufferPhyAddr, &pModelBufferVirAddr);
+            }
+        }
+        else {
+            std::vector<char>().swap(model_data);
+        }
+        return;
+    };
+
+    int ret = load_model_from_mem(model_buffer, model_size);
+    if (0 != ret) {
+        ALOGE("load_model_from_mem failed! ret=0x%x", ret);
+        free_model_buffer();
+        return ret;
+    }
+
+    m_strategy = strategy;
+    ret = _prepare_io();
+    if (0 != ret) {
+        ALOGE("_prepare_io failed! ret=0x%x", ret);
+        free_model_buffer();
+        _free_io();
+        return ret;
+    }
+
+    m_loaded = (ret == 0);
+
+    return ret;
+}
+
+int AxModelRunner::load_model_from_mem(void* data, int size) {
+    int ret = AX_ENGINE_CreateHandle(&m_handle, data, size);
+    if (0 != ret) {
+        ALOGE("AX_ENGINE_CreateHandle failed! ret=0x%x", ret);
+        return ret;
+    }
+        
+    ret = AX_ENGINE_CreateContext(m_handle);
+    if (0 != ret) {
+        ALOGE("AX_ENGINE_CreateContext failed! ret=0x%x", ret);
+        return ret;
+    }
+
+    return ret;
+}
+
+int AxModelRunner::unload_model(void) {
+    int ret = 0;
+    if (m_handle != 0) {
+        ret = AX_ENGINE_DestroyHandle(m_handle);
+        if (0 == ret)   
+            m_handle = 0;
+    }
+
+    _free_io();
+
+    return ret;
+}
+
+int AxModelRunner::run(void) {
+    int ret = AX_ENGINE_RunSync(m_handle, &m_io);
+    if (0 != ret) {
+        ALOGE("AX_ENGINE_RunSync failed! ret=0x%x", ret);
+        return ret;
+    }
+    return ret;
+}
+
+int AxModelRunner::set_input(int index, void* data) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return -1;
+    }
+
+    if (index < 0)  index += m_input_num;
+    if (index > m_input_num - 1) {
+        ALOGE("index(%d) exceed input_num(%d)", index, m_input_num);
+        return -1;
+    }
+
+    if (!data) {
+        ALOGE("data is null");
+        return -1;
+    }
+
+    memcpy(m_io.pInputs[index].pVirAddr, data, m_io.pInputs[index].nSize);
+    if (m_strategy == IO_BUFFER_STRATEGY_CACHED)
+        _cache_io_flush(m_io.pInputs[index]);
+
+    return 0;
+}
+
+int AxModelRunner::set_inputs(const std::vector<void*>& datas) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return -1;
+    }
+
+    for (int index = 0; index < m_input_num; index++) {
+        void* data = datas[index];
+        if (!data) {
+            ALOGE("index %d data is null", index);
+            return -1;
+        }
+
+        memcpy(m_io.pInputs[index].pVirAddr, data, m_io.pInputs[index].nSize);
+        if (m_strategy == IO_BUFFER_STRATEGY_CACHED)
+            _cache_io_flush(m_io.pInputs[index]);
+    }
+
+    return 0;
+}
+
+int AxModelRunner::get_output(int index, void* data) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return -1;
+    }
+
+    if (index < 0)  index += m_output_num;
+    if (index > m_output_num - 1) {
+        ALOGE("index(%d) exceed output_num(%d)", index, m_output_num);
+        return -1;
+    }
+
+    if (!data) {
+        ALOGE("data is null");
+        return -1;
+    }
+
+    if (m_strategy == IO_BUFFER_STRATEGY_CACHED)
+        _cache_io_flush(m_io.pOutputs[index]);
+
+    memcpy(data, m_io.pOutputs[index].pVirAddr, m_io.pOutputs[index].nSize);
+
+    return 0;
+}
+
+int AxModelRunner::get_outputs(const std::vector<void*>& datas) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return -1;
+    }
+
+    for (int index = 0; index < m_output_num; index++) {
+        void* data = datas[index];
+        if (!data) {
+            ALOGE("index %d data is null", index);
+            return -1;
+        }
+
+        if (m_strategy == IO_BUFFER_STRATEGY_CACHED)
+            _cache_io_flush(m_io.pOutputs[index]);
+
+        memcpy(data, m_io.pOutputs[index].pVirAddr, m_io.pOutputs[index].nSize);
+    }
+    
+    return 0;
+}
+
+void* AxModelRunner::get_input_ptr(int index) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return nullptr;
+    }
+
+    if (index < 0)  index += m_input_num;
+    if (index > m_input_num - 1) {
+        ALOGE("index(%d) exceed input_num(%d)", index, m_input_num);
+        return nullptr;
+    }
+
+    return m_io.pInputs[index].pVirAddr;
+}
+
+void* AxModelRunner::get_output_ptr(int index) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return nullptr;
+    }
+
+    if (index < 0)  index += m_output_num;
+    if (index > m_output_num - 1) {
+        ALOGE("index(%d) exceed output_num(%d)", index, m_output_num);
+        return nullptr;
+    }
+
+    return m_io.pOutputs[index].pVirAddr;
+}
+
+const char* AxModelRunner::get_input_name(int index) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return nullptr;
+    }
+
+    if (index < 0)  index += m_input_num;
+    if (index > m_input_num - 1) {
+        ALOGE("index(%d) exceed input_num(%d)", index, m_input_num);
+        return nullptr;
+    }
+
+    return m_input_names[index].c_str();
+}
+
+const char* AxModelRunner::get_output_name(int index) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return nullptr;
+    }
+
+    if (index < 0)  index += m_output_num;
+    if (index > m_output_num - 1) {
+        ALOGE("index(%d) exceed output_num(%d)", index, m_output_num);
+        return nullptr;
+    }
+
+    return m_output_names[index].c_str();
+}
+
+int AxModelRunner::get_input_size(int index) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return 0;
+    }
+
+    if (index < 0)  index += m_input_num;
+    if (index > m_input_num - 1) {
+        ALOGE("index(%d) exceed input_num(%d)", index, m_input_num);
+        return 0;
+    }
+
+    return m_pIOinfo->pInputs[index].nSize;
+}
+
+int AxModelRunner::get_output_size(int index) {
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return 0;
+    }
+
+    if (index < 0)  index += m_output_num;
+    if (index > m_output_num - 1) {
+        ALOGE("index(%d) exceed output_num(%d)", index, m_output_num);
+        return 0;
+    }
+
+    return m_pIOinfo->pOutputs[index].nSize;
+}
+
+std::vector<int> AxModelRunner::get_input_shape(int index) {
+    std::vector<int> shape;
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return shape;
+    }
+
+    if (index < 0)  index += m_input_num;
+    if (index > m_input_num - 1) {
+        ALOGE("index(%d) exceed input_num(%d)", index, m_input_num);
+        return shape;
+    }
+
+    shape.resize(m_pIOinfo->pInputs[index].nShapeSize);
+    for (int i = 0; i < shape.size(); i++) {
+        shape[i] = m_pIOinfo->pInputs[index].pShape[i];
+    }
+    return shape;
+}
+
+std::vector<int> AxModelRunner::get_output_shape(int index) {
+    std::vector<int> shape;
+    if (!m_loaded) {
+        ALOGE("model is not loaded!");
+        return shape;
+    }
+
+    if (index < 0)  index += m_output_num;
+    if (index > m_output_num - 1) {
+        ALOGE("index(%d) exceed output_num(%d)", index, m_output_num);
+        return shape;
+    }
+
+    shape.resize(m_pIOinfo->pOutputs[index].nShapeSize);
+    for (int i = 0; i < shape.size(); i++) {
+        shape[i] = m_pIOinfo->pOutputs[index].pShape[i];
+    }
+    return shape;
+}
+
+// ================ PRIVATE ================
+int AxModelRunner::_prepare_io() {
+    int ret = AX_ENGINE_GetIOInfo(m_handle, &m_pIOinfo);
+    if (0 != ret) {
+        ALOGE("AX_ENGINE_GetIOInfo failed! ret=0x%x", ret);
+        return ret;
+    }
+
+    m_input_num = m_pIOinfo->nInputSize;
+    m_output_num = m_pIOinfo->nOutputSize;
+
+    m_io.nInputSize = m_pIOinfo->nInputSize;
+    m_io.nOutputSize = m_pIOinfo->nOutputSize;
+
+    m_io.pInputs = new AX_ENGINE_IO_BUFFER_T[m_pIOinfo->nInputSize];
+    m_io.pOutputs = new AX_ENGINE_IO_BUFFER_T[m_pIOinfo->nOutputSize];
+
+    for (int i = 0; i < m_pIOinfo->nInputSize; i++) {
+        const char* layer_name = m_pIOinfo->pInputs[i].pName;
+        m_input_names.push_back(std::string(layer_name));
+
+        ret = _alloc_io_buffer(m_io.pInputs[i], m_pIOinfo->pInputs[i], m_strategy);
+        if (0 != ret) {
+            ALOGE("_alloc_io_buffer for input[%d] failed! ret=0x%x", i, ret);
+            return ret;
+        }
+    }
+
+    for (int i = 0; i < m_pIOinfo->nOutputSize; i++) {
+        const char* layer_name = m_pIOinfo->pOutputs[i].pName;
+        m_output_names.push_back(std::string(layer_name));
+
+        ret = _alloc_io_buffer(m_io.pOutputs[i], m_pIOinfo->pOutputs[i], m_strategy);
+        if (0 != ret) {
+            ALOGE("_alloc_io_buffer for output[%d] failed! ret=0x%x", i, ret);
+            return ret;
+        }
+    }
+
+    return ret;
+}
+
+void AxModelRunner::_free_io() {
+    for (size_t i = 0; i < m_io.nInputSize; i++) {
+        if (0 != m_io.pInputs[i].phyAddr)
+            AX_SYS_MemFree(m_io.pInputs[i].phyAddr, m_io.pInputs[i].pVirAddr);
+    }
+
+    for (size_t i = 0; i < m_io.nOutputSize; i++) {
+        if (0 != m_io.pOutputs[i].phyAddr)
+            AX_SYS_MemFree(m_io.pOutputs[i].phyAddr, m_io.pOutputs[i].pVirAddr);
+    }
+    
+    delete[] m_io.pInputs;
+    delete[] m_io.pOutputs;
+    memset(&m_io, 0, sizeof(AX_ENGINE_IO_T));
+}
+
+int AxModelRunner::_alloc_io_buffer(AX_ENGINE_IO_BUFFER_T& buffer, 
+        const AX_ENGINE_IOMETA_T &meta, IO_BUFFER_STRATEGY_T strategy) {
+    int ret = 0;
+    
+    memset(&buffer, 0, sizeof(AX_ENGINE_IO_BUFFER_T));
+    buffer.nSize = meta.nSize;
+    
+    if (IO_BUFFER_STRATEGY_DEFAULT == strategy) {
+        AX_SYS_MemAlloc((AX_U64*)&buffer.phyAddr, 
+            (AX_VOID**)&buffer.pVirAddr, 
+            meta.nSize, IO_CMM_ALIGN_SIZE, (const AX_S8*)meta.pName);
+    } else {
+        AX_SYS_MemAllocCached((AX_U64*)&buffer.phyAddr, 
+            (AX_VOID**)&buffer.pVirAddr, 
+            meta.nSize, IO_CMM_ALIGN_SIZE, (const AX_S8*)meta.pName);
+    }
+
+    return ret;
+}
+
+void AxModelRunner::_cache_io_flush(AX_ENGINE_IO_BUFFER_T &buffer) {
+    if (buffer.phyAddr != 0) {
+        AX_SYS_MflushCache(buffer.phyAddr, buffer.pVirAddr, buffer.nSize);
+    }
+}

cpp/src/ax_model_runner/ax_model_runner.hpp

@@ -0,0 +1,84 @@
+/**************************************************************************************************
+ *
+ * Copyright (c) 2019-2025 Axera Semiconductor (Ningbo) Co., Ltd. All Rights Reserved.
+ *
+ * This source file is the property of Axera Semiconductor (Ningbo) Co., Ltd. and
+ * may not be copied or distributed in any isomorphic form without the prior
+ * written consent of Axera Semiconductor (Ningbo) Co., Ltd.
+ *
+ **************************************************************************************************/
+
+#pragma once
+
+#include "ax_engine_api.h"
+
+#include <vector>
+#include <string>
+
+typedef enum _IO_BUFFER_STRATEGY_T {
+    IO_BUFFER_STRATEGY_DEFAULT = 0,
+    IO_BUFFER_STRATEGY_CACHED
+} IO_BUFFER_STRATEGY_T;
+
+class AxModelRunner {
+public:
+    AxModelRunner();
+
+    ~AxModelRunner();
+
+    int load_model(const char* model_path, bool use_cmm = true, IO_BUFFER_STRATEGY_T strategy = IO_BUFFER_STRATEGY_CACHED);
+
+    int load_model_from_mem(void* data, int size);
+
+    int unload_model(void);
+
+    int run(void);
+
+    int set_input(int index, void* data);
+    int set_inputs(const std::vector<void*>& datas);
+
+    int get_output(int index, void* data);
+    int get_outputs(const std::vector<void*>& datas);
+
+    inline int get_input_num(void) {
+        return m_input_num;
+    }
+
+    inline int get_output_num(void) {
+        return m_output_num;
+    }
+
+    void* get_input_ptr(int index);
+
+    void* get_output_ptr(int index);
+
+    const char* get_input_name(int index);
+
+    const char* get_output_name(int index);
+
+    int get_input_size(int index);
+
+    int get_output_size(int index);
+
+    std::vector<int> get_input_shape(int index);
+
+    std::vector<int> get_output_shape(int index);
+
+private:
+    int _prepare_io();
+    void _free_io();
+    int _alloc_io_buffer(AX_ENGINE_IO_BUFFER_T &buffer, 
+            const AX_ENGINE_IOMETA_T &meta, IO_BUFFER_STRATEGY_T strategy);
+    void _cache_io_flush(AX_ENGINE_IO_BUFFER_T &buffer);        
+    
+private:
+    AX_ENGINE_HANDLE m_handle;
+    AX_ENGINE_IO_T m_io;
+    AX_ENGINE_IO_INFO_T* m_pIOinfo;
+    int m_input_num;
+    int m_output_num;
+    IO_BUFFER_STRATEGY_T m_strategy;
+    std::vector<std::string> m_input_names;
+    std::vector<std::string> m_output_names;
+    bool m_loaded;
+};

cpp/src/cppjieba/DictTrie.hpp

@@ -0,0 +1,280 @@
+#ifndef CPPJIEBA_DICT_TRIE_HPP
+#define CPPJIEBA_DICT_TRIE_HPP
+
+#include <algorithm>
+#include <fstream>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <deque>
+#include <set>
+#include <string>
+#include <unordered_set>
+#include "limonp/StringUtil.hpp"
+#include "limonp/Logging.hpp"
+#include "Unicode.hpp"
+#include "Trie.hpp"
+
+namespace cppjieba {
+
+const double MIN_DOUBLE = -3.14e+100;
+const double MAX_DOUBLE = 3.14e+100;
+const size_t DICT_COLUMN_NUM = 3;
+const char* const UNKNOWN_TAG = "";
+
+class DictTrie {
+ public:
+  enum UserWordWeightOption {
+    WordWeightMin,
+    WordWeightMedian,
+    WordWeightMax,
+  }; // enum UserWordWeightOption
+
+  DictTrie(const std::string& dict_path, const std::string& user_dict_paths = "", UserWordWeightOption user_word_weight_opt = WordWeightMedian) {
+    Init(dict_path, user_dict_paths, user_word_weight_opt);
+  }
+
+  ~DictTrie() {
+    delete trie_;
+  }
+
+  bool InsertUserWord(const std::string& word, const std::string& tag = UNKNOWN_TAG) {
+    DictUnit node_info;
+    if (!MakeNodeInfo(node_info, word, user_word_default_weight_, tag)) {
+      return false;
+    }
+    active_node_infos_.push_back(node_info);
+    trie_->InsertNode(node_info.word, &active_node_infos_.back());
+    return true;
+  }
+
+  bool InsertUserWord(const std::string& word,int freq, const std::string& tag = UNKNOWN_TAG) {
+    DictUnit node_info;
+    double weight = freq ? log(1.0 * freq / freq_sum_) : user_word_default_weight_ ;
+    if (!MakeNodeInfo(node_info, word, weight , tag)) {
+      return false;
+    }
+    active_node_infos_.push_back(node_info);
+    trie_->InsertNode(node_info.word, &active_node_infos_.back());
+    return true;
+  }
+
+  bool DeleteUserWord(const std::string& word, const std::string& tag = UNKNOWN_TAG) {
+    DictUnit node_info;
+    if (!MakeNodeInfo(node_info, word, user_word_default_weight_, tag)) {
+      return false;
+    }
+    trie_->DeleteNode(node_info.word, &node_info);
+    return true;
+  }
+
+  const DictUnit* Find(RuneStrArray::const_iterator begin, RuneStrArray::const_iterator end) const {
+    return trie_->Find(begin, end);
+  }
+
+  void Find(RuneStrArray::const_iterator begin,
+        RuneStrArray::const_iterator end,
+        std::vector<struct Dag>&res,
+        size_t max_word_len = MAX_WORD_LENGTH) const {
+    trie_->Find(begin, end, res, max_word_len);
+  }
+
+  bool Find(const std::string& word)
+  {
+    const DictUnit *tmp = NULL;
+    RuneStrArray runes;
+    if (!DecodeUTF8RunesInString(word, runes))
+    {
+      XLOG(ERROR) << "Decode failed.";
+    }
+    tmp = Find(runes.begin(), runes.end());
+    if (tmp == NULL)
+    {
+      return false;
+    }
+    else
+    {
+      return true;
+    }
+  }
+
+  bool IsUserDictSingleChineseWord(const Rune& word) const {
+    return IsIn(user_dict_single_chinese_word_, word);
+  }
+
+  double GetMinWeight() const {
+    return min_weight_;
+  }
+
+  void InserUserDictNode(const std::string& line) {
+    std::vector<std::string> buf;
+    DictUnit node_info;
+    limonp::Split(line, buf, " ");
+    if(buf.size() == 1){
+          MakeNodeInfo(node_info,
+                buf[0],
+                user_word_default_weight_,
+                UNKNOWN_TAG);
+        } else if (buf.size() == 2) {
+          MakeNodeInfo(node_info,
+                buf[0],
+                user_word_default_weight_,
+                buf[1]);
+        } else if (buf.size() == 3) {
+          int freq = atoi(buf[1].c_str());
+          assert(freq_sum_ > 0.0);
+          double weight = log(1.0 * freq / freq_sum_);
+          MakeNodeInfo(node_info, buf[0], weight, buf[2]);
+        }
+        static_node_infos_.push_back(node_info);
+        if (node_info.word.size() == 1) {
+          user_dict_single_chinese_word_.insert(node_info.word[0]);
+        }
+  }
+
+  void LoadUserDict(const std::vector<std::string>& buf) {
+    for (size_t i = 0; i < buf.size(); i++) {
+      InserUserDictNode(buf[i]);
+    }
+  }
+
+   void LoadUserDict(const std::set<std::string>& buf) {
+    std::set<std::string>::const_iterator iter;
+    for (iter = buf.begin(); iter != buf.end(); iter++){
+      InserUserDictNode(*iter);
+    }
+  }
+
+  void LoadUserDict(const std::string& filePaths) {
+    std::vector<std::string> files = limonp::Split(filePaths, "|;");
+    for (size_t i = 0; i < files.size(); i++) {
+      std::ifstream ifs(files[i].c_str());
+      XCHECK(ifs.is_open()) << "open " << files[i] << " failed";
+      std::string line;
+
+      while(getline(ifs, line)) {
+        if (line.size() == 0) {
+          continue;
+        }
+        InserUserDictNode(line);
+      }
+    }
+  }
+
+
+ private:
+  void Init(const std::string& dict_path, const std::string& user_dict_paths, UserWordWeightOption user_word_weight_opt) {
+    LoadDict(dict_path);
+    freq_sum_ = CalcFreqSum(static_node_infos_);
+    CalculateWeight(static_node_infos_, freq_sum_);
+    SetStaticWordWeights(user_word_weight_opt);
+
+    if (user_dict_paths.size()) {
+      LoadUserDict(user_dict_paths);
+    }
+    Shrink(static_node_infos_);
+    CreateTrie(static_node_infos_);
+  }
+
+  void CreateTrie(const std::vector<DictUnit>& dictUnits) {
+    assert(dictUnits.size());
+    std::vector<Unicode> words;
+    std::vector<const DictUnit*> valuePointers;
+    for (size_t i = 0 ; i < dictUnits.size(); i ++) {
+      words.push_back(dictUnits[i].word);
+      valuePointers.push_back(&dictUnits[i]);
+    }
+
+    trie_ = new Trie(words, valuePointers);
+  }
+
+  bool MakeNodeInfo(DictUnit& node_info,
+        const std::string& word,
+        double weight,
+        const std::string& tag) {
+    if (!DecodeUTF8RunesInString(word, node_info.word)) {
+      XLOG(ERROR) << "UTF-8 decode failed for dict word: " << word;
+      return false;
+    }
+    node_info.weight = weight;
+    node_info.tag = tag;
+    return true;
+  }
+
+  void LoadDict(const std::string& filePath) {
+    std::ifstream ifs(filePath.c_str());
+    XCHECK(ifs.is_open()) << "open " << filePath << " failed.";
+    std::string line;
+    std::vector<std::string> buf;
+
+    DictUnit node_info;
+    while (getline(ifs, line)) {
+      limonp::Split(line, buf, " ");
+      XCHECK(buf.size() == DICT_COLUMN_NUM) << "split result illegal, line:" << line;
+      MakeNodeInfo(node_info,
+            buf[0],
+            atof(buf[1].c_str()),
+            buf[2]);
+      static_node_infos_.push_back(node_info);
+    }
+  }
+
+  static bool WeightCompare(const DictUnit& lhs, const DictUnit& rhs) {
+    return lhs.weight < rhs.weight;
+  }
+
+  void SetStaticWordWeights(UserWordWeightOption option) {
+    XCHECK(!static_node_infos_.empty());
+    std::vector<DictUnit> x = static_node_infos_;
+    std::sort(x.begin(), x.end(), WeightCompare);
+    min_weight_ = x[0].weight;
+    max_weight_ = x[x.size() - 1].weight;
+    median_weight_ = x[x.size() / 2].weight;
+    switch (option) {
+     case WordWeightMin:
+       user_word_default_weight_ = min_weight_;
+       break;
+     case WordWeightMedian:
+       user_word_default_weight_ = median_weight_;
+       break;
+     default:
+       user_word_default_weight_ = max_weight_;
+       break;
+    }
+  }
+
+  double CalcFreqSum(const std::vector<DictUnit>& node_infos) const {
+    double sum = 0.0;
+    for (size_t i = 0; i < node_infos.size(); i++) {
+      sum += node_infos[i].weight;
+    }
+    return sum;
+  }
+
+  void CalculateWeight(std::vector<DictUnit>& node_infos, double sum) const {
+    assert(sum > 0.0);
+    for (size_t i = 0; i < node_infos.size(); i++) {
+      DictUnit& node_info = node_infos[i];
+      assert(node_info.weight > 0.0);
+      node_info.weight = log(double(node_info.weight)/sum);
+    }
+  }
+
+  void Shrink(std::vector<DictUnit>& units) const {
+    std::vector<DictUnit>(units.begin(), units.end()).swap(units);
+  }
+
+  std::vector<DictUnit> static_node_infos_;
+  std::deque<DictUnit> active_node_infos_; // must not be std::vector
+  Trie * trie_;
+
+  double freq_sum_;
+  double min_weight_;
+  double max_weight_;
+  double median_weight_;
+  double user_word_default_weight_;
+  std::unordered_set<Rune> user_dict_single_chinese_word_;
+};
+}
+
+#endif