Upload the cpp version

.gitattributes

@@ -35,6 +35,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 assets/moss_prompts/en_4_4p5s.wav filter=lfs diff=lfs merge=lfs -text
 assets/moss_prompts/zh_1_4p5s.wav filter=lfs diff=lfs merge=lfs -text
+cpp/install/ax650/zipvoice_axera filter=lfs diff=lfs merge=lfs -text
+cpp/vocoder/vocos_full.axmodel filter=lfs diff=lfs merge=lfs -text
 models/zipvoice_ax650/decoder_part0.axmodel filter=lfs diff=lfs merge=lfs -text
 models/zipvoice_ax650/decoder_part1.axmodel filter=lfs diff=lfs merge=lfs -text
 models/zipvoice_ax650/decoder_part2.axmodel filter=lfs diff=lfs merge=lfs -text
@@ -50,19 +52,11 @@ models/zipvoice_distill_ax650/decoder_part1.axmodel filter=lfs diff=lfs merge=lf
 models/zipvoice_distill_ax650/decoder_part2.axmodel filter=lfs diff=lfs merge=lfs -text
 models/zipvoice_distill_ax650/decoder_part3.axmodel filter=lfs diff=lfs merge=lfs -text
 models/zipvoice_distill_ax650/encoder.axmodel filter=lfs diff=lfs merge=lfs -text
-outputs/en_long_paragraph.wav filter=lfs diff=lfs merge=lfs -text
+outputs/en_long_paragraph_ax650.wav filter=lfs diff=lfs merge=lfs -text
 outputs/en_long_paragraph_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-outputs/en_sentence.wav filter=lfs diff=lfs merge=lfs -text
+outputs/en_sentence_ax650.wav filter=lfs diff=lfs merge=lfs -text
 outputs/en_sentence_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-outputs/zh_long_paragraph.wav filter=lfs diff=lfs merge=lfs -text
+outputs/zh_long_paragraph_ax650.wav filter=lfs diff=lfs merge=lfs -text
 outputs/zh_long_paragraph_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-outputs/zh_sentence.wav filter=lfs diff=lfs merge=lfs -text
+outputs/zh_sentence_ax650.wav filter=lfs diff=lfs merge=lfs -text
 outputs/zh_sentence_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-en_long_paragraph_ax650.wav filter=lfs diff=lfs merge=lfs -text
-en_long_paragraph_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-en_sentence_ax650.wav filter=lfs diff=lfs merge=lfs -text
-en_sentence_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-zh_long_paragraph_ax650.wav filter=lfs diff=lfs merge=lfs -text
-zh_long_paragraph_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text
-zh_sentence_ax650.wav filter=lfs diff=lfs merge=lfs -text
-zh_sentence_distill_ax650.wav filter=lfs diff=lfs merge=lfs -text

README.md

@@ -265,3 +265,16 @@ RTF: 0.3045
 ## 参考
 
 - [ZipVoice](https://github.com/k2-fsa/ZipVoice)
+
+## C++ 版本
+
+纯 C++ 推理实现，全链路 axmodel，性能更高。详见 [/data/shared/huyuan/TTS/ZipVoice.AXERA/cpp/README.md](cpp/README.md)。
+
+### 性能对比 (AX650 Distill, 中文段落, 44.97s 音频)
+
+| 版本 | 推理耗时 | RTF |
+|------|---------|-----|
+| Python | 13.457s | 0.30 |
+| C++ | 7.357s | 0.16 |
+
+C++ 版本比 Python 快约 **1.8x**，vocoder IRFFT 使用 kissfft 比 Python torch.istft 快约 30x。

cpp/.gitattributes

@@ -0,0 +1,2 @@
+*.axmodel filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

cpp/CMakeLists.txt

@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+project(zipvoice_axera)
+
+set(CMAKE_CXX_STANDARD 14)
+
+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 -fdata-sections -ffunction-sections")
+endif()
+
+# AXERA MSP (Media Software Platform) dependencies
+# Adjust these paths to match your SDK installation
+include(cmake/msp_dependencies.cmake)
+
+include_directories(${MSP_INC_DIR})
+link_directories(${MSP_LIB_DIR})
+
+# Project includes (project root so "utils/io.hpp" and "src/EngineWrapper.hpp" resolve)
+include_directories(${CMAKE_SOURCE_DIR})
+
+# Source files
+set(SRC
+    src/EngineWrapper.cpp
+    src/tokenizer.cpp
+    src/fbank.cpp
+    src/zipvoice_engine.cpp
+    src/vocoder.cpp
+    third_party/kissfft/kiss_fft.c
+)
+
+add_executable(${PROJECT_NAME} zipvoice.cpp ${SRC})
+target_include_directories(${PROJECT_NAME} PRIVATE third_party/kissfft)
+target_link_libraries(${PROJECT_NAME} ${MSP_LIBS})
+
+install(TARGETS ${PROJECT_NAME}
+        RUNTIME DESTINATION ./)
+set_target_properties(${PROJECT_NAME}
+    PROPERTIES
+    INSTALL_RPATH "$ORIGIN/")
+
+# Print configuration summary
+message(STATUS "========================================")
+message(STATUS "ZipVoice AXERA C++ Build Configuration")
+message(STATUS "========================================")
+message(STATUS "MSP_INC_DIR: ${MSP_INC_DIR}")
+message(STATUS "MSP_LIB_DIR: ${MSP_LIB_DIR}")
+message(STATUS "MSP_LIBS:    ${MSP_LIBS}")
+message(STATUS "========================================")

cpp/README.md

@@ -0,0 +1,286 @@
+# ZipVoice AXERA C++
+
+ZipVoice TTS 在 AXERA NPU 板卡上的 C++ 推理实现。全链路 axmodel，无 Python 依赖（英文分词除外）。
+
+## 性能 (AX650)
+
+### Distill 模型
+
+| 场景 | 音频 | 耗时 | RTF |
+|------|------|------|-----|
+| 中文句子 | 6.41s | 1.057s | 0.165 |
+| 中文段落 | 44.97s | 7.357s | 0.164 |
+| 英文句子 | 6.41s | 1.067s | 0.166 |
+| 英文段落 | 59.31s | 10.529s | 0.178 |
+
+### 普通模型
+
+| 场景 | 音频 | 耗时 | RTF |
+|------|------|------|-----|
+| 中文句子 | 6.41s | 5.709s | 0.891 |
+| 中文段落 | 44.97s | 39.714s | 0.883 |
+| 英文句子 | 6.41s | 5.693s | 0.888 |
+| 英文段落 | 59.31s | 56.759s | 0.957 |
+
+
+
+## 目录结构
+
+```
+├── CMakeLists.txt              # 构建配置
+├── zipvoice.cpp                # 主程序
+├── build_ax650.sh              # 交叉编译脚本
+├── download_bsp.sh             # 下载 BSP SDK
+├── cmake/
+│   └── msp_dependencies.cmake  # MSP SDK 配置
+├── toolchains/
+│   └── aarch64-none-linux-gnu.toolchain.cmake  # 工具链
+├── third_party/kissfft/        # kissfft (vocoder IRFFT)
+├── utils/                      # 日志/IO/检查
+├── src/                        # 核心源码
+│   ├── EngineWrapper.*         # AX引擎封装
+│   ├── tokenizer.*             # 中文分词 (41K汉字pinyin映射)
+│   ├── pinyin_table.hpp        # 汉字→拼音表 (自动生成)
+│   ├── fbank.*                 # Mel滤波器 (FFT)
+│   ├── zipvoice_engine.*       # 推理引擎 (encoder+decoder4)
+│   ├── vocoder.*               # 声码器 (axmodel+kissfft IRFFT)
+│   └── wav_writer.hpp          # WAV写入
+├── vocoder/
+│   └── vocos_full.axmodel      # 量化声码器 (15MB)
+├── scripts/                    # Python辅助脚本
+│   ├── gen_cat_tokens.py       # 预计算token
+│   ├── gen_pinyin_table.py     # 生成汉字映射表
+│   ├── export_vocos_onnx.py    # 导出ONNX
+│   ├── generate_vocoder_calib.py # 校准数据
+│   └── quantize_vocoder.sh     # pulsar2量化
+└── README.md
+```
+
+## 环境准备
+
+```bash
+# 下载 BSP SDK
+bash download_bsp.sh
+
+# 安装交叉编译器
+wget https://developer.arm.com/-/media/Files/downloads/gnu-a/9.2-2019.12/binrel/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz
+tar -xf gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz
+# 编译时传 -DTOOLCHAIN_DIR=/path/to/gcc-arm-... 或在 toolchains/ 中修改
+```
+
+## 编译
+
+```bash
+mkdir build_ax650 && cd build_ax650
+cmake .. \
+    -DCMAKE_TOOLCHAIN_FILE=../toolchains/aarch64-none-linux-gnu.toolchain.cmake \
+    -DTOOLCHAIN_DIR=/path/to/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu \
+    -DCMAKE_INSTALL_PREFIX=../install/ax650 \
+    -DCMAKE_BUILD_TYPE=Release
+make -j$(nproc) && make install
+```
+
+## 板端推理
+
+所有命令在 repo 根目录（`ZipVoice.AXERA/`）下执行。
+
+### 中文
+
+```bash
+# 普通模型 — 句子
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_ax650 \
+    --token-file ./resources/zipvoice_hf/zipvoice/tokens.txt \
+    --prompt-wav ./assets/moss_prompts/zh_1_4p5s.wav \
+    --prompt-text "不管怎么样我和汤姆还是要感谢贝尔卡金的援手" \
+    --text "今天午后天气很好，我打开窗户，听见远处有人聊天，水杯也轻轻晃了一下。" \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        1
+  Audio duration:  6.41 s
+  Total time:      5.71 s
+  RTF (端到端):    0.891
+```
+
+```bash
+# 蒸馏模型 — 句子 (约3倍速)
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_distill_ax650 \
+    --token-file ./resources/zipvoice_hf/zipvoice/tokens.txt \
+    --prompt-wav ./assets/moss_prompts/zh_1_4p5s.wav \
+    --prompt-text "不管怎么样我和汤姆还是要感谢贝尔卡金的援手" \
+    --text "今天午后天气很好，我打开窗户，听见远处有人聊天，水杯也轻轻晃了一下。" \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        1
+  Audio duration:  6.41 s
+  Total time:      1.06 s
+  RTF (端到端):    0.165
+```
+
+```bash
+# 普通模型 — 段落
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_ax650 \
+    --token-file ./resources/zipvoice_hf/zipvoice/tokens.txt \
+    --prompt-wav ./assets/moss_prompts/zh_1_4p5s.wav \
+    --prompt-text "不管怎么样我和汤姆还是要感谢贝尔卡金的援手" \
+    --text-file ./assets/paragraphs/zh_ginkgo.txt \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        7
+  Audio duration:  44.97 s
+  Total time:      39.71 s
+  RTF (端到端):    0.883
+```
+
+```bash
+# 蒸馏��型 — 段落
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_distill_ax650 \
+    --token-file ./resources/zipvoice_hf/zipvoice/tokens.txt \
+    --prompt-wav ./assets/moss_prompts/zh_1_4p5s.wav \
+    --prompt-text "不管怎么样我和汤姆还是要感谢贝尔卡金的援手" \
+    --text-file ./assets/paragraphs/zh_ginkgo.txt \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        7
+  Audio duration:  44.97 s
+  Total time:      7.38 s
+  RTF (端到端):    0.164
+```
+
+### 英文 (加 `--repo-dir .` 自动调 Python 分词器)
+
+```bash
+# 普通模型 — 句子
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_ax650 \
+    --prompt-wav ./assets/moss_prompts/en_4_4p5s.wav \
+    --prompt-text "This is almost twice the current industry production level per train." \
+    --text "This morning, a small train left the station, carrying sleepy passengers toward a bright coastal town." \
+    --repo-dir . \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output_en.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        1
+  Audio duration:  6.41 s
+  Total time:      5.69 s
+  RTF (端到端):    0.888
+```
+
+```bash
+# 蒸馏模型 — 句子
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_distill_ax650 \
+    --prompt-wav ./assets/moss_prompts/en_4_4p5s.wav \
+    --prompt-text "This is almost twice the current industry production level per train." \
+    --text "This morning, a small train left the station, carrying sleepy passengers toward a bright coastal town." \
+    --repo-dir . \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output_en.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        1
+  Audio duration:  6.41 s
+  Total time:      1.06 s
+  RTF (端到端):    0.166
+```
+
+```bash
+# 普通模型 — 段落
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_ax650 \
+    --prompt-wav ./assets/moss_prompts/en_4_4p5s.wav \
+    --prompt-text "This is almost twice the current industry production level per train." \
+    --text-file ./assets/paragraphs/en_scavenger.txt \
+    --repo-dir . \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output_en.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        10
+  Audio duration:  59.31 s
+  Total time:      56.76 s
+  RTF (端到端):    0.957
+```
+
+```bash
+# 蒸馏模型 — 段落
+cpp/install/ax650/zipvoice_axera \
+    --model-dir ./models/zipvoice_distill_ax650 \
+    --prompt-wav ./assets/moss_prompts/en_4_4p5s.wav \
+    --prompt-text "This is almost twice the current industry production level per train." \
+    --text-file ./assets/paragraphs/en_scavenger.txt \
+    --repo-dir . \
+    --vocoder-model ./cpp/vocoder/vocos_full.axmodel \
+    --output-wav output_en.wav --seed 42
+```
+
+```text
+推理结果:
+  Segments:        10
+  Audio duration:  59.31 s
+  Total time:      10.56 s
+  RTF (端到端):    0.178
+```
+
+## 命令行参数
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `--model-dir` | 模型目录 | 必填 |
+| `--token-file` | tokens.txt (中文) | 可选 |
+| `--prompt-wav` | 提示音频 | 必填 |
+| `--prompt-text` | 提示文本 | 必填 |
+| `--text` / `--text-file` | 合成文本 | 二选一 |
+| `--repo-dir` | repo根目录 (英文分词) | 可选 |
+| `--vocoder-model` | vocos axmodel 路径 | 必填 |
+| `--output-wav` | 输出WAV | output.wav |
+| `--num-step` | 采样步数 | 10 (distill: 4) |
+| `--speed` | 语速 | 1.0 |
+| `--seed` | 随机种子 | 42 |
+
+## 重新量化 vocoder
+
+```bash
+cd cpp/scripts
+python3 export_vocos_onnx.py       # 导出ONNX
+python3 generate_vocoder_calib.py  # 生成校准数据
+source /path/to/npu_dev && bash quantize_vocoder.sh  # 量化
+```
+
+## 实现要点
+
+- **中文分词**: C++ 内置, 基于 pypinyin 的 41K 汉字→拼音映射表, 0ms 开销
+- **英文分词**: Python daemon 持久进程, 首次 import ~8s, 后续每次 ~10ms
+- **长文本分段**: 对齐 Python `text_processing.build_segments`, 自动按 token/帧数约束切段
+- **声码器**: vocos axmodel (NPU) + kissfft IRFFT (CPU), 比手写逐点版快 ~30x
+- **RTF 口径**: 仅计入增量推理 (tokenizer + encoder + decoder + vocoder), 不含一次性初始化
+
+## 许可
+
+MIT License

cpp/build_ax650.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Cross-compile ZipVoice AXERA for AX650 / AX630C
+#
+# Prerequisite: download_bsp.sh (run once to clone ax650n_bsp_sdk)
+#               cross compiler at /data/shared/huyuan/toolchains/
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+rm -rf build_ax650
+mkdir -p build_ax650 && cd build_ax650
+
+cmake .. \
+  -DCMAKE_TOOLCHAIN_FILE=../toolchains/aarch64-none-linux-gnu.toolchain.cmake \
+  -DTOOLCHAIN_DIR=/data/shared/huyuan/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu \
+  -DCMAKE_INSTALL_PREFIX=../install/ax650 \
+  -DCMAKE_BUILD_TYPE=Release \
+  $@
+
+make -j$(nproc)
+make install
+
+echo ""
+echo "========================================"
+echo "Build complete!"
+echo "Executable: $(pwd)/../install/ax650/zipvoice_axera"
+echo "========================================"

cpp/cmake/msp_dependencies.cmake

@@ -0,0 +1,26 @@
+# BSP MSP (Media Software Platform) Dependencies Configuration
+# Uses ax650n_bsp_sdk cloned from https://github.com/AXERA-TECH/ax650n_bsp_sdk.git
+#
+# Reference: melotts.axera-main/cpp/cmake/msp_dependencies.cmake
+
+# bsp
+if(NOT BSP_MSP_DIR)
+    set(BSP_MSP_DIR ${CMAKE_SOURCE_DIR}/ax650n_bsp_sdk/msp/out)
+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. Run download_bsp.sh first.")
+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)
+
+# Allow the linker to find transitive dependencies in the BSP lib dir
+link_directories(${MSP_LIB_DIR})

cpp/download_bsp.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+if [ ! -d ax650n_bsp_sdk ]; then
+  git clone https://github.com/AXERA-TECH/ax650n_bsp_sdk.git
+fi

cpp/install/ax650/zipvoice_axera

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d15168590f21a4255f223055008fb6832babf8a1f096c39f93afe0d78fb4c98
+size 582624

cpp/scripts/compare_vocoder.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+Compare PyTorch vocoder vs quantized axmodel output.
+Saves intermediate tensors for board-side comparison.
+
+Usage:
+  # Dev machine: generate test data
+  python3 compare_vocoder.py --save-test-data
+
+  # Board: run axmodel on same input, save output
+  python3 compare_vocoder.py --run-axmodel
+
+  # Dev machine: compare results
+  python3 compare_vocoder.py --compare
+"""
+import sys, os, math, argparse
+import numpy as np
+
+REPO_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+ONNX_DIR = os.path.join(REPO_DIR, 'cpp', 'vocoder_onnx')
+TEST_DIR = os.path.join(ONNX_DIR, 'test_data')
+os.makedirs(TEST_DIR, exist_ok=True)
+
+FEAT_SCALE = 0.1
+N_FFT = 1024
+HOP = 256
+
+
+def irfft_overlap_add(real_spec, imag_spec):
+    """C++ IRFFT + overlap-add, verified to match PyTorch istft (cos_sim=0.999999)."""
+    n_freqs = N_FFT // 2 + 1
+    T = real_spec.shape[1]
+    window = 0.5 * (1.0 - np.cos(2.0 * math.pi * np.arange(N_FFT) / (N_FFT - 1)))
+    window_sq = window ** 2
+
+    # Build IRFFT basis
+    irfft_cos = np.zeros((N_FFT, n_freqs), dtype=np.float32)
+    irfft_sin = np.zeros((N_FFT, n_freqs), dtype=np.float32)
+    for n in range(N_FFT):
+        for k in range(n_freqs):
+            ang = 2.0 * math.pi * k * n / N_FFT
+            if k == 0:
+                irfft_cos[n, k] = 1.0 / N_FFT
+                irfft_sin[n, k] = 0.0
+            elif k == n_freqs - 1:
+                irfft_cos[n, k] = math.cos(ang) / N_FFT
+                irfft_sin[n, k] = 0.0
+            else:
+                irfft_cos[n, k] = math.cos(ang) * (2.0 / N_FFT)
+                irfft_sin[n, k] = math.sin(ang) * (2.0 / N_FFT)
+
+    out_len = (T - 1) * HOP + N_FFT
+    audio = np.zeros(out_len, dtype=np.float32)
+    envelope = np.zeros(out_len, dtype=np.float32)
+
+    for t in range(T):
+        r = real_spec[0, t, :]
+        im = imag_spec[0, t, :]
+        frame = irfft_cos @ r - irfft_sin @ im
+        pos = t * HOP
+        for n in range(N_FFT):
+            p = pos + n
+            if p < out_len:
+                audio[p] += frame[n] * window[n]
+                envelope[p] += window_sq[n]
+
+    audio /= np.maximum(envelope, 1e-10)
+    pad = N_FFT // 2
+    return audio[pad:pad + (T - 1) * HOP]
+
+
+def compare(name, ref, test):
+    ref = np.asarray(ref, dtype=np.float32).flatten()
+    test = np.asarray(test, dtype=np.float32).flatten()
+    if len(ref) != len(test):
+        print(f"  [{name}] SIZE MISMATCH: ref={ref.shape} test={test.shape}")
+        return
+    diff = np.abs(ref - test)
+    sig = np.mean(np.abs(ref)) + 1e-10
+    cos = np.dot(ref, test) / (np.linalg.norm(ref) * np.linalg.norm(test) + 1e-10)
+    print(f"  [{name}] max_err={diff.max():.2e}  rel_err={diff.mean()/sig:.2e}  cos_sim={cos:.6f}")
+
+
+def cmd_save_test_data():
+    """Generate test mel and save PT/ONNX reference outputs."""
+    import torch
+    sys.path.insert(0, REPO_DIR)
+    from scripts.local_vocos import LocalVocos
+    import onnxruntime as ort
+
+    # Load models
+    vocoder = LocalVocos()
+    sd = torch.load(f'{REPO_DIR}/resources/vocos-mel-24khz/pytorch_model.bin',
+                    weights_only=True, map_location='cpu')
+    sd = {k: v for k, v in sd.items() if k.startswith(('backbone.', 'head.'))}
+    vocoder.load_state_dict(sd)
+    vocoder.eval()
+
+    sess_f = ort.InferenceSession(f'{ONNX_DIR}/vocos_full_B1_T620.onnx')
+
+    # Load real mel or generate random
+    mel_bin = os.path.join(REPO_DIR, 'cpp', 'output_mel.bin')
+    if os.path.exists(mel_bin):
+        real_mel = np.fromfile(mel_bin, dtype=np.float32).reshape(-1, 100)  # [T, 100]
+        T = real_mel.shape[0]
+        # Undo feat_scale, transpose to [1, 100, T]
+        mel_input = (real_mel / FEAT_SCALE).T[np.newaxis, :, :].astype(np.float32)  # [1, 100, T]
+        print(f"Using real mel: shape={mel_input.shape}, range=[{mel_input.min():.3f}, {mel_input.max():.3f}]")
+    else:
+        T = 200
+        mel_input = np.random.RandomState(42).randn(1, 100, T).astype(np.float32) * 3.0
+        print(f"Using random mel: shape={mel_input.shape}")
+
+    # Pad to 620 for ONNX
+    T_pad = 620
+    mel_onnx = np.zeros((1, 100, T_pad), dtype=np.float32)
+    mel_onnx[:, :, :T] = mel_input[:, :, :T]
+
+    # PT inference
+    mel_pt = torch.from_numpy(mel_input)
+    with torch.no_grad():
+        features_pt = vocoder.backbone(mel_pt)
+        audio_pt = vocoder.head(features_pt).squeeze().numpy()
+        h = vocoder.head.out(features_pt)
+        mag, phase = h.chunk(2, dim=-1)
+        mag = torch.exp(mag).clamp(max=1e2)
+        real_pt = (mag * torch.cos(phase)).numpy()
+        imag_pt = (mag * torch.sin(phase)).numpy()
+
+    # ONNX inference
+    onnx_out = sess_f.run(None, {'mel': mel_onnx})
+    real_onnx = onnx_out[0][:, :T, :]
+    imag_onnx = onnx_out[1][:, :T, :]
+    audio_onnx = irfft_overlap_add(real_onnx, imag_onnx)
+
+    # Save everything
+    np.save(f'{TEST_DIR}/mel_input.npy', mel_input)
+    np.save(f'{TEST_DIR}/mel_onnx_padded.npy', mel_onnx)
+    np.save(f'{TEST_DIR}/pt_real.npy', real_pt)
+    np.save(f'{TEST_DIR}/pt_imag.npy', imag_pt)
+    np.save(f'{TEST_DIR}/pt_audio.npy', audio_pt)
+    np.save(f'{TEST_DIR}/onnx_real.npy', real_onnx)
+    np.save(f'{TEST_DIR}/onnx_imag.npy', imag_onnx)
+    np.save(f'{TEST_DIR}/onnx_audio.npy', audio_onnx)
+    np.save(f'{TEST_DIR}/T_frames.npy', np.array([T], dtype=np.int32))
+
+    # Meta
+    with open(f'{TEST_DIR}/info.txt', 'w') as f:
+        f.write(f"T={T}\n")
+        f.write(f"feat_scale={FEAT_SCALE}\n")
+        f.write(f"mel_range=[{mel_input.min():.4f}, {mel_input.max():.4f}]\n")
+        f.write(f"pt_real_range=[{real_pt.min():.4f}, {real_pt.max():.4f}]\n")
+        f.write(f"pt_audio_len={len(audio_pt)}\n")
+
+    # Verify PT vs ONNX
+    print("\n=== PT vs ONNX (dev machine) ===")
+    compare('real_spectrum', real_pt, real_onnx)
+    compare('imag_spectrum', imag_pt, imag_onnx)
+    compare('audio', audio_pt, audio_onnx)
+
+    # Also write audio files for listening
+    import soundfile as sf
+    sf.write(f'{TEST_DIR}/pt_audio.wav', audio_pt, 24000)
+    sf.write(f'{TEST_DIR}/onnx_audio.wav', audio_onnx, 24000)
+
+    print(f"\nTest data saved to {TEST_DIR}/")
+    print("Copy to board and run: python3 compare_vocoder.py --run-axmodel")
+
+
+def cmd_run_axmodel():
+    """Run axmodel on board with the same test mel, save output."""
+    import onnxruntime as ort
+    from axengine import InferenceSession
+
+    T = int(np.load(f'{TEST_DIR}/T_frames.npy')[0])
+    mel_onnx = np.load(f'{TEST_DIR}/mel_onnx_padded.npy')
+
+    # Run axmodel
+    model_path = f'{ONNX_DIR}/axmodel/vocos_full.axmodel'
+    if not os.path.exists(model_path):
+        print(f"ERROR: {model_path} not found")
+        return
+
+    print(f"Loading axmodel: {model_path}")
+    sess = InferenceSession(model_path)
+
+    print(f"Running inference (mel shape={mel_onnx.shape})...")
+    outputs = sess.run(None, {'mel': mel_onnx})
+    print(f"Output keys: {list(outputs.keys()) if isinstance(outputs, dict) else type(outputs)}")
+
+    # Extract real/imag
+    if isinstance(outputs, dict):
+        real_ax = outputs['real'][:, :T, :]
+        imag_ax = outputs['imag'][:, :T, :]
+    elif isinstance(outputs, (list, tuple)):
+        real_ax = outputs[0][:, :T, :]
+        imag_ax = outputs[1][:, :T, :]
+    else:
+        real_ax = outputs[:, :T, :]  # guess
+        imag_ax = None
+
+    audio_ax = irfft_overlap_add(real_ax, imag_ax)
+
+    # Save
+    np.save(f'{TEST_DIR}/ax_real.npy', real_ax)
+    np.save(f'{TEST_DIR}/ax_imag.npy', imag_ax)
+    np.save(f'{TEST_DIR}/ax_audio.npy', audio_ax)
+    import soundfile as sf
+    sf.write(f'{TEST_DIR}/ax_audio.wav', audio_ax, 24000)
+
+    # Compare with ONNX reference
+    onnx_real = np.load(f'{TEST_DIR}/onnx_real.npy')
+    onnx_imag = np.load(f'{TEST_DIR}/onnx_imag.npy')
+    onnx_audio = np.load(f'{TEST_DIR}/onnx_audio.npy')
+
+    print("\n=== axmodel vs ONNX (board) ===")
+    compare('real_spectrum', onnx_real, real_ax)
+    compare('imag_spectrum', onnx_imag, imag_ax)
+    compare('audio', onnx_audio, audio_ax)
+
+    print(f"\nResults saved to {TEST_DIR}/")
+    print("Copy back to dev machine and run: python3 compare_vocoder.py --compare")
+
+
+def cmd_compare():
+    """Compare all outputs (dev machine, after copying ax_*.npy from board)."""
+    pt_audio    = np.load(f'{TEST_DIR}/pt_audio.npy')
+    onnx_audio  = np.load(f'{TEST_DIR}/onnx_audio.npy')
+    ax_audio    = np.load(f'{TEST_DIR}/ax_audio.npy')
+
+    pt_real  = np.load(f'{TEST_DIR}/pt_real.npy')
+    onnx_real = np.load(f'{TEST_DIR}/onnx_real.npy')
+    ax_real   = np.load(f'{TEST_DIR}/ax_real.npy')
+
+    pt_imag  = np.load(f'{TEST_DIR}/pt_imag.npy')
+    onnx_imag = np.load(f'{TEST_DIR}/onnx_imag.npy')
+    ax_imag   = np.load(f'{TEST_DIR}/ax_imag.npy')
+
+    print("=== Full Comparison ===")
+    print("\n--- Spectrum ---")
+    compare('real: PT vs ONNX', pt_real, onnx_real)
+    compare('real: PT vs axmodel', pt_real, ax_real)
+    compare('real: ONNX vs axmodel', onnx_real, ax_real)
+    print()
+    compare('imag: PT vs ONNX', pt_imag, onnx_imag)
+    compare('imag: PT vs axmodel', pt_imag, ax_imag)
+    compare('imag: ONNX vs axmodel', onnx_imag, ax_imag)
+
+    print("\n--- Audio ---")
+    compare('audio: PT vs ONNX', pt_audio, onnx_audio)
+    compare('audio: PT vs axmodel', pt_audio, ax_audio)
+    compare('audio: ONNX vs axmodel', onnx_audio, ax_audio)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--save-test-data', action='store_true')
+    parser.add_argument('--run-axmodel', action='store_true')
+    parser.add_argument('--compare', action='store_true')
+    args = parser.parse_args()
+
+    if args.save_test_data:
+        cmd_save_test_data()
+    elif args.run_axmodel:
+        cmd_run_axmodel()
+    elif args.compare:
+        cmd_compare()
+    else:
+        print("Usage: --save-test-data | --run-axmodel | --compare")
+        print("\nWorkflow:")
+        print("  1. Dev machine:  python3 compare_vocoder.py --save-test-data")
+        print("  2. Copy TEST_DIR to board, run: python3 compare_vocoder.py --run-axmodel")
+        print("  3. Copy ax_*.npy back to dev, run: python3 compare_vocoder.py --compare")
+
+
+if __name__ == '__main__':
+    main()

cpp/scripts/export_vocos_onnx.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+Export Vocos ONNX models with onnxsim optimization.
+
+Static shapes (B=1, T=620):
+  vocos_backbone_B1_T620.onnx     mel [1,100,620] → features [1,620,512]
+  vocos_head_linear_B1_T620.onnx  features [1,620,512] → (real, imag) [1,620,513]
+  vocos_full_B1_T620.onnx         mel [1,100,620] → (real, imag) [1,620,513]
+
+IRFFT + window + overlap-add is handled in C++ (simple, ~50 lines with existing FFT).
+"""
+import sys, os, math
+import numpy as np
+import torch
+import torch.nn as nn
+import onnx
+from onnxsim import simplify
+
+REPO_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, REPO_DIR)
+from scripts.local_vocos import LocalVocos, ISTFTHead
+
+OUT_DIR = os.path.join(REPO_DIR, 'cpp', 'vocoder_onnx')
+os.makedirs(OUT_DIR, exist_ok=True)
+
+
+class HeadLinearOnly(nn.Module):
+    """Linear(512→1026) + mag/phase → real/imag spectrum. No ISTFT."""
+    def __init__(self, head: ISTFTHead):
+        super().__init__()
+        self.out = head.out  # Linear(512, 1026)
+    def forward(self, x):    # x: [B, T, 512]
+        h = self.out(x); mag, phase = h.chunk(2, dim=-1)
+        mag = torch.exp(mag).clamp(max=1e2)
+        return mag * torch.cos(phase), mag * torch.sin(phase)
+
+
+class FullModel(nn.Module):
+    def __init__(self, backbone, head_linear):
+        super().__init__()
+        self.backbone = backbone
+        self.head_linear = head_linear
+    def forward(self, mel):
+        return self.head_linear(self.backbone(mel))
+
+
+def export_onnx(model, dummy, path, in_names, out_names, dyn=None):
+    tmp = path + '.tmp'
+    torch.onnx.export(model, dummy, tmp,
+                      input_names=in_names, output_names=out_names,
+                      dynamic_axes=dyn, opset_version=17, do_constant_folding=True)
+    model_simp, check = simplify(tmp)
+    assert check, f"onnxsim verification failed for {path}"
+    onnx.save(model_simp, path)
+    os.remove(tmp)
+    size_mb = os.path.getsize(path) / 1024 / 1024
+    print(f"  {os.path.basename(path):50s} {size_mb:6.1f} MB")
+
+
+def verify(name, pt_list, onnx_list):
+    for i, (pt, onnx_val) in enumerate(zip(pt_list, onnx_list)):
+        diff = np.abs(pt - onnx_val)
+        sig = max(np.mean(np.abs(pt)), 1e-10)
+        print(f"  [{name}/{i}] max_err={diff.max():.2e}  rel_err={diff.mean()/sig:.2e}  "
+              f"shape={pt.shape}")
+
+
+def main():
+    print("Loading Vocos...")
+    vocoder = LocalVocos()
+    sd = torch.load(f'{REPO_DIR}/resources/vocos-mel-24khz/pytorch_model.bin',
+                    weights_only=True, map_location='cpu')
+    sd = {k: v for k, v in sd.items() if k.startswith(('backbone.', 'head.'))}
+    vocoder.load_state_dict(sd)
+    vocoder.eval()
+
+    backbone = vocoder.backbone
+    head_linear = HeadLinearOnly(vocoder.head).eval()
+
+    B, T = 1, 620
+    dummy_mel = torch.randn(B, 100, T)
+
+    with torch.no_grad():
+        bb_out = backbone(dummy_mel)
+        pt_real, pt_imag = head_linear(bb_out)
+
+    print(f"PT output: real={pt_real.shape}, imag={pt_imag.shape}")
+
+    # --- Export static (B=1, T=620) ---
+    print("\n=== Static models (B=1, T=620) ===")
+    export_onnx(backbone, dummy_mel,
+                f'{OUT_DIR}/vocos_backbone_B1_T620.onnx',
+                ['mel'], ['features'])
+    export_onnx(head_linear, bb_out,
+                f'{OUT_DIR}/vocos_head_linear_B1_T620.onnx',
+                ['features'], ['real', 'imag'])
+    export_onnx(FullModel(backbone, head_linear).eval(), dummy_mel,
+                f'{OUT_DIR}/vocos_full_B1_T620.onnx',
+                ['mel'], ['real', 'imag'])
+
+    # --- Verify with onnxruntime ---
+    print("\n=== Verification ===")
+    import onnxruntime as ort
+
+    for tag, model_file, input_dict, pt_expected in [
+        ('backbone', 'vocos_backbone_B1_T620.onnx',
+         {'mel': dummy_mel.numpy()}, [bb_out.numpy()]),
+        ('head_linear', 'vocos_head_linear_B1_T620.onnx',
+         {'features': bb_out.numpy()}, [pt_real.numpy(), pt_imag.numpy()]),
+        ('full', 'vocos_full_B1_T620.onnx',
+         {'mel': dummy_mel.numpy()}, [pt_real.numpy(), pt_imag.numpy()]),
+    ]:
+        sess = ort.InferenceSession(f'{OUT_DIR}/{model_file}')
+        onnx_out = sess.run(None, input_dict)
+        verify(tag, pt_expected, onnx_out)
+
+    print("\nDone! All exported and verified.")
+    for f in sorted(os.listdir(OUT_DIR)):
+        if 'B1_T620' in f:
+            size = os.path.getsize(f'{OUT_DIR}/{f}') / 1024 / 1024
+            print(f"  {f} ({size:.1f} MB)")
+
+
+if __name__ == '__main__':
+    main()

cpp/scripts/gen_cat_tokens.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Generate cat_tokens binary for C++ ZipVoice inference. Works for any language.
+
+Usage:
+  python3 gen_cat_tokens.py --prompt "prompt text" --text "target text"
+  python3 gen_cat_tokens.py --prompt-file prompt.txt --text-file target.txt
+"""
+import sys, os, argparse
+import numpy as np
+
+REPO_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  # cpp/scripts → repo root
+sys.path.insert(0, REPO_DIR)
+
+from scripts.local_tokenizer import LocalEmiliaTokenizer
+from scripts.text_processing import normalize_punctuation
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--prompt', default='')
+parser.add_argument('--text', default='')
+parser.add_argument('--prompt-file', default='')
+parser.add_argument('--text-file', default='')
+parser.add_argument('--output', default='cat_tokens.bin')
+parser.add_argument('--max-tokens', type=int, default=384)
+args = parser.parse_args()
+
+prompt = args.prompt or (open(args.prompt_file).read().strip() if args.prompt_file else '')
+text = args.text or (open(args.text_file).read().strip() if args.text_file else '')
+
+if not prompt or not text:
+    print("ERROR: provide --prompt/--prompt-file and --text/--text-file")
+    sys.exit(1)
+
+token_file = os.path.join(REPO_DIR, 'resources', 'zipvoice_hf', 'zipvoice', 'tokens.txt')
+tokenizer = LocalEmiliaTokenizer(token_file=token_file)
+
+pids = tokenizer.texts_to_token_ids([normalize_punctuation(prompt)])[0]
+tids = tokenizer.texts_to_token_ids([normalize_punctuation(text)])[0]
+
+cat = pids + tids + [tokenizer.pad_id]
+ct = np.full((args.max_tokens,), tokenizer.pad_id, dtype=np.int32)
+ct[:len(cat)] = np.array(cat, dtype=np.int32)
+ct.tofile(args.output)
+
+print(f'prompt_tokens_len={len(pids)}  text_tokens_len={len(tids)}  saved: {args.output}')

cpp/scripts/gen_pinyin_table.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Generate C++ header with Chinese character → pinyin token mapping."""
+import sys, os
+REPO_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, REPO_DIR)
+
+from pypinyin.pinyin_dict import pinyin_dict
+from pypinyin.contrib.tone_convert import to_initials, to_finals_tone3
+
+TOKEN_FILE = os.path.join(REPO_DIR, 'resources', 'zipvoice_hf', 'zipvoice', 'tokens.txt')
+OUTPUT = os.path.join(REPO_DIR, 'cpp', 'src', 'pinyin_table.hpp')
+
+# Load token2id
+token2id = {}
+with open(TOKEN_FILE) as f:
+    for line in f:
+        if '\t' in line:
+            t, tid = line.rstrip().split('\t')
+            token2id[t] = int(tid)
+
+# Build char → token IDs
+char_entries = []
+for codepoint, pinyins in pinyin_dict.items():
+    ch = chr(codepoint)
+    py = pinyins.split(',')[0]
+    initial = to_initials(py, strict=False)
+    final = to_finals_tone3(py, strict=False, neutral_tone_with_five=True)
+    if not final: continue
+
+    ini_token = initial + '0' if initial else ''
+    tokens = []
+    if ini_token and ini_token in token2id:
+        tokens.append(token2id[ini_token])
+    if final in token2id:
+        tokens.append(token2id[final])
+
+    if tokens:
+        char_entries.append((codepoint, tokens))
+
+# Sort by codepoint for binary search
+char_entries.sort(key=lambda x: x[0])
+
+# Generate C++ header
+with open(OUTPUT, 'w') as f:
+    f.write('''// Auto-generated Chinese character → token ID mapping
+// Source: pypinyin.pinyin_dict, tokens.txt
+// Generated by gen_pinyin_table.py
+
+#pragma once
+#include <cstdint>
+#include <string>
+#include <vector>
+
+struct PinyinEntry {
+    uint32_t codepoint;
+    int16_t  token1;
+    int16_t  token2;  // -1 if only one token
+};
+
+// Sorted by codepoint, use binary search
+static const PinyinEntry PINYIN_TABLE[] = {
+''')
+
+    for codepoint, tokens in char_entries:
+        t1 = tokens[0]
+        t2 = tokens[1] if len(tokens) > 1 else -1
+        f.write(f'    {{0x{codepoint:04X}, {t1}, {t2}}},  // {chr(codepoint)}\n')
+
+    f.write(f'''}};
+
+static const int PINYIN_TABLE_SIZE = {len(char_entries)};
+
+// Lookup tokens for a Chinese character. Returns empty vector if not found.
+inline std::vector<int> pinyin_lookup(uint32_t codepoint) {{
+    // Binary search
+    int lo = 0, hi = PINYIN_TABLE_SIZE - 1;
+    while (lo <= hi) {{
+        int mid = (lo + hi) / 2;
+        if (PINYIN_TABLE[mid].codepoint == codepoint) {{
+            std::vector<int> result;
+            result.push_back(PINYIN_TABLE[mid].token1);
+            if (PINYIN_TABLE[mid].token2 >= 0)
+                result.push_back(PINYIN_TABLE[mid].token2);
+            return result;
+        }}
+        if (PINYIN_TABLE[mid].codepoint < codepoint)
+            lo = mid + 1;
+        else
+            hi = mid - 1;
+    }}
+    return {{}};
+}}
+''')
+
+print(f"Generated {OUTPUT}: {len(char_entries)} entries")

cpp/scripts/generate_vocoder_calib.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Generate vocoder calibration data on dev machine (no axengine needed).
+
+Collects mel features from:
+  1. Real mel output files (output_mel.bin from previous C++ runs)
+  2. Random mel features in the expected value range
+  3. Zero/silence mel features
+Then runs them through ONNX to get intermediate features for head_linear calibration.
+
+Usage:
+  python3 generate_vocoder_calib.py --output-dir ./calib_data_vocoder
+"""
+import sys, os, argparse, json, glob
+from pathlib import Path
+import numpy as np
+import onnxruntime as ort
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPO_DIR = SCRIPT_DIR.parent.parent  # scripts/ → cpp/ → repo root
+ONNX_DIR = SCRIPT_DIR.parent / "vocoder_onnx"  # cpp/vocoder_onnx
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", default=str(ONNX_DIR / "calib_data"))
+    parser.add_argument("--num-samples", type=int, default=16)
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    rng = np.random.RandomState(args.seed)
+
+    T = 620
+    mel_samples = []
+
+    # --- Source 1: Real mel features if available (undo feat_scale to match vocoder input) ---
+    feat_scale = 0.1
+    for pattern in ["output_mel.bin", "output_mel_debug.bin"]:
+        for p in [REPO_DIR / pattern, SCRIPT_DIR / pattern]:
+            if p.exists():
+                mel = np.fromfile(str(p), dtype=np.float32).reshape(-1, 100).T[np.newaxis, :, :] / feat_scale  # [1, 100, frames]
+                gen_frames = min(mel.shape[2], T)
+                padded = np.zeros((1, 100, T), dtype=np.float32)
+                padded[0, :, :gen_frames] = mel[0, :, :gen_frames]
+                mel_samples.append(padded)
+                print(f"Real mel from {p}: shape={mel.shape}")
+
+    # --- Source 2: Random mel in vocoder input range (after /feat_scale) ---
+    # Python: features / 0.1 before vocoder → range ~[-8.6, 4.0]
+    # So calibration mel should be in [feat_scaled] range, divided by feat_scale
+    # to match the actual vocoder input distribution
+    feat_scale = 0.1
+    for i in range(max(0, args.num_samples - len(mel_samples))):
+        length = rng.randint(100, T + 1)
+        # Generate in feat_scaled range, then undo feat_scale
+        mel = (rng.randn(1, 100, T).astype(np.float32) * 0.3 - 0.04) / feat_scale
+        mel[0, :, length:] = 0.0
+        mel_samples.append(mel)
+
+    # --- Source 3: Edge cases (with feat_scale undo) ---
+    mel_samples.append(np.zeros((1, 100, T), dtype=np.float32))
+    mel_samples.append(np.ones((1, 100, T), dtype=np.float32) * 0.5 / feat_scale)
+    mel_samples.append(rng.randn(1, 100, T).astype(np.float32) * 0.1 / feat_scale)
+    mel_samples.append(rng.randn(1, 100, T).astype(np.float32) / feat_scale)
+
+    print(f"\nTotal mel samples: {len(mel_samples)}")
+
+    # --- Run ONNX to get backbone outputs (for head_linear calibration) ---
+    bb_path = ONNX_DIR / "vocos_backbone_B1_T620.onnx"
+    hl_path = ONNX_DIR / "vocos_head_linear_B1_T620.onnx"
+
+    if not bb_path.exists():
+        print(f"ERROR: {bb_path} not found. Run export_vocos_onnx.py first.")
+        return
+
+    sess_bb = ort.InferenceSession(str(bb_path))
+    print(f"Loaded backbone: {bb_path}")
+
+    # --- Save backbone calibration data ---
+    bb_dir = out_dir / "vocos_backbone" / "mel"
+    bb_dir.mkdir(parents=True, exist_ok=True)
+    bb_entries = []
+    backbone_outputs = []
+
+    for i, mel in enumerate(mel_samples):
+        np.save(bb_dir / f"{i:04d}.npy", mel)
+        bb_entries.append({"file": f"mel/{i:04d}.npy", "shape": list(mel.shape)})
+
+        # Run ONNX to get head_linear input
+        feat = sess_bb.run(None, {'mel': mel})[0]
+        backbone_outputs.append(feat)
+
+    print(f"Backbone calibration: {len(bb_entries)} samples")
+
+    # --- Save head_linear calibration data ---
+    hl_dir = out_dir / "vocos_head_linear" / "features"
+    hl_dir.mkdir(parents=True, exist_ok=True)
+    hl_entries = []
+
+    for i, feat in enumerate(backbone_outputs):
+        np.save(hl_dir / f"{i:04d}.npy", feat)
+        hl_entries.append({"file": f"features/{i:04d}.npy", "shape": list(feat.shape)})
+
+    print(f"Head_linear calibration: {len(hl_entries)} samples")
+
+    # --- Verify head_linear ONNX with calibration data ---
+    if hl_path.exists():
+        sess_hl = ort.InferenceSession(str(hl_path))
+        for i in range(min(3, len(backbone_outputs))):
+            r, im = sess_hl.run(None, {'features': backbone_outputs[i]})
+            print(f"  Verify head[{i}]: real range=[{r.min():.3f},{r.max():.3f}], "
+                  f"imag range=[{im.min():.3f},{im.max():.3f}]")
+
+    # --- Manifest ---
+    manifest = {
+        "description": "Vocoder ONNX calibration data",
+        "backbone": {
+            "model": "vocos_backbone_B1_T620.onnx",
+            "input": "mel", "shape": [1, 100, 620], "dtype": "float32",
+            "num_samples": len(bb_entries),
+            "files": bb_entries,
+        },
+        "head_linear": {
+            "model": "vocos_head_linear_B1_T620.onnx",
+            "input": "features", "shape": [1, 620, 512], "dtype": "float32",
+            "num_samples": len(hl_entries),
+            "files": hl_entries,
+        },
+    }
+    with open(out_dir / "calib_manifest.json", "w") as f:
+        json.dump(manifest, f, indent=2, ensure_ascii=False)
+
+    print(f"\nDone! Output: {out_dir}")
+    print(f"  vocos_backbone/mel/   : {len(bb_entries)} .npy files")
+    print(f"  vocos_head_linear/features/: {len(hl_entries)} .npy files")
+
+
+if __name__ == "__main__":
+    main()

cpp/scripts/py_daemon.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+ZipVoice Python daemon: loads tokenizer once, handles C++ requests via stdin/stdout.
+Protocol (tab-separated lines to preserve spaces in text paths):
+  count\t<prompt_file>\t<text_file>
+    -> prints "COUNT <prompt_len> <text_len>"
+  tokenize\t<prompt_file>\t<text_file>\t<max_tokens>\t<output_bin>
+    -> prints "TOKENS <prompt_len> <text_len>"
+  quit
+    -> exits
+"""
+import sys, os
+import numpy as np
+
+REPO_DIR = sys.argv[1]
+sys.path.insert(0, REPO_DIR)
+
+from scripts.local_tokenizer import LocalEmiliaTokenizer
+from scripts.text_processing import normalize_punctuation
+
+TOKEN_FILE = os.path.join(REPO_DIR, "resources", "zipvoice_hf", "zipvoice", "tokens.txt")
+tokenizer = LocalEmiliaTokenizer(token_file=TOKEN_FILE)
+
+print("READY", flush=True)
+
+for line in sys.stdin:
+    line = line.rstrip("\n")
+    if not line:
+        continue
+    parts = line.split("\t")
+    cmd = parts[0]
+
+    if cmd == "count":
+        prompt_file, text_file = parts[1], parts[2]
+        pt = normalize_punctuation(open(prompt_file).read().strip())
+        tt = normalize_punctuation(open(text_file).read().strip())
+        pids = tokenizer.texts_to_token_ids([pt])[0]
+        tids = tokenizer.texts_to_token_ids([tt])[0]
+        print(f"COUNT {len(pids)} {len(tids)}", flush=True)
+
+    elif cmd == "tokenize":
+        prompt_file, text_file, max_tokens, output_bin = parts[1], parts[2], int(parts[3]), parts[4]
+        pt = normalize_punctuation(open(prompt_file).read().strip())
+        tt = normalize_punctuation(open(text_file).read().strip())
+        pids = tokenizer.texts_to_token_ids([pt])[0]
+        tids = tokenizer.texts_to_token_ids([tt])[0]
+        cat = pids + tids + [tokenizer.pad_id]
+        if len(cat) > max_tokens:
+            print(f"ERROR too_many_tokens {len(cat)}>{max_tokens}", flush=True)
+            continue
+        ct = np.full((max_tokens,), tokenizer.pad_id, dtype=np.int32)
+        ct[:len(cat)] = np.array(cat, dtype=np.int32)
+        ct.tofile(output_bin)
+        print(f"TOKENS {len(pids)} {len(tids)}", flush=True)
+
+    elif cmd == "quit":
+        break

cpp/scripts/quantize_vocoder.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# Quantize vocoder ONNX models to axmodel using pulsar2.
+#
+# Prerequisites:
+#   1. export_vocos_onnx.py (generates vocoder_onnx/*.onnx)
+#   2. generate_vocoder_calib.py (generates vocoder_onnx/calib_data/)
+#   3. source <npu_dev_env> (activates pulsar2, e.g. $HOME/npu-codebase/script/npu_dev)
+#
+# Usage:
+#   bash quantize_vocoder.sh
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PARENT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+cd "${PARENT_DIR}"
+
+ONNX_DIR="${PARENT_DIR}/vocoder_onnx"
+CALIB_DIR="${ONNX_DIR}/calib_data"
+BUILD_DIR="${ONNX_DIR}/pulsar2_build"
+AXMODEL_DIR="${ONNX_DIR}/axmodel"
+
+# --- Config ---
+TARGET_HARDWARE="${TARGET_HARDWARE:-AX650}"
+NPU_MODE="${NPU_MODE:-NPU3}"
+CHECK_LEVEL="${CHECK_LEVEL:-0}"
+DEFAULT_DATA_TYPE="${DEFAULT_DATA_TYPE:-U16}"
+CALIBRATION_SIZE="${CALIBRATION_SIZE:--1}"
+
+FULL_MODEL="${ONNX_DIR}/vocos_full_B1_T620.onnx"
+CALIB_DIR_BB="${CALIB_DIR}/vocos_backbone"
+
+if [ ! -f "${FULL_MODEL}" ]; then
+    echo "ERROR: ${FULL_MODEL} not found. Run export_vocos_onnx.py first."
+    exit 1
+fi
+
+if [ ! -d "${CALIB_DIR_BB}" ]; then
+    echo "ERROR: ${CALIB_DIR_BB} not found. Run generate_vocoder_calib.py first."
+    exit 1
+fi
+
+# Activate pulsar2 if not already available
+if ! command -v pulsar2 >/dev/null 2>&1; then
+    echo "Activating pulsar2 environment..."
+    set +u
+    source "${NPU_DEV_ENV:-$HOME/npu-codebase/script/npu_dev}"
+    set -u
+fi
+
+mkdir -p "${BUILD_DIR}" "${AXMODEL_DIR}"
+
+# --- Step 1: Package calibration data as tar.gz ---
+echo "=== Packaging calibration data ==="
+
+# Calibration for full model: mel -> (real, imag)
+# Input tensor is "mel", calibration data in vocos_backbone/mel/
+FULL_CALIB_TAR="${CALIB_DIR}/vocos_full_mel.tar.gz"
+INPUT_DIR="${CALIB_DIR_BB}/mel"
+
+if [ ! -f "${FULL_CALIB_TAR}" ]; then
+    echo "Creating ${FULL_CALIB_TAR}..."
+    cd "${INPUT_DIR}"
+    tar czf "${FULL_CALIB_TAR}" --transform 's|.*/||' *.npy
+    cd "${SCRIPT_DIR}"
+fi
+echo "  ${FULL_CALIB_TAR} ($(du -h "${FULL_CALIB_TAR}" | cut -f1))"
+
+# --- Step 2: Build pulsar2 config ---
+echo ""
+echo "=== Quantizing vocos_full ==="
+
+CONFIG="${BUILD_DIR}/config_vocos_full.json"
+
+cat > "${CONFIG}" << EOF
+{
+    "model_type": "ONNX",
+    "npu_mode": "${NPU_MODE}",
+    "input": "${FULL_MODEL}",
+    "output_name": "vocos_full.axmodel",
+    "output_dir": "${BUILD_DIR}",
+    "target_hardware": "${TARGET_HARDWARE}",
+    "onnx_opt": {"disable_onnx_optimization": false, "enable_onnxsim": true},
+    "quant": {
+        "input_configs": [
+            {"tensor_name": "mel", "calibration_dataset": "${FULL_CALIB_TAR}", "calibration_format": "Numpy", "calibration_size": ${CALIBRATION_SIZE}}
+        ],
+        "layer_configs": [
+            {"op_type": "Pow", "data_type": "U8"},
+            {"start_tensor_names": ["DEFAULT"], "end_tensor_names": ["DEFAULT"], "data_type": "${DEFAULT_DATA_TYPE}"}
+        ],
+        "calibration_method": "MinMax",
+        "enable_smooth_quant": true,
+        "conv_bias_data_type": "FP32",
+        "precision_analysis": true,
+        "precision_analysis_method": "EndToEnd",
+        "disable_auto_refine_scale": true,
+        "transformer_opt_level": 0
+    },
+    "input_processors": [{"tensor_name": "DEFAULT"}],
+    "compiler": {"check": ${CHECK_LEVEL}, "enable_slice_mode": false}
+}
+EOF
+
+echo "Config: ${CONFIG}"
+echo "Input shapes: mel:1x100x620"
+
+# --- Step 3: Run pulsar2 ---
+echo ""
+echo "=== Running pulsar2 build ==="
+pulsar2 build --config "${CONFIG}" --input_shapes "mel:1x100x620" 2>&1 | tee "${BUILD_DIR}/build_vocos_full.log"
+
+# --- Step 4: Copy output ---
+BUILD_OUTPUT="${BUILD_DIR}/vocos_full.axmodel"
+if [ -f "${BUILD_OUTPUT}" ]; then
+    cp "${BUILD_OUTPUT}" "${AXMODEL_DIR}/"
+    echo ""
+    echo "=== Done! ==="
+    ls -lh "${AXMODEL_DIR}/vocos_full.axmodel"
+else
+    echo "ERROR: Build failed, ${BUILD_OUTPUT} not found"
+    exit 1
+fi

cpp/src/EngineWrapper.cpp

@@ -0,0 +1,282 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * EngineWrapper implementation
+ **************************************************************************************************/
+
+#include "EngineWrapper.hpp"
+#include "utils/io.hpp"
+
+#include <cstdlib>
+
+static const char *strAlgoModelType[AX_ENGINE_MODEL_TYPE_BUTT] = {"3.6T", "7.2T", "10.8T"};
+
+// NPU type enum
+typedef enum axNPU_TYPE_E {
+    AX_NPU_DEFAULT = 0,
+    AX_STD_VNPU_1 = (1 << 0),
+    AX_STD_VNPU_2 = (1 << 1),
+    AX_STD_VNPU_3 = (1 << 2),
+    AX_BL_VNPU_1  = (1 << 3),
+    AX_BL_VNPU_2  = (1 << 4)
+} AX_NPU_TYPE_E;
+
+static AX_S32 CheckModelVNpu(const std::string &strModel,
+                              const AX_ENGINE_MODEL_TYPE_T &eModelType,
+                              const AX_S32 &nNpuType, AX_U32 &nNpuSet) {
+    AX_ENGINE_NPU_ATTR_T stNpuAttr;
+    memset(&stNpuAttr, 0x00, sizeof(stNpuAttr));
+
+    auto ret = AX_ENGINE_GetVNPUAttr(&stNpuAttr);
+    if (ret == 0) {
+        if (stNpuAttr.eHardMode == AX_ENGINE_VIRTUAL_NPU_DISABLE) {
+            nNpuSet = 0x01;
+        } else if (stNpuAttr.eHardMode == AX_ENGINE_VIRTUAL_NPU_STD) {
+            if (eModelType == AX_ENGINE_MODEL_TYPE1 || eModelType == AX_ENGINE_MODEL_TYPE2)
+                return -1;
+            if (nNpuType == 0) nNpuSet = 0x02;
+            else {
+                if (nNpuType & AX_STD_VNPU_1) nNpuSet |= 0x01;
+                if (nNpuType & AX_STD_VNPU_2) nNpuSet |= 0x02;
+                if (nNpuType & AX_STD_VNPU_3) nNpuSet |= 0x04;
+            }
+        } else if (stNpuAttr.eHardMode == AX_ENGINE_VIRTUAL_NPU_BIG_LITTLE) {
+            if (eModelType == AX_ENGINE_MODEL_TYPE2) return -1;
+            if (nNpuType == 0) {
+                nNpuSet = (eModelType == AX_ENGINE_MODEL_TYPE1) ? 0x01 : 0x02;
+            } else {
+                if (eModelType == AX_ENGINE_MODEL_TYPE1) {
+                    if (nNpuType & AX_BL_VNPU_2) return -1;
+                    if (nNpuType & AX_BL_VNPU_1) nNpuSet |= 0x01;
+                } else {
+                    if (nNpuType & AX_BL_VNPU_1) nNpuSet |= 0x01;
+                    if (nNpuType & AX_BL_VNPU_2) nNpuSet |= 0x02;
+                }
+            }
+        }
+    }
+    return ret;
+}
+
+EngineWrapper::EngineWrapper()
+    : m_hasInit(false), m_handle(nullptr), m_io_info(nullptr),
+      m_input_num(0), m_output_num(0) {
+    memset(&m_io, 0, sizeof(m_io));
+}
+
+EngineWrapper::~EngineWrapper() {
+    Release();
+}
+
+int EngineWrapper::Init(const char* strModelPath, uint32_t nNpuType) {
+    // 1. Load model
+    AX_BOOL bLoadModelUseCmm = AX_TRUE;
+    AX_CHAR *pModelBufferVirAddr = nullptr;
+    AX_U64 u64ModelBufferPhyAddr = 0;
+    AX_U32 nModelBufferSize = 0;
+
+    if (bLoadModelUseCmm) {
+        if (!utils::read_file(strModelPath, (AX_VOID **)&pModelBufferVirAddr,
+                               u64ModelBufferPhyAddr, nModelBufferSize)) {
+            printf("Read model(%s) fail\n", strModelPath);
+            return -1;
+        }
+    } else {
+        std::vector<char> model_buffer;
+        if (!utils::read_file(strModelPath, model_buffer)) {
+            printf("Read model(%s) fail\n", strModelPath);
+            return -1;
+        }
+        pModelBufferVirAddr = model_buffer.data();
+        nModelBufferSize = model_buffer.size();
+    }
+
+    auto freeModelBuffer = [&]() {
+        if (bLoadModelUseCmm) {
+            if (u64ModelBufferPhyAddr != 0)
+                AX_SYS_MemFree(u64ModelBufferPhyAddr, &pModelBufferVirAddr);
+        }
+    };
+
+    // 1.1 Get Model Type
+    AX_ENGINE_MODEL_TYPE_T eModelType = AX_ENGINE_MODEL_TYPE0;
+    AX_S32 ret = AX_ENGINE_GetModelType(pModelBufferVirAddr, nModelBufferSize, &eModelType);
+    if (0 != ret || eModelType >= AX_ENGINE_MODEL_TYPE_BUTT) {
+        printf("%s AX_ENGINE_GetModelType fail ret=%x\n", strModelPath, ret);
+        freeModelBuffer();
+        return -1;
+    }
+
+    // 1.2 Check VNPU
+    AX_U32 nNpuSet = 0;
+    ret = CheckModelVNpu(strModelPath, eModelType, nNpuType, nNpuSet);
+    if (0 != ret) {
+        printf("CheckModelVNpu fail\n");
+        freeModelBuffer();
+        return -1;
+    }
+
+    // 2. Create handle
+    AX_ENGINE_HANDLE handle = nullptr;
+    ret = AX_ENGINE_CreateHandle(&handle, pModelBufferVirAddr, nModelBufferSize);
+    freeModelBuffer();
+
+    auto deinit_handle = [&handle]() {
+        if (handle) { AX_ENGINE_DestroyHandle(handle); }
+        return -1;
+    };
+
+    if (0 != ret || !handle) {
+        printf("Create model(%s) handle fail\n", strModelPath);
+        return deinit_handle();
+    }
+
+    // 3. Create context
+    ret = AX_ENGINE_CreateContext(handle);
+    if (0 != ret) return deinit_handle();
+
+    // 4. Get IO info
+    m_io_info = nullptr;
+    ret = AX_ENGINE_GetIOInfo(handle, &m_io_info);
+    if (0 != ret) return deinit_handle();
+
+    m_input_num = m_io_info->nInputSize;
+    m_output_num = m_io_info->nOutputSize;
+
+    // Build name-to-index maps
+    m_input_name_to_idx.clear();
+    for (int i = 0; i < m_input_num; ++i) {
+        m_input_name_to_idx[std::string(m_io_info->pInputs[i].pName)] = i;
+    }
+    m_output_name_to_idx.clear();
+    for (int i = 0; i < m_output_num; ++i) {
+        m_output_name_to_idx[std::string(m_io_info->pOutputs[i].pName)] = i;
+    }
+
+    // 5. Prepare IO buffers
+    ret = utils::prepare_io("enc", m_io_info, m_io, utils::IO_BUFFER_STRATEGY_DEFAULT);
+    if (0 != ret) {
+        printf("prepare io failed!\n");
+        utils::free_io(m_io);
+        return deinit_handle();
+    }
+
+    m_handle = handle;
+    m_hasInit = true;
+    return 0;
+}
+
+int EngineWrapper::SetInput(void* pInput, int index) {
+    if (!m_hasInit || index < 0 || index >= m_input_num) return -1;
+    return utils::push_io_input(pInput, index, m_io);
+}
+
+int EngineWrapper::RunSync() {
+    if (!m_hasInit) return -1;
+    auto ret = AX_ENGINE_RunSync(m_handle, &m_io);
+    if (0 != ret) {
+        printf("AX_ENGINE_RunSync failed. ret=0x%x\n", ret);
+    }
+    return ret;
+}
+
+int EngineWrapper::GetOutput(void* pOutput, int index) {
+    if (!m_hasInit || index < 0 || index >= m_output_num) return -1;
+    return utils::push_io_output(pOutput, index, m_io);
+}
+
+int EngineWrapper::SetInputByName(const char* name, void* pInput) {
+    auto it = m_input_name_to_idx.find(std::string(name));
+    if (it == m_input_name_to_idx.end()) {
+        printf("Input '%s' not found in model\n", name);
+        return -1;
+    }
+    return SetInput(pInput, it->second);
+}
+
+int EngineWrapper::GetOutputByName(const char* name, void* pOutput) {
+    auto it = m_output_name_to_idx.find(std::string(name));
+    if (it == m_output_name_to_idx.end()) {
+        printf("Output '%s' not found in model\n", name);
+        return -1;
+    }
+    return GetOutput(pOutput, it->second);
+}
+
+int EngineWrapper::GetInputSize(int index) {
+    if (index < 0 || index >= m_input_num) return -1;
+    return m_io.pInputs[index].nSize;
+}
+
+int EngineWrapper::GetOutputSize(int index) {
+    if (index < 0 || index >= m_output_num) return -1;
+    return m_io.pOutputs[index].nSize;
+}
+
+int EngineWrapper::GetInputSizeByName(const char* name) {
+    int idx = GetInputIndex(name);
+    if (idx < 0) return -1;
+    return GetInputSize(idx);
+}
+
+int EngineWrapper::GetOutputSizeByName(const char* name) {
+    int idx = GetOutputIndex(name);
+    if (idx < 0) return -1;
+    return GetOutputSize(idx);
+}
+
+int EngineWrapper::GetInputIndex(const char* name) {
+    auto it = m_input_name_to_idx.find(std::string(name));
+    return (it != m_input_name_to_idx.end()) ? it->second : -1;
+}
+
+int EngineWrapper::GetOutputIndex(const char* name) {
+    auto it = m_output_name_to_idx.find(std::string(name));
+    return (it != m_output_name_to_idx.end()) ? it->second : -1;
+}
+
+const char* EngineWrapper::GetInputName(int index) const {
+    if (index < 0 || index >= m_input_num) return nullptr;
+    return m_io_info->pInputs[index].pName;
+}
+
+const char* EngineWrapper::GetOutputName(int index) const {
+    if (index < 0 || index >= m_output_num) return nullptr;
+    return m_io_info->pOutputs[index].pName;
+}
+
+static const char* dtype_str(AX_ENGINE_DATA_TYPE_T t) {
+    switch (t) {
+        case AX_ENGINE_DT_FLOAT32: return "float32";
+        case AX_ENGINE_DT_FLOAT64: return "float64";
+        case AX_ENGINE_DT_SINT8:   return "sint8";
+        case AX_ENGINE_DT_UINT8:   return "uint8";
+        case AX_ENGINE_DT_SINT16:  return "sint16";
+        case AX_ENGINE_DT_UINT16:  return "uint16";
+        case AX_ENGINE_DT_SINT32:  return "sint32";
+        case AX_ENGINE_DT_UINT32:  return "uint32";
+        default: return "unknown";
+    }
+}
+
+const char* EngineWrapper::GetInputDtypeStr(int index) const {
+    if (index < 0 || index >= m_input_num) return "?";
+    return dtype_str(m_io_info->pInputs[index].eDataType);
+}
+
+const char* EngineWrapper::GetOutputDtypeStr(int index) const {
+    if (index < 0 || index >= m_output_num) return "?";
+    return dtype_str(m_io_info->pOutputs[index].eDataType);
+}
+
+int EngineWrapper::Release() {
+    if (m_handle) {
+        utils::free_io(m_io);
+        AX_ENGINE_DestroyHandle(m_handle);
+        m_handle = nullptr;
+    }
+    m_hasInit = false;
+    m_input_name_to_idx.clear();
+    m_output_name_to_idx.clear();
+    return 0;
+}

cpp/src/EngineWrapper.hpp

@@ -0,0 +1,62 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * EngineWrapper: wraps AX_ENGINE API for loading and running .axmodel files.
+ * Supports both index-based and name-based I/O access.
+ *
+ * Adapted from melotts.axera-main
+ **************************************************************************************************/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <cstring>
+#include <cstdint>
+
+#include "ax_engine_api.h"
+
+class EngineWrapper {
+public:
+    EngineWrapper();
+    ~EngineWrapper();
+
+    int Init(const char* strModelPath, uint32_t nNpuType = 0);
+
+    // Index-based I/O (simple interface)
+    int SetInput(void* pInput, int index);
+    int RunSync();
+    int GetOutput(void* pOutput, int index);
+
+    // Name-based I/O (for multi-input/output models)
+    int SetInputByName(const char* name, void* pInput);
+    int GetOutputByName(const char* name, void* pOutput);
+
+    int GetInputSize(int index);
+    int GetOutputSize(int index);
+    int GetInputSizeByName(const char* name);
+    int GetOutputSizeByName(const char* name);
+
+    int GetInputIndex(const char* name);
+    int GetOutputIndex(const char* name);
+    int GetInputCount() const { return m_input_num; }
+    int GetOutputCount() const { return m_output_num; }
+    const char* GetInputName(int index) const;
+    const char* GetOutputName(int index) const;
+    const char* GetInputDtypeStr(int index) const;
+    const char* GetOutputDtypeStr(int index) const;
+
+    bool HasInit() const { return m_hasInit; }
+    int Release();
+
+private:
+    bool m_hasInit;
+    AX_ENGINE_HANDLE m_handle;
+    AX_ENGINE_IO_INFO_T *m_io_info;
+    AX_ENGINE_IO_T m_io;
+    int m_input_num, m_output_num;
+
+    std::unordered_map<std::string, int> m_input_name_to_idx;
+    std::unordered_map<std::string, int> m_output_name_to_idx;
+};

cpp/src/cmdline.hpp

@@ -0,0 +1,732 @@
+/*
+  Copyright (c) 2009, Hideyuki Tanaka
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  * 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.
+  * Neither the name of the <organization> nor the
+  names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
+  EXPRESS 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 <copyright holder> 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.
+*/
+
+#pragma once
+
+#include <cxxabi.h>
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+namespace cmdline {
+
+namespace detail {
+
+template <typename Target, typename Source, bool Same>
+class lexical_cast_t {
+ public:
+  static Target cast(const Source &arg) {
+    Target ret;
+    std::stringstream ss;
+    if (!(ss << arg && ss >> ret && ss.eof())) throw std::bad_cast();
+
+    return ret;
+  }
+};
+
+template <typename Target, typename Source>
+class lexical_cast_t<Target, Source, true> {
+ public:
+  static Target cast(const Source &arg) { return arg; }
+};
+
+template <typename Source>
+class lexical_cast_t<std::string, Source, false> {
+ public:
+  static std::string cast(const Source &arg) {
+    std::ostringstream ss;
+    ss << arg;
+    return ss.str();
+  }
+};
+
+template <typename Target>
+class lexical_cast_t<Target, std::string, false> {
+ public:
+  static Target cast(const std::string &arg) {
+    Target ret;
+    std::istringstream ss(arg);
+    if (!(ss >> ret && ss.eof())) throw std::bad_cast();
+    return ret;
+  }
+};
+
+template <typename T1, typename T2>
+struct is_same {
+  static const bool value = false;
+};
+
+template <typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template <typename Target, typename Source>
+Target lexical_cast(const Source &arg) {
+  return lexical_cast_t<Target, Source,
+                        detail::is_same<Target, Source>::value>::cast(arg);
+}
+
+static inline std::string demangle(const std::string &name) {
+  int status = 0;
+  char *p = abi::__cxa_demangle(name.c_str(), 0, 0, &status);
+  std::string ret(p);
+  free(p);
+  return ret;
+}
+
+template <class T>
+std::string readable_typename() {
+  return demangle(typeid(T).name());
+}
+
+template <class T>
+std::string default_value(T def) {
+  return detail::lexical_cast<std::string>(def);
+}
+
+template <>
+inline std::string readable_typename<std::string>() {
+  return "string";
+}
+
+}  // namespace detail
+
+//-----
+
+class cmdline_error : public std::exception {
+ public:
+  cmdline_error(const std::string &msg) : msg(msg) {}
+  ~cmdline_error() throw() {}
+  const char *what() const throw() { return msg.c_str(); }
+
+ private:
+  std::string msg;
+};
+
+template <class T>
+struct default_reader {
+  T operator()(const std::string &str) { return detail::lexical_cast<T>(str); }
+};
+
+template <class T>
+struct range_reader {
+  range_reader(const T &low, const T &high) : low(low), high(high) {}
+  T operator()(const std::string &s) const {
+    T ret = default_reader<T>()(s);
+    if (!(ret >= low && ret <= high))
+      throw cmdline::cmdline_error("range_error");
+    return ret;
+  }
+
+ private:
+  T low, high;
+};
+
+template <class T>
+range_reader<T> range(const T &low, const T &high) {
+  return range_reader<T>(low, high);
+}
+
+template <class T>
+struct oneof_reader {
+  T operator()(const std::string &s) {
+    T ret = default_reader<T>()(s);
+    if (std::find(alt.begin(), alt.end(), ret) == alt.end())
+      throw cmdline_error("");
+    return ret;
+  }
+  void add(const T &v) { alt.push_back(v); }
+
+ private:
+  std::vector<T> alt;
+};
+
+template <class T>
+oneof_reader<T> oneof(T a1) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  ret.add(a8);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  ret.add(a8);
+  ret.add(a9);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9,
+                      T a10) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  ret.add(a8);
+  ret.add(a9);
+  ret.add(a10);
+  return ret;
+}
+
+//-----
+
+class parser {
+ public:
+  parser() {}
+  ~parser() {
+    for (std::map<std::string, option_base *>::iterator p = options.begin();
+         p != options.end(); p++)
+      delete p->second;
+  }
+
+  void add(const std::string &name, char short_name = 0,
+           const std::string &desc = "") {
+    if (options.count(name))
+      throw cmdline_error("multiple definition: " + name);
+    options[name] = new option_without_value(name, short_name, desc);
+    ordered.push_back(options[name]);
+  }
+
+  template <class T>
+  void add(const std::string &name, char short_name = 0,
+           const std::string &desc = "", bool need = true, const T def = T()) {
+    add(name, short_name, desc, need, def, default_reader<T>());
+  }
+
+  template <class T, class F>
+  void add(const std::string &name, char short_name = 0,
+           const std::string &desc = "", bool need = true, const T def = T(),
+           F reader = F()) {
+    if (options.count(name))
+      throw cmdline_error("multiple definition: " + name);
+    options[name] = new option_with_value_with_reader<T, F>(
+        name, short_name, need, def, desc, reader);
+    ordered.push_back(options[name]);
+  }
+
+  void footer(const std::string &f) { ftr = f; }
+
+  void set_program_name(const std::string &name) { prog_name = name; }
+
+  bool exist(const std::string &name) const {
+    if (options.count(name) == 0)
+      throw cmdline_error("there is no flag: --" + name);
+    return options.find(name)->second->has_set();
+  }
+
+  template <class T>
+  const T &get(const std::string &name) const {
+    if (options.count(name) == 0)
+      throw cmdline_error("there is no flag: --" + name);
+    const option_with_value<T> *p =
+        dynamic_cast<const option_with_value<T> *>(options.find(name)->second);
+    if (p == NULL) throw cmdline_error("type mismatch flag '" + name + "'");
+    return p->get();
+  }
+
+  const std::vector<std::string> &rest() const { return others; }
+
+  bool parse(const std::string &arg) {
+    std::vector<std::string> args;
+
+    std::string buf;
+    bool in_quote = false;
+    for (std::string::size_type i = 0; i < arg.length(); i++) {
+      if (arg[i] == '\"') {
+        in_quote = !in_quote;
+        continue;
+      }
+
+      if (arg[i] == ' ' && !in_quote) {
+        args.push_back(buf);
+        buf = "";
+        continue;
+      }
+
+      if (arg[i] == '\\') {
+        i++;
+        if (i >= arg.length()) {
+          errors.push_back("unexpected occurrence of '\\' at end of string");
+          return false;
+        }
+      }
+
+      buf += arg[i];
+    }
+
+    if (in_quote) {
+      errors.push_back("quote is not closed");
+      return false;
+    }
+
+    if (buf.length() > 0) args.push_back(buf);
+
+    for (size_t i = 0; i < args.size(); i++)
+      std::cout << "\"" << args[i] << "\"" << std::endl;
+
+    return parse(args);
+  }
+
+  bool parse(const std::vector<std::string> &args) {
+    int argc = static_cast<int>(args.size());
+    std::vector<const char *> argv(argc);
+
+    for (int i = 0; i < argc; i++) argv[i] = args[i].c_str();
+
+    return parse(argc, &argv[0]);
+  }
+
+  bool parse(int argc, const char *const argv[]) {
+    errors.clear();
+    others.clear();
+
+    if (argc < 1) {
+      errors.push_back("argument number must be longer than 0");
+      return false;
+    }
+    if (prog_name == "") prog_name = argv[0];
+
+    std::map<char, std::string> lookup;
+    for (std::map<std::string, option_base *>::iterator p = options.begin();
+         p != options.end(); p++) {
+      if (p->first.length() == 0) continue;
+      char initial = p->second->short_name();
+      if (initial) {
+        if (lookup.count(initial) > 0) {
+          lookup[initial] = "";
+          errors.push_back(std::string("short option '") + initial +
+                           "' is ambiguous");
+          return false;
+        } else
+          lookup[initial] = p->first;
+      }
+    }
+
+    for (int i = 1; i < argc; i++) {
+      if (strncmp(argv[i], "--", 2) == 0) {
+        const char *p = strchr(argv[i] + 2, '=');
+        if (p) {
+          std::string name(argv[i] + 2, p);
+          std::string val(p + 1);
+          set_option(name, val);
+        } else {
+          std::string name(argv[i] + 2);
+          if (options.count(name) == 0) {
+            errors.push_back("undefined option: --" + name);
+            continue;
+          }
+          if (options[name]->has_value()) {
+            if (i + 1 >= argc) {
+              errors.push_back("option needs value: --" + name);
+              continue;
+            } else {
+              i++;
+              set_option(name, argv[i]);
+            }
+          } else {
+            set_option(name);
+          }
+        }
+      } else if (strncmp(argv[i], "-", 1) == 0) {
+        if (!argv[i][1]) continue;
+        char last = argv[i][1];
+        for (int j = 2; argv[i][j]; j++) {
+          last = argv[i][j];
+          if (lookup.count(argv[i][j - 1]) == 0) {
+            errors.push_back(std::string("undefined short option: -") +
+                             argv[i][j - 1]);
+            continue;
+          }
+          if (lookup[argv[i][j - 1]] == "") {
+            errors.push_back(std::string("ambiguous short option: -") +
+                             argv[i][j - 1]);
+            continue;
+          }
+          set_option(lookup[argv[i][j - 1]]);
+        }
+
+        if (lookup.count(last) == 0) {
+          errors.push_back(std::string("undefined short option: -") + last);
+          continue;
+        }
+        if (lookup[last] == "") {
+          errors.push_back(std::string("ambiguous short option: -") + last);
+          continue;
+        }
+
+        if (i + 1 < argc && options[lookup[last]]->has_value()) {
+          set_option(lookup[last], argv[i + 1]);
+          i++;
+        } else {
+          set_option(lookup[last]);
+        }
+      } else {
+        others.push_back(argv[i]);
+      }
+    }
+
+    for (std::map<std::string, option_base *>::iterator p = options.begin();
+         p != options.end(); p++)
+      if (!p->second->valid())
+        errors.push_back("need option: --" + std::string(p->first));
+
+    return errors.size() == 0;
+  }
+
+  void parse_check(const std::string &arg) {
+    if (!options.count("help")) add("help", '?', "print this message");
+    check(0, parse(arg));
+  }
+
+  void parse_check(const std::vector<std::string> &args) {
+    if (!options.count("help")) add("help", '?', "print this message");
+    check(args.size(), parse(args));
+  }
+
+  void parse_check(int argc, char *argv[]) {
+    if (!options.count("help")) add("help", '?', "print this message");
+    check(argc, parse(argc, argv));
+  }
+
+  std::string error() const { return errors.size() > 0 ? errors[0] : ""; }
+
+  std::string error_full() const {
+    std::ostringstream oss;
+    for (size_t i = 0; i < errors.size(); i++) oss << errors[i] << std::endl;
+    return oss.str();
+  }
+
+  std::string usage() const {
+    std::ostringstream oss;
+    oss << "usage: " << prog_name << " ";
+    for (size_t i = 0; i < ordered.size(); i++) {
+      if (ordered[i]->must()) oss << ordered[i]->short_description() << " ";
+    }
+
+    oss << "[options] ... " << ftr << std::endl;
+    oss << "options:" << std::endl;
+
+    size_t max_width = 0;
+    for (size_t i = 0; i < ordered.size(); i++) {
+      max_width = std::max(max_width, ordered[i]->name().length());
+    }
+    for (size_t i = 0; i < ordered.size(); i++) {
+      if (ordered[i]->short_name()) {
+        oss << "  -" << ordered[i]->short_name() << ", ";
+      } else {
+        oss << "      ";
+      }
+
+      oss << "--" << ordered[i]->name();
+      for (size_t j = ordered[i]->name().length(); j < max_width + 4; j++)
+        oss << ' ';
+      oss << ordered[i]->description() << std::endl;
+    }
+    return oss.str();
+  }
+
+ private:
+  void check(int argc, bool ok) {
+    if ((argc == 1 && !ok) || exist("help")) {
+      std::cerr << usage();
+      exit(0);
+    }
+
+    if (!ok) {
+      std::cerr << error() << std::endl << usage();
+      exit(1);
+    }
+  }
+
+  void set_option(const std::string &name) {
+    if (options.count(name) == 0) {
+      errors.push_back("undefined option: --" + name);
+      return;
+    }
+    if (!options[name]->set()) {
+      errors.push_back("option needs value: --" + name);
+      return;
+    }
+  }
+
+  void set_option(const std::string &name, const std::string &value) {
+    if (options.count(name) == 0) {
+      errors.push_back("undefined option: --" + name);
+      return;
+    }
+    if (!options[name]->set(value)) {
+      errors.push_back("option value is invalid: --" + name + "=" + value);
+      return;
+    }
+  }
+
+  class option_base {
+   public:
+    virtual ~option_base() {}
+
+    virtual bool has_value() const = 0;
+    virtual bool set() = 0;
+    virtual bool set(const std::string &value) = 0;
+    virtual bool has_set() const = 0;
+    virtual bool valid() const = 0;
+    virtual bool must() const = 0;
+
+    virtual const std::string &name() const = 0;
+    virtual char short_name() const = 0;
+    virtual const std::string &description() const = 0;
+    virtual std::string short_description() const = 0;
+  };
+
+  class option_without_value : public option_base {
+   public:
+    option_without_value(const std::string &name, char short_name,
+                         const std::string &desc)
+        : nam(name), snam(short_name), desc(desc), has(false) {}
+    ~option_without_value() {}
+
+    bool has_value() const { return false; }
+
+    bool set() {
+      has = true;
+      return true;
+    }
+
+    bool set(const std::string &) { return false; }
+
+    bool has_set() const { return has; }
+
+    bool valid() const { return true; }
+
+    bool must() const { return false; }
+
+    const std::string &name() const { return nam; }
+
+    char short_name() const { return snam; }
+
+    const std::string &description() const { return desc; }
+
+    std::string short_description() const { return "--" + nam; }
+
+   private:
+    std::string nam;
+    char snam;
+    std::string desc;
+    bool has;
+  };
+
+  template <class T>
+  class option_with_value : public option_base {
+   public:
+    option_with_value(const std::string &name, char short_name, bool need,
+                      const T &def, const std::string &desc)
+        : nam(name),
+          snam(short_name),
+          need(need),
+          has(false),
+          def(def),
+          actual(def) {
+      this->desc = full_description(desc);
+    }
+    ~option_with_value() {}
+
+    const T &get() const { return actual; }
+
+    bool has_value() const { return true; }
+
+    bool set() { return false; }
+
+    bool set(const std::string &value) {
+      try {
+        actual = read(value);
+        has = true;
+      } catch (const std::exception &e) {
+        return false;
+      }
+      return true;
+    }
+
+    bool has_set() const { return has; }
+
+    bool valid() const {
+      if (need && !has) return false;
+      return true;
+    }
+
+    bool must() const { return need; }
+
+    const std::string &name() const { return nam; }
+
+    char short_name() const { return snam; }
+
+    const std::string &description() const { return desc; }
+
+    std::string short_description() const {
+      return "--" + nam + "=" + detail::readable_typename<T>();
+    }
+
+   protected:
+    std::string full_description(const std::string &desc) {
+      return desc + " (" + detail::readable_typename<T>() +
+             (need ? "" : " [=" + detail::default_value<T>(def) + "]") + ")";
+    }
+
+    virtual T read(const std::string &s) = 0;
+
+    std::string nam;
+    char snam;
+    bool need;
+    std::string desc;
+
+    bool has;
+    T def;
+    T actual;
+  };
+
+  template <class T, class F>
+  class option_with_value_with_reader : public option_with_value<T> {
+   public:
+    option_with_value_with_reader(const std::string &name, char short_name,
+                                  bool need, const T def,
+                                  const std::string &desc, F reader)
+        : option_with_value<T>(name, short_name, need, def, desc),
+          reader(reader) {}
+
+   private:
+    T read(const std::string &s) { return reader(s); }
+
+    F reader;
+  };
+
+  std::map<std::string, option_base *> options;
+  std::vector<option_base *> ordered;
+  std::string ftr;
+
+  std::string prog_name;
+  std::vector<std::string> others;
+
+  std::vector<std::string> errors;
+};
+
+}  // namespace cmdline

cpp/src/fbank.cpp

@@ -0,0 +1,219 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * FBANK implementation with simple DFT-based STFT.
+ * For production, use FFTW or an NPU-accelerated implementation.
+ **************************************************************************************************/
+
+#include "fbank.hpp"
+
+#include <algorithm>
+#include <cstring>
+#include <cstdio>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+static float hz_to_mel(float freq) {
+    return 2595.0f * std::log10(1.0f + freq / 700.0f);
+}
+
+static float mel_to_hz(float mel) {
+    return 700.0f * (std::pow(10.0f, mel / 2595.0f) - 1.0f);
+}
+
+MelFilterBank::MelFilterBank() : m_n_freqs(0) {}
+
+int MelFilterBank::Init(const Config& config) {
+    m_config = config;
+    m_n_freqs = config.n_fft / 2 + 1;
+
+    CreateWindow();
+    CreateMelFilterbank();
+
+    printf("FBANK init: n_mels=%d, n_fft=%d, hop=%d, sr=%d\n",
+           config.n_mels, config.n_fft, config.hop_length, config.sampling_rate);
+    return 0;
+}
+
+void MelFilterBank::CreateWindow() {
+    m_window.resize(m_config.n_fft);
+    for (int i = 0; i < m_config.n_fft; ++i) {
+        m_window[i] = 0.5f * (1.0f - std::cos(2.0f * M_PI * i / (m_config.n_fft - 1)));
+    }
+}
+
+void MelFilterBank::CreateMelFilterbank() {
+    int n_freqs = m_n_freqs;
+    int n_mels = m_config.n_mels;
+
+    // Frequency points for each FFT bin
+    std::vector<float> all_freqs(n_freqs);
+    for (int i = 0; i < n_freqs; ++i) {
+        all_freqs[i] = i * m_config.sampling_rate / (2.0f * (n_freqs - 1));
+    }
+
+    // Mel points
+    float m_min = hz_to_mel(0.0f);
+    float m_max = hz_to_mel(m_config.sampling_rate / 2.0f);
+    std::vector<float> m_pts(n_mels + 2);
+    for (int i = 0; i < n_mels + 2; ++i) {
+        m_pts[i] = m_min + (m_max - m_min) * i / (n_mels + 1);
+    }
+
+    // Convert to Hz
+    std::vector<float> f_pts(n_mels + 2);
+    for (int i = 0; i < n_mels + 2; ++i) {
+        f_pts[i] = mel_to_hz(m_pts[i]);
+    }
+
+    // Build filterbank matrix [n_freqs, n_mels]
+    m_mel_basis.resize(n_freqs * n_mels, 0.0f);
+
+    for (int m = 0; m < n_mels; ++m) {
+        for (int k = 0; k < n_freqs; ++k) {
+            float freq = all_freqs[k];
+            float left = f_pts[m];
+            float center = f_pts[m + 1];
+            float right = f_pts[m + 2];
+
+            float val = 0.0f;
+            if (freq >= left && freq <= center) {
+                val = (freq - left) / (center - left);
+            } else if (freq >= center && freq <= right) {
+                val = (right - freq) / (right - center);
+            }
+            m_mel_basis[k * n_mels + m] = val;
+        }
+    }
+}
+
+int MelFilterBank::ComputeNumFrames(int num_samples, int hop_length) {
+    return (num_samples + hop_length / 2) / hop_length;
+}
+
+// Radix-2 FFT (in-place, complex)
+static void fft(std::vector<float>& real, std::vector<float>& imag, bool inverse = false) {
+    int n = (int)real.size();
+    // Bit-reversal permutation
+    for (int i = 1, j = 0; i < n; ++i) {
+        int bit = n >> 1;
+        for (; j & bit; bit >>= 1) j ^= bit;
+        j ^= bit;
+        if (i < j) {
+            std::swap(real[i], real[j]);
+            std::swap(imag[i], imag[j]);
+        }
+    }
+    // Butterfly
+    for (int len = 2; len <= n; len <<= 1) {
+        float angle = 2.0f * M_PI / len * (inverse ? 1.0f : -1.0f);
+        float w_real = std::cos(angle);
+        float w_imag = std::sin(angle);
+        for (int i = 0; i < n; i += len) {
+            float cur_real = 1.0f, cur_imag = 0.0f;
+            for (int j = 0; j < len / 2; ++j) {
+                int a = i + j;
+                int b = i + j + len / 2;
+                float t_real = cur_real * real[b] - cur_imag * imag[b];
+                float t_imag = cur_real * imag[b] + cur_imag * real[b];
+                real[b] = real[a] - t_real;
+                imag[b] = imag[a] - t_imag;
+                real[a] += t_real;
+                imag[a] += t_imag;
+                float next_real = cur_real * w_real - cur_imag * w_imag;
+                cur_imag = cur_real * w_imag + cur_imag * w_real;
+                cur_real = next_real;
+            }
+        }
+    }
+    if (inverse) {
+        for (int i = 0; i < n; ++i) {
+            real[i] /= n;
+            imag[i] /= n;
+        }
+    }
+}
+
+void MelFilterBank::ComputeSTFT(const std::vector<float>& samples,
+                                 std::vector<float>& spec_real,
+                                 std::vector<float>& spec_imag,
+                                 int& num_frames) {
+    int n_fft = m_config.n_fft;
+    int hop = m_config.hop_length;
+    int num_samples = static_cast<int>(samples.size());
+
+    num_frames = ComputeNumFrames(num_samples, hop);
+    int n_freqs = n_fft / 2 + 1;
+
+    spec_real.assign(num_frames * n_freqs, 0.0f);
+    spec_imag.assign(num_frames * n_freqs, 0.0f);
+
+    // Pad signal (center padding, matching Python torch.stft center=True)
+    int pad_amount = n_fft / 2;
+    std::vector<float> padded(pad_amount + num_samples + pad_amount, 0.0f);
+    std::copy(samples.begin(), samples.end(), padded.begin() + pad_amount);
+
+    // FFT workspace
+    std::vector<float> fft_real(n_fft), fft_imag(n_fft);
+
+    for (int frame = 0; frame < num_frames; ++frame) {
+        int start = frame * hop;
+        // Apply window and copy to FFT buffer
+        for (int n = 0; n < n_fft; ++n) {
+            fft_real[n] = padded[start + n] * m_window[n];
+            fft_imag[n] = 0.0f;
+        }
+        // Forward FFT
+        fft(fft_real, fft_imag, false);
+        // Extract first n_freqs bins
+        for (int k = 0; k < n_freqs; ++k) {
+            spec_real[frame * n_freqs + k] = fft_real[k];
+            spec_imag[frame * n_freqs + k] = fft_imag[k];
+        }
+    }
+}
+
+std::vector<float> MelFilterBank::Extract(const std::vector<float>& samples, int sample_rate) {
+    if (sample_rate != m_config.sampling_rate) {
+        printf("WARNING: sample_rate mismatch: expected %d, got %d\n",
+               m_config.sampling_rate, sample_rate);
+    }
+
+    int num_frames;
+    std::vector<float> spec_real, spec_imag;
+    ComputeSTFT(samples, spec_real, spec_imag, num_frames);
+
+    int n_freqs = m_n_freqs;
+    int n_mels = m_config.n_mels;
+
+    // Compute magnitude spectrogram [num_frames, n_freqs]
+    std::vector<float> spec_mag(num_frames * n_freqs);
+    for (int i = 0; i < num_frames * n_freqs; ++i) {
+        spec_mag[i] = std::sqrt(spec_real[i] * spec_real[i] + spec_imag[i] * spec_imag[i]);
+    }
+
+    // Apply mel filterbank: mel[frame, m] = sum_freq(spec[frame, freq] * basis[freq, m])
+    std::vector<float> mel(num_frames * n_mels, 0.0f);
+    for (int f = 0; f < num_frames; ++f) {
+        for (int m = 0; m < n_mels; ++m) {
+            float sum = 0.0f;
+            for (int k = 0; k < n_freqs; ++k) {
+                sum += spec_mag[f * n_freqs + k] * m_mel_basis[k * n_mels + m];
+            }
+            mel[f * n_mels + m] = std::log(std::max(sum, 1e-7f));
+        }
+    }
+
+    // Expected num_frames
+    int expected_frames = ComputeNumFrames(static_cast<int>(samples.size()), m_config.hop_length);
+    if (num_frames > expected_frames) {
+        // Truncate
+        std::vector<float> truncated(expected_frames * n_mels);
+        std::copy(mel.begin(), mel.begin() + expected_frames * n_mels, truncated.begin());
+        return truncated;
+    }
+
+    return mel;
+}

cpp/src/fbank.hpp

@@ -0,0 +1,65 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * FBANK: Mel filterbank feature extraction for prompt audio.
+ *
+ * Extracts log-mel spectrogram features from audio waveform, matching the
+ * Python LocalVocosFbank behavior.
+ **************************************************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include <cstdint>
+
+class MelFilterBank {
+public:
+    struct Config {
+        int sampling_rate;
+        int n_mels;
+        int n_fft;
+        int hop_length;
+
+        Config() : sampling_rate(24000), n_mels(100), n_fft(1024), hop_length(256) {}
+    };
+
+    MelFilterBank();
+
+    /**
+     * Initialize the filterbank with given config.
+     */
+    int Init(const Config& config = Config());
+
+    /**
+     * Extract log-mel features from float32 audio samples [num_samples].
+     * Returns features of shape [num_frames, n_mels].
+     */
+    std::vector<float> Extract(const std::vector<float>& samples, int sample_rate);
+
+    /**
+     * Get the number of frames for given number of samples.
+     */
+    static int ComputeNumFrames(int num_samples, int hop_length);
+
+    const Config& GetConfig() const { return m_config; }
+
+private:
+    Config m_config;
+
+    // Mel filterbank matrix [n_freqs, n_mels]
+    std::vector<float> m_mel_basis;
+    int m_n_freqs;
+
+    // Hann window
+    std::vector<float> m_window;
+
+    void CreateMelFilterbank();
+    void CreateWindow();
+
+    // Simple STFT
+    void ComputeSTFT(const std::vector<float>& samples,
+                     std::vector<float>& spec_real,
+                     std::vector<float>& spec_imag,
+                     int& num_frames);
+};

cpp/src/tokenizer.cpp

@@ -0,0 +1,306 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Tokenizer implementation. Uses pinyin_table.hpp (auto-generated from pypinyin.pinyin_dict)
+ * for Chinese character → pinyin token mapping, matching Python LocalEmiliaTokenizer output.
+ **************************************************************************************************/
+
+#include "tokenizer.hpp"
+#include "src/pinyin_table.hpp"
+
+#include <fstream>
+#include <sstream>
+#include <regex>
+#include <cctype>
+#include <algorithm>
+
+Tokenizer::Tokenizer() : m_pad_id(0), m_loaded(false) {}
+
+int Tokenizer::Load(const std::string& token_file) {
+    std::ifstream file(token_file);
+    if (!file.is_open()) {
+        printf("Failed to open token file: %s\n", token_file.c_str());
+        return -1;
+    }
+
+    m_token2id.clear();
+    std::string line;
+    while (std::getline(file, line)) {
+        if (line.empty()) continue;
+        // Format: token\tid
+        size_t tab_pos = line.rfind('\t');
+        if (tab_pos == std::string::npos) continue;
+
+        std::string token = line.substr(0, tab_pos);
+        int id = std::stoi(line.substr(tab_pos + 1));
+        m_token2id[token] = id;
+    }
+    file.close();
+
+    // Build reverse mapping
+    int max_id = 0;
+    for (auto& kv : m_token2id) {
+        if (kv.second > max_id) max_id = kv.second;
+    }
+    m_id2token.resize(max_id + 1);
+    for (auto& kv : m_token2id) {
+        m_id2token[kv.second] = kv.first;
+    }
+
+    auto it = m_token2id.find("_");
+    if (it != m_token2id.end()) {
+        m_pad_id = it->second;
+    } else {
+        m_pad_id = 0;
+        printf("WARNING: pad token '_' not found in token file, using 0 as pad_id\n");
+    }
+
+    m_loaded = true;
+    printf("Loaded %zu tokens from %s, pad_id=%d\n", m_token2id.size(), token_file.c_str(), m_pad_id);
+    return 0;
+}
+
+int Tokenizer::TokenToId(const std::string& token) const {
+    auto it = m_token2id.find(token);
+    return (it != m_token2id.end()) ? it->second : m_pad_id;
+}
+
+bool Tokenizer::IsChinese(char c) {
+    return (c >= 0x4E00 && c <= 0x9FFF);
+}
+
+bool Tokenizer::IsAlphabet(char c) {
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+}
+
+std::string Tokenizer::MapPunctuation(const std::string& text) {
+    // Map full-width Chinese punctuation to ASCII equivalents.
+    // UTF-8 code points:
+    //   \xEF\xBC\x8C = U+FF0C (，)  \xEF\xBC\x9A = U+FF1A (：)
+    //   \xE3\x80\x82 = U+3002 (。)  \xE3\x80\x81 = U+3001 (、)
+    //   \xEF\xBC\x81 = U+FF01 (！)  \xE2\x80\x9C = U+201C (")
+    //   \xEF\xBC\x9F = U+FF1F (？)  \xE2\x80\x9D = U+201D (")
+    //   \xEF\xBC\x9B = U+FF1B (；)  \xE2\x80\x98 = U+2018 (')
+    //   \xE2\x80\xA6 = U+2026 (…)   \xE2\x80\x99 = U+2019 (')
+    //   \xE2\x8B\xAF = U+22EF (⋯)
+    static const std::pair<std::string, std::string> replacements[] = {
+        {"\xEF\xBC\x8C", ","},   // ，
+        {"\xE3\x80\x82", "."},   // 。
+        {"\xEF\xBC\x81", "!"},   // ！
+        {"\xEF\xBC\x9F", "?"},   // ？
+        {"\xEF\xBC\x9B", ";"},   // ；
+        {"\xEF\xBC\x9A", ":"},   // ：
+        {"\xE3\x80\x81", ","},   // 、
+        {"\xE2\x80\x9C", "\""},  // "
+        {"\xE2\x80\x9D", "\""},  // "
+        {"\xE2\x80\x98", "'"},   // '
+        {"\xE2\x80\x99", "'"},   // '
+        {"\xE2\x80\xA6", "..."}, // …
+        {"\xE2\x8B\xAF", "..."}, // ⋯
+    };
+    std::string result = text;
+    for (auto& rep : replacements) {
+        size_t pos = 0;
+        while ((pos = result.find(rep.first, pos)) != std::string::npos) {
+            result.replace(pos, rep.first.length(), rep.second);
+            pos += rep.second.length();
+        }
+    }
+    return result;
+}
+
+std::vector<std::pair<std::string, std::string>>
+Tokenizer::GetSegments(const std::string& text) const {
+    std::vector<std::pair<std::string, std::string>> segments;
+    if (text.empty()) return segments;
+
+    std::string current;
+    std::string current_lang;
+
+    auto char_lang = [](char c) -> std::string {
+        if (IsChinese(c)) return "zh";
+        if (IsAlphabet(c)) return "en";
+        return "other";
+    };
+
+    for (size_t i = 0; i < text.size(); ) {
+        // Handle UTF-8 multi-byte characters
+        size_t char_len = 1;
+        unsigned char c = static_cast<unsigned char>(text[i]);
+        if ((c & 0x80) == 0) 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;
+
+        std::string ch = text.substr(i, char_len);
+        std::string lang;
+
+        if (char_len > 1) {
+            lang = "zh"; // Assume multi-byte UTF-8 is Chinese
+        } else if (IsAlphabet(ch[0])) {
+            lang = "en";
+        } else {
+            lang = "other";
+        }
+
+        if (current.empty()) {
+            current = ch;
+            current_lang = lang;
+        } else if (current_lang == "other" || lang == "other" || current_lang == lang) {
+            current += ch;
+            if (current_lang == "other" && lang != "other") current_lang = lang;
+        } else {
+            segments.push_back({current, current_lang});
+            current = ch;
+            current_lang = lang;
+        }
+        i += char_len;
+    }
+    if (!current.empty()) {
+        segments.push_back({current, current_lang});
+    }
+    return segments;
+}
+
+std::vector<std::string> Tokenizer::TokenizeZh(const std::string& text) const {
+    // Character-by-character pinyin tokenization using pinyin_table.hpp.
+    // Matches Python LocalEmiliaTokenizer (without jieba word segmentation).
+    std::vector<std::string> tokens;
+    std::string normalized = MapPunctuation(text);
+
+    for (size_t i = 0; i < normalized.size(); ) {
+        unsigned char c = static_cast<unsigned char>(normalized[i]);
+        size_t char_len = 1;
+        if ((c & 0x80) == 0) 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;
+
+        std::string ch = normalized.substr(i, char_len);
+        i += char_len;
+
+        // Punctuation or ASCII
+        if (char_len == 1) {
+            std::string mapped = MapPunctuation(ch);
+            if (mapped != ch && m_token2id.find(mapped) != m_token2id.end()) {
+                tokens.push_back(mapped);
+                continue;
+            }
+            if (m_token2id.find(ch) != m_token2id.end()) {
+                tokens.push_back(ch);
+                continue;
+            }
+        }
+
+        // Chinese character: lookup pinyin token IDs via generated table
+        if (char_len == 3) {
+            uint32_t cp = ((unsigned char)ch[0] & 0x0F) << 12
+                        | ((unsigned char)ch[1] & 0x3F) << 6
+                        | ((unsigned char)ch[2] & 0x3F);
+            auto ids = pinyin_lookup(cp);
+            for (int tid : ids) {
+                if (tid >= 0 && tid < (int)m_id2token.size() && !m_id2token[tid].empty()) {
+                    tokens.push_back(m_id2token[tid]);
+                }
+            }
+        }
+    }
+    return tokens;
+}
+
+std::vector<std::string> Tokenizer::TokenizeEn(const std::string& text) const {
+    // Simplified English tokenization: character-by-character phoneme mapping
+    // In production, use the Python tokenizer with piper_phonemize
+    std::vector<std::string> tokens;
+    std::string lower = text;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+    lower = MapPunctuation(lower);
+
+    for (size_t i = 0; i < lower.size(); ++i) {
+        char c = lower[i];
+        if (c == ' ') continue;
+        if (ispunct(c)) {
+            // Map common punctuation
+            switch (c) {
+                case ',': tokens.push_back(","); break;
+                case '.': tokens.push_back("."); break;
+                case '!': tokens.push_back("!"); break;
+                case '?': tokens.push_back("?"); break;
+                case ';': tokens.push_back(";"); break;
+                case ':': tokens.push_back(":"); break;
+                case '\'': tokens.push_back("'"); break;
+                case '"': tokens.push_back("\""); break;
+                default: break;
+            }
+            continue;
+        }
+        // Output character as-is (phoneme-based tokens)
+        std::string token(1, c);
+        if (m_token2id.find(token) != m_token2id.end()) {
+            tokens.push_back(token);
+        }
+    }
+    return tokens;
+}
+
+std::vector<int> Tokenizer::TextToTokenIds(const std::string& text) const {
+    if (!m_loaded) return {};
+
+    std::string normalized = MapPunctuation(text);
+    auto segments = GetSegments(normalized);
+
+    std::vector<int> token_ids;
+    for (auto& seg : segments) {
+        std::vector<std::string> tokens;
+        if (seg.second == "zh") {
+            tokens = TokenizeZh(seg.first);
+        } else if (seg.second == "en") {
+            tokens = TokenizeEn(seg.first);
+        }
+        // "other" segments: try individual chars as tokens
+        else {
+            for (char c : seg.first) {
+                std::string token(1, c);
+                if (m_token2id.find(token) != m_token2id.end()) {
+                    token_ids.push_back(m_token2id.at(token));
+                }
+            }
+            continue;
+        }
+
+        for (auto& token : tokens) {
+            auto it = m_token2id.find(token);
+            if (it != m_token2id.end()) {
+                token_ids.push_back(it->second);
+            }
+        }
+    }
+    return token_ids;
+}
+
+std::vector<std::vector<int>> Tokenizer::TextsToTokenIds(const std::vector<std::string>& texts) const {
+    std::vector<std::vector<int>> result;
+    result.reserve(texts.size());
+    for (auto& text : texts) {
+        result.push_back(TextToTokenIds(text));
+    }
+    return result;
+}
+
+void Tokenizer::BuildCatTokens(const std::vector<int>& prompt_tokens,
+                                const std::vector<int>& text_tokens,
+                                int max_tokens,
+                                std::vector<int32_t>& out_cat_tokens) const {
+    out_cat_tokens.assign(max_tokens, static_cast<int32_t>(m_pad_id));
+
+    size_t pos = 0;
+    for (size_t i = 0; i < prompt_tokens.size() && pos < (size_t)max_tokens; ++i) {
+        out_cat_tokens[pos++] = static_cast<int32_t>(prompt_tokens[i]);
+    }
+    for (size_t i = 0; i < text_tokens.size() && pos < (size_t)max_tokens; ++i) {
+        out_cat_tokens[pos++] = static_cast<int32_t>(text_tokens[i]);
+    }
+    if (pos < (size_t)max_tokens) {
+        out_cat_tokens[pos] = static_cast<int32_t>(m_pad_id);
+    }
+}

cpp/src/tokenizer.hpp

@@ -0,0 +1,79 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Tokenizer: loads tokens.txt and maps token strings to IDs.
+ *
+ * For board deployment, tokenization should ideally be done on a host machine
+ * and token IDs passed directly. This class provides basic tokenization
+ * capability for convenience.
+ **************************************************************************************************/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <cstdint>
+
+class Tokenizer {
+public:
+    Tokenizer();
+
+    /**
+     * Load tokens.txt file. Format: token\tid per line.
+     */
+    int Load(const std::string& token_file);
+
+    /**
+     * Convert a single text to token IDs using simplified rules.
+     * For production use, pre-compute token IDs with the Python tokenizer.
+     */
+    std::vector<int> TextToTokenIds(const std::string& text) const;
+
+    /**
+     * Convert multiple texts to token IDs.
+     */
+    std::vector<std::vector<int>> TextsToTokenIds(const std::vector<std::string>& texts) const;
+
+    /**
+     * Get the pad token ID ("_" token).
+     */
+    int GetPadId() const { return m_pad_id; }
+
+    /**
+     * Get vocabulary size.
+     */
+    int GetVocabSize() const { return static_cast<int>(m_token2id.size()); }
+
+    /**
+     * Lookup a single token. Returns pad_id if not found.
+     */
+    int TokenToId(const std::string& token) const;
+
+    /**
+     * Build concatenated token array [prompt_tokens + text_tokens + pad] padded to max_tokens.
+     */
+    void BuildCatTokens(const std::vector<int>& prompt_tokens,
+                        const std::vector<int>& text_tokens,
+                        int max_tokens,
+                        std::vector<int32_t>& out_cat_tokens) const;
+
+    bool IsLoaded() const { return m_loaded; }
+
+private:
+    std::unordered_map<std::string, int> m_token2id;
+    std::vector<std::string> m_id2token;
+    int m_pad_id;
+    bool m_loaded;
+
+    // Simplified text→tokens for Chinese (char-by-char pinyin-like tokens)
+    std::vector<std::string> TokenizeZh(const std::string& text) const;
+    // Simplified text→tokens for English (basic phoneme rules)
+    std::vector<std::string> TokenizeEn(const std::string& text) const;
+    // Split text into language segments
+    std::vector<std::pair<std::string, std::string>> GetSegments(const std::string& text) const;
+
+    static bool IsChinese(char c);
+    static bool IsAlphabet(char c);
+    static std::string MapPunctuation(const std::string& text);
+};

cpp/src/vocoder.cpp

@@ -0,0 +1,153 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Vocoder implementation using kissfft for fast IRFFT.
+ **************************************************************************************************/
+
+#include "src/vocoder.hpp"
+
+#include <cmath>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+Vocoder::Vocoder() : m_has_init(false), m_n_freqs(0) {}
+Vocoder::~Vocoder() {
+    m_session.reset();
+    if (m_fft_cfg)  { rnn_fft_free(m_fft_cfg, 0);  m_fft_cfg = nullptr; }
+    m_ifft_cfg = nullptr;  // shared with m_fft_cfg
+}
+
+int Vocoder::Init(const Config& cfg) {
+    m_cfg = cfg;
+    m_n_freqs = cfg.n_fft / 2 + 1;  // 513
+
+    BuildWindow();
+
+    // Init kissfft once
+    m_fft_cfg = rnn_fft_alloc(cfg.n_fft, NULL, NULL, 0);
+    if (!m_fft_cfg) {
+        printf("Failed to init kissfft for vocoder\n");
+        return -1;
+    }
+    m_ifft_cfg = m_fft_cfg;
+
+    // Load vocos_full.axmodel
+    m_session = std::make_unique<EngineWrapper>();
+    if (m_session->Init(cfg.model_path.c_str()) != 0) {
+        printf("Failed to load vocoder model: %s\n", cfg.model_path.c_str());
+        return -1;
+    }
+
+    m_has_init = true;
+    printf("Vocoder initialized: n_fft=%d, hop=%d, n_mels=%d\n",
+           cfg.n_fft, cfg.hop_length, cfg.n_mels);
+    return 0;
+}
+
+void Vocoder::BuildWindow() {
+    int n = m_cfg.n_fft;
+    m_window.resize(n);
+    m_window_sq.resize(n);
+    for (int i = 0; i < n; ++i) {
+        m_window[i] = 0.5f * (1.0f - std::cos(2.0f * M_PI * i / (n - 1)));
+        m_window_sq[i] = m_window[i] * m_window[i];
+    }
+}
+
+int Vocoder::Decode(const std::vector<float>& mel, int T, float feat_scale, std::vector<float>& audio) {
+    if (!m_has_init || mel.empty()) return -1;
+
+    int feat_dim = m_cfg.n_mels;      // 100
+    int n_fft = m_cfg.n_fft;          // 1024
+    int n_freqs = m_n_freqs;          // 513
+    int hop = m_cfg.hop_length;       // 256
+
+    // 1. Undo feat_scale and transpose to [1, n_mels, T_model]
+    float inv_scale = (feat_scale != 0.0f) ? (1.0f / feat_scale) : 1.0f;
+    int T_model = 620;
+    std::vector<float> mel_padded(T_model * feat_dim, 0.0f);
+    for (int t = 0; t < T; ++t) {
+        for (int c = 0; c < feat_dim; ++c) {
+            mel_padded[c * T_model + t] = mel[t * feat_dim + c] * inv_scale;
+        }
+    }
+
+    // 2. Run vocos_full.axmodel on NPU
+    int input_idx = m_session->GetInputIndex("mel");
+    if (input_idx < 0) input_idx = 0;
+    m_session->SetInput(mel_padded.data(), input_idx);
+
+    if (m_session->RunSync() != 0) {
+        printf("Vocoder NPU inference failed\n");
+        return -1;
+    }
+
+    int real_idx = m_session->GetOutputIndex("real");
+    int imag_idx = m_session->GetOutputIndex("imag");
+    if (real_idx < 0) real_idx = 0;
+    if (imag_idx < 0) imag_idx = 1;
+
+    int spec_size = m_session->GetOutputSize(real_idx);
+    std::vector<float> real_spec(spec_size / sizeof(float));
+    std::vector<float> imag_spec(spec_size / sizeof(float));
+    m_session->GetOutput(real_spec.data(), real_idx);
+    m_session->GetOutput(imag_spec.data(), imag_idx);
+
+    // 3. kissfft IRFFT + window + overlap-add
+    int out_len = (T - 1) * hop + n_fft;
+    audio.assign(out_len, 0.0f);
+    std::vector<float> envelope(out_len, 0.0f);
+
+    std::vector<kiss_fft_cpx> cx_in(n_fft), cx_out(n_fft);
+
+    for (int t = 0; t < T; ++t) {
+        int spec_offset = t * n_freqs;
+
+        // Build full Hermitian spectrum from [0..N/2]
+        cx_in[0].r = real_spec[spec_offset + 0];
+        cx_in[0].i = 0.0f;
+        for (int k = 1; k < n_freqs - 1; ++k) {
+            cx_in[k].r = real_spec[spec_offset + k];
+            cx_in[k].i = imag_spec[spec_offset + k];
+            cx_in[n_fft - k].r =  real_spec[spec_offset + k];
+            cx_in[n_fft - k].i = -imag_spec[spec_offset + k];
+        }
+        cx_in[n_freqs - 1].r = real_spec[spec_offset + (n_freqs - 1)];
+        cx_in[n_freqs - 1].i = 0.0f;  // Nyquist imag must be 0
+
+        rnn_ifft(m_ifft_cfg, cx_in.data(), cx_out.data(), 0);
+
+        // Window + overlap-add
+        int pos = t * hop;
+        for (int n = 0; n < n_fft; ++n) {
+            float sample = (cx_out[n].r / n_fft) * m_window[n];
+            int p = pos + n;
+            if (p < out_len) {
+                audio[p] += sample;
+                envelope[p] += m_window_sq[n];
+            }
+        }
+    }
+
+    // 4. Normalize by window envelope
+    for (int i = 0; i < out_len; ++i) {
+        if (envelope[i] > 1e-10f) {
+            audio[i] /= envelope[i];
+        }
+    }
+
+    // 5. Center trim (n_fft/2 from each side, matching torch.istft center=True)
+    int pad = n_fft / 2;
+    int trim_len = out_len - 2 * pad;
+    if (trim_len > 0) {
+        std::vector<float> trimmed(audio.begin() + pad, audio.begin() + pad + trim_len);
+        audio = std::move(trimmed);
+    }
+
+    return 0;
+}

cpp/src/vocoder.hpp

@@ -0,0 +1,66 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Vocoder: mel features → audio via vocos_full.axmodel + IRFFT + overlap-add.
+ **************************************************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+
+#include "src/EngineWrapper.hpp"
+#include "kiss_fft.h"
+
+class Vocoder {
+public:
+    struct Config {
+        std::string model_path;
+        int n_fft = 1024;
+        int hop_length = 256;
+        int win_length = 1024;
+        int n_mels = 100;
+        int sample_rate = 24000;
+    };
+
+    Vocoder();
+    ~Vocoder();
+
+    /**
+     * Initialize: load vocos_full.axmodel and pre-compute IRFFT basis.
+     */
+    int Init(const Config& cfg);
+
+    /**
+     * Decode mel features to audio waveform.
+     * @param mel        Mel features [T, n_mels] (flat, row-major)
+     * @param T          Number of mel frames
+     * @param feat_scale Feature scaling factor to undo (Python: features/feat_scale before vocoder)
+     * @param audio      Output audio samples (24kHz float32)
+     */
+    int Decode(const std::vector<float>& mel, int T, float feat_scale, std::vector<float>& audio);
+
+    bool HasInit() const { return m_has_init; }
+
+private:
+    Config m_cfg;
+    bool m_has_init;
+    std::unique_ptr<EngineWrapper> m_session;
+
+    // kissfft configs (shared forward/inverse twiddles)
+    kiss_fft_state* m_fft_cfg = nullptr;
+    kiss_fft_state* m_ifft_cfg = nullptr;
+
+    // Hann window
+    std::vector<float> m_window;
+
+    // Window squared for envelope normalization
+    std::vector<float> m_window_sq;
+
+    int m_n_freqs;
+
+    void BuildWindow();
+
+    static void Fft(std::vector<float>& real, std::vector<float>& imag, bool inverse);
+};

cpp/src/wav_writer.hpp

@@ -0,0 +1,84 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Simple WAV file writer for float32 mono audio.
+ **************************************************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <cstdint>
+#include <cstring>
+
+class WavWriter {
+public:
+    /**
+     * Write float32 mono audio samples to a WAV file.
+     *
+     * @param path        Output file path
+     * @param samples     Float32 audio samples in range [-1.0, 1.0]
+     * @param sample_rate Sample rate in Hz (e.g., 24000)
+     * @return true on success
+     */
+    static bool Write(const std::string& path,
+                      const std::vector<float>& samples,
+                      int sample_rate) {
+        std::ofstream file(path, std::ios::binary);
+        if (!file.is_open()) return false;
+
+        int num_samples = static_cast<int>(samples.size());
+        int byte_rate = sample_rate * 2;  // 16-bit mono
+        int data_size = num_samples * 2;
+        int chunk_size = 36 + data_size;
+
+        // RIFF header
+        Write4CC(file, "RIFF");
+        WriteU32LE(file, chunk_size);
+        Write4CC(file, "WAVE");
+
+        // fmt chunk
+        Write4CC(file, "fmt ");
+        WriteU32LE(file, 16);           // chunk size
+        WriteU16LE(file, 1);            // PCM format
+        WriteU16LE(file, 1);            // mono
+        WriteU32LE(file, sample_rate);
+        WriteU32LE(file, byte_rate);
+        WriteU16LE(file, 2);            // block align
+        WriteU16LE(file, 16);           // bits per sample
+
+        // data chunk
+        Write4CC(file, "data");
+        WriteU32LE(file, data_size);
+
+        // Convert float32 to int16 (with clipping)
+        for (float sample : samples) {
+            // Clamp to [-1, 1]
+            if (sample > 1.0f) sample = 1.0f;
+            if (sample < -1.0f) sample = -1.0f;
+            int16_t val = static_cast<int16_t>(sample * 32767.0f);
+            WriteU16LE(file, static_cast<uint16_t>(val));
+        }
+
+        file.close();
+        return true;
+    }
+
+private:
+    static void WriteU16LE(std::ofstream& f, uint16_t v) {
+        f.put(v & 0xFF);
+        f.put((v >> 8) & 0xFF);
+    }
+
+    static void WriteU32LE(std::ofstream& f, uint32_t v) {
+        f.put(v & 0xFF);
+        f.put((v >> 8) & 0xFF);
+        f.put((v >> 16) & 0xFF);
+        f.put((v >> 24) & 0xFF);
+    }
+
+    static void Write4CC(std::ofstream& f, const char* s) {
+        f.write(s, 4);
+    }
+};

cpp/src/zipvoice_engine.cpp

@@ -0,0 +1,614 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * ZipVoiceEngine implementation.
+ **************************************************************************************************/
+
+#include "zipvoice_engine.hpp"
+
+#include <fstream>
+#include <sstream>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <sys/time.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+// Simple JSON value parser (no external dependency)
+// Only parses the simple structures needed by manifest.json and runtime_config.json
+namespace {
+
+std::string json_get_string(const std::string& json, const std::string& key) {
+    std::string search = "\"" + key + "\"";
+    size_t pos = json.find(search);
+    if (pos == std::string::npos) return "";
+
+    pos = json.find(':', pos + search.length());
+    if (pos == std::string::npos) return "";
+
+    pos = json.find('"', pos + 1);
+    if (pos == std::string::npos) return "";
+
+    size_t end = json.find('"', pos + 1);
+    if (end == std::string::npos) return "";
+
+    return json.substr(pos + 1, end - pos - 1);
+}
+
+int json_get_int(const std::string& json, const std::string& key, int default_val = 0) {
+    std::string search = "\"" + key + "\"";
+    size_t pos = json.find(search);
+    if (pos == std::string::npos) return default_val;
+
+    pos = json.find(':', pos + search.length());
+    if (pos == std::string::npos) return default_val;
+
+    // Skip whitespace
+    pos++;
+    while (pos < json.length() && (json[pos] == ' ' || json[pos] == '\t' || json[pos] == '\n')) pos++;
+    if (pos >= json.length()) return default_val;
+
+    // Parse number
+    std::string num_str;
+    while (pos < json.length() && (std::isdigit(json[pos]) || json[pos] == '-' || json[pos] == '.')) {
+        num_str += json[pos];
+        pos++;
+    }
+    if (num_str.empty()) return default_val;
+
+    // Check if float
+    if (num_str.find('.') != std::string::npos) {
+        return static_cast<int>(std::stof(num_str));
+    }
+    return std::stoi(num_str);
+}
+
+float json_get_float(const std::string& json, const std::string& key, float default_val = 0.0f) {
+    std::string search = "\"" + key + "\"";
+    size_t pos = json.find(search);
+    if (pos == std::string::npos) return default_val;
+
+    pos = json.find(':', pos + search.length());
+    if (pos == std::string::npos) return default_val;
+
+    pos++;
+    while (pos < json.length() && (json[pos] == ' ' || json[pos] == '\t' || json[pos] == '\n')) pos++;
+    if (pos >= json.length()) return default_val;
+
+    std::string num_str;
+    while (pos < json.length() && (std::isdigit(json[pos]) || json[pos] == '-' || json[pos] == '.')) {
+        num_str += json[pos];
+        pos++;
+    }
+    if (num_str.empty()) return default_val;
+    return std::stof(num_str);
+}
+
+std::vector<std::string> json_get_string_array(const std::string& json, const std::string& key) {
+    std::vector<std::string> result;
+    std::string search = "\"" + key + "\"";
+    size_t pos = json.find(search);
+    if (pos == std::string::npos) return result;
+
+    pos = json.find('[', pos + search.length());
+    if (pos == std::string::npos) return result;
+
+    size_t end = json.find(']', pos);
+    if (end == std::string::npos) return result;
+
+    std::string array_str = json.substr(pos + 1, end - pos - 1);
+
+    size_t start = 0;
+    while (start < array_str.length()) {
+        size_t q1 = array_str.find('"', start);
+        if (q1 == std::string::npos) break;
+        size_t q2 = array_str.find('"', q1 + 1);
+        if (q2 == std::string::npos) break;
+        result.push_back(array_str.substr(q1 + 1, q2 - q1 - 1));
+        start = q2 + 1;
+    }
+    return result;
+}
+
+std::string read_file_content(const std::string& path) {
+    std::ifstream file(path);
+    if (!file.is_open()) return "";
+    std::stringstream ss;
+    ss << file.rdbuf();
+    return ss.str();
+}
+
+} // anonymous namespace
+
+ZipVoiceEngine::ZipVoiceEngine()
+    : m_has_init(false), m_decoder_seq_len(0), m_decoder_has_padding_mask(false) {}
+
+ZipVoiceEngine::~ZipVoiceEngine() {
+    m_sessions.clear();
+}
+
+double ZipVoiceEngine::GetCurrentTimeMs() {
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
+}
+
+int ZipVoiceEngine::Init(const std::string& model_dir) {
+    if (LoadConfig(model_dir) != 0) return -1;
+    if (LoadManifest(model_dir) != 0) return -1;
+    if (LoadModels(model_dir) != 0) return -1;
+    if (LoadDecoderMetadata() != 0) return -1;
+
+    m_has_init = true;
+    printf("ZipVoiceEngine initialized: max_tokens=%d, max_feat_len=%d, feat_dim=%d, num_step=%d\n",
+           m_config.max_tokens, m_config.max_feat_len, m_config.feat_dim, m_config.num_step);
+    return 0;
+}
+
+int ZipVoiceEngine::LoadConfig(const std::string& model_dir) {
+    std::string config_path = model_dir + "/runtime_config.json";
+    std::string json = read_file_content(config_path);
+    if (!json.empty()) {
+        m_config.max_tokens = json_get_int(json, "max_tokens", 384);
+        m_config.max_feat_len = json_get_int(json, "max_feat_len", 1024);
+        m_config.feat_dim = json_get_int(json, "feat_dim", 100);
+        m_config.sampling_rate = json_get_int(json, "sampling_rate", 24000);
+        m_config.hop_length = json_get_int(json, "hop_length", 256);
+        m_config.num_step = json_get_int(json, "num_step", 10);
+        m_config.t_shift = json_get_float(json, "t_shift", 0.5f);
+    }
+    m_config.model_dir = model_dir;
+    return 0;
+}
+
+int ZipVoiceEngine::LoadManifest(const std::string& model_dir) {
+    std::string manifest_path = model_dir + "/decoder4_split_manifest.json";
+    std::string json = read_file_content(manifest_path);
+    if (json.empty()) {
+        printf("Failed to read manifest: %s\n", manifest_path.c_str());
+        return -1;
+    }
+
+    // Parse encoder info
+    m_encoder_info.name = json_get_string(json, "name");
+    // Need to parse the nested "encoder" object
+    size_t enc_pos = json.find("\"encoder\"");
+    if (enc_pos != std::string::npos) {
+        size_t obj_start = json.find('{', enc_pos);
+        size_t obj_end = json.find('}', obj_start);
+        if (obj_start != std::string::npos && obj_end != std::string::npos) {
+            std::string enc_json = json.substr(obj_start, obj_end - obj_start + 1);
+            m_encoder_info.name = json_get_string(enc_json, "name");
+            m_encoder_info.file = json_get_string(enc_json, "file");
+            m_encoder_info.inputs = json_get_string_array(enc_json, "inputs");
+            m_encoder_info.outputs = json_get_string_array(enc_json, "outputs");
+        }
+    }
+
+    // Parse decoder_parts array
+    size_t dec_pos = json.find("\"decoder_parts\"");
+    if (dec_pos != std::string::npos) {
+        size_t arr_start = json.find('[', dec_pos);
+        if (arr_start != std::string::npos) {
+            m_decoder_parts.clear();
+            size_t pos = arr_start + 1;
+            int depth = 0;
+            std::string part_json;
+            for (; pos < json.length(); ++pos) {
+                if (json[pos] == '{') depth++;
+                if (depth > 0) part_json += json[pos];
+                if (json[pos] == '}') {
+                    depth--;
+                    if (depth == 0) {
+                        // Parse this part
+                        ModelInfo info;
+                        info.name = json_get_string(part_json, "name");
+                        info.file = json_get_string(part_json, "file");
+                        info.inputs = json_get_string_array(part_json, "inputs");
+                        info.outputs = json_get_string_array(part_json, "outputs");
+                        m_decoder_parts.push_back(info);
+                        part_json.clear();
+                    }
+                }
+            }
+        }
+    }
+
+    printf("Manifest: encoder=%s, decoder_parts=%zu\n",
+           m_encoder_info.name.c_str(), m_decoder_parts.size());
+    for (size_t i = 0; i < m_decoder_parts.size(); ++i) {
+        printf("  part%zu: %s (%s) in=%zu out=%zu\n", i,
+               m_decoder_parts[i].name.c_str(), m_decoder_parts[i].file.c_str(),
+               m_decoder_parts[i].inputs.size(), m_decoder_parts[i].outputs.size());
+    }
+    return 0;
+}
+
+int ZipVoiceEngine::LoadModels(const std::string& model_dir) {
+    // Load encoder
+    std::string enc_path = model_dir + "/" + m_encoder_info.file;
+    auto enc = std::make_unique<EngineWrapper>();
+    if (enc->Init(enc_path.c_str()) != 0) {
+        printf("Failed to load encoder: %s\n", enc_path.c_str());
+        return -1;
+    }
+    m_sessions[m_encoder_info.name] = std::move(enc);
+
+    // Load decoder parts
+    for (auto& part : m_decoder_parts) {
+        std::string path = model_dir + "/" + part.file;
+        auto sess = std::make_unique<EngineWrapper>();
+        if (sess->Init(path.c_str()) != 0) {
+            printf("Failed to load decoder part: %s\n", path.c_str());
+            return -1;
+        }
+        m_sessions[part.name] = std::move(sess);
+    }
+
+    printf("Loaded %zu models\n", m_sessions.size());
+    return 0;
+}
+
+int ZipVoiceEngine::LoadDecoderMetadata() {
+    if (m_decoder_parts.empty()) return -1;
+
+    auto& part0 = m_decoder_parts[0];
+    auto it = m_sessions.find(part0.name);
+    if (it == m_sessions.end()) return -1;
+
+    auto& sess = it->second;
+
+    // Check if padding_mask is an input
+    int pad_idx = sess->GetInputIndex("padding_mask");
+    m_decoder_has_padding_mask = (pad_idx >= 0);
+
+    // Get sequence length from x input shape
+    m_decoder_seq_len = m_config.max_feat_len;
+
+    // Try to get seq_len from model metadata
+    // The shape info is in the AX engine io_info; for simplicity we use config value
+
+    printf("Decoder metadata: seq_len=%d, has_padding_mask=%d\n",
+           m_decoder_seq_len, m_decoder_has_padding_mask ? 1 : 0);
+    return 0;
+}
+
+std::vector<float> ZipVoiceEngine::GetTimesteps(int num_step, float t_shift) const {
+    std::vector<float> ts(num_step + 1);
+    for (int i = 0; i <= num_step; ++i) {
+        float t = static_cast<float>(i) / num_step;
+        ts[i] = t_shift * t / (1.0f + (t_shift - 1.0f) * t);
+    }
+    return ts;
+}
+
+int ZipVoiceEngine::RunEncoder(const std::vector<int32_t>& cat_tokens,
+                                std::vector<float>& out_encoded) {
+    auto it = m_sessions.find(m_encoder_info.name);
+    if (it == m_sessions.end()) return -1;
+
+    auto& sess = it->second;
+
+    // Set input
+    int input_idx = sess->GetInputIndex(m_encoder_info.inputs[0].c_str());
+    if (input_idx < 0) input_idx = 0;
+
+    // Need to copy to non-const buffer for the engine API
+    std::vector<int32_t> input_copy = cat_tokens;
+    sess->SetInput(input_copy.data(), input_idx);
+
+    // Run
+    if (sess->RunSync() != 0) return -1;
+
+    // Get output
+    int output_idx = sess->GetOutputIndex(m_encoder_info.outputs[0].c_str());
+    if (output_idx < 0) output_idx = 0;
+
+    int output_size = sess->GetOutputSize(output_idx);
+    out_encoded.resize(output_size / sizeof(float));
+    sess->GetOutput(out_encoded.data(), output_idx);
+
+    return 0;
+}
+
+int ZipVoiceEngine::DurationExpand(const std::vector<float>& encoded,
+                                    int prompt_tokens_len,
+                                    int text_tokens_len,
+                                    int prompt_features_len,
+                                    float speed,
+                                    std::vector<float>& out_text_condition,
+                                    int& out_features_len) {
+    int total_tokens_len = prompt_tokens_len + text_tokens_len;
+    if (total_tokens_len <= 0) return -1;
+
+    // Compute target features length
+    int features_len = static_cast<int>(
+        std::ceil(static_cast<float>(prompt_features_len) / prompt_tokens_len
+                  * total_tokens_len / speed)
+    );
+    if (features_len > m_config.max_feat_len) {
+        features_len = m_config.max_feat_len;
+    }
+
+    int feat_dim = m_config.feat_dim;
+
+    // encoded shape: [1, max_tokens, feat_dim] (flat array)
+    // Extract the no-pad portion
+    int token_dur = features_len / total_tokens_len;
+    int max_tokens = m_config.max_tokens;
+
+    // out_text_condition: [1, features_len, feat_dim]
+    out_text_condition.assign(features_len * feat_dim, 0.0f);
+
+    // Repeat each token embedding token_dur times
+    for (int t = 0; t < total_tokens_len; ++t) {
+        int base_idx = t * feat_dim;
+        for (int d = 0; d < token_dur; ++d) {
+            int frame_idx = t * token_dur + d;
+            if (frame_idx >= features_len) break;
+            int dst_idx = frame_idx * feat_dim;
+            std::copy(encoded.begin() + base_idx,
+                      encoded.begin() + base_idx + feat_dim,
+                      out_text_condition.begin() + dst_idx);
+        }
+    }
+
+    // Fill residual frames with last token embedding
+    int filled = total_tokens_len * token_dur;
+    int residual = features_len - filled;
+    if (residual > 0) {
+        int last_base = total_tokens_len * feat_dim;
+        for (int d = 0; d < residual; ++d) {
+            int dst_idx = (filled + d) * feat_dim;
+            std::copy(encoded.begin() + last_base,
+                      encoded.begin() + last_base + feat_dim,
+                      out_text_condition.begin() + dst_idx);
+        }
+    }
+
+    out_features_len = features_len;
+    return 0;
+}
+
+int ZipVoiceEngine::RunDecoderPart(const ModelInfo& part,
+                                    std::map<std::string, std::vector<float>>& values,
+                                    const std::vector<uint8_t>* padding_mask_data,
+                                    std::vector<uint8_t>* padding_mask2_out) {
+    auto it = m_sessions.find(part.name);
+    if (it == m_sessions.end()) return -1;
+    auto& sess = it->second;
+
+    // Set inputs in order
+    for (size_t i = 0; i < part.inputs.size(); ++i) {
+        const std::string& expected_name = part.inputs[i];
+
+        int input_idx = sess->GetInputIndex(expected_name.c_str());
+        if (input_idx < 0) input_idx = static_cast<int>(i);
+
+        // padding_mask: use uint8 data from caller (part0 only)
+        if (expected_name == "padding_mask") {
+            if (padding_mask_data) {
+                sess->SetInput((void*)padding_mask_data->data(), input_idx);
+                continue;
+            }
+        }
+        // padding_mask2: use raw uint8 data from part0's output
+        if (expected_name == "padding_mask2") {
+            if (padding_mask2_out && !padding_mask2_out->empty()) {
+                sess->SetInput((void*)padding_mask2_out->data(), input_idx);
+                continue;
+            }
+            printf("ERROR: padding_mask2 not available for '%s'\n", part.name.c_str());
+            return -1;
+        }
+
+        // Find the value in float map
+        auto val_it = values.find(expected_name);
+        if (val_it == values.end()) {
+            printf("Missing input '%s' for model '%s'\n",
+                   expected_name.c_str(), part.name.c_str());
+            return -1;
+        }
+
+        sess->SetInput((void*)val_it->second.data(), input_idx);
+    }
+
+    // Run
+    if (sess->RunSync() != 0) return -1;
+
+    // Get outputs
+    for (size_t i = 0; i < part.outputs.size(); ++i) {
+        const std::string& name = part.outputs[i];
+
+        int output_idx = sess->GetOutputIndex(name.c_str());
+        if (output_idx < 0) output_idx = static_cast<int>(i);
+
+        int size = sess->GetOutputSize(output_idx);
+        if (size <= 0) {
+            printf("Invalid output size for '%s' in '%s'\n",
+                   name.c_str(), part.name.c_str());
+            return -1;
+        }
+
+        // padding_mask2 is uint8 — read raw bytes, don't convert to float
+        if (name == "padding_mask2" && padding_mask2_out) {
+            padding_mask2_out->resize(size);
+            sess->GetOutput(padding_mask2_out->data(), output_idx);
+            continue;
+        }
+
+        std::vector<float> output_data(size / sizeof(float));
+        sess->GetOutput(output_data.data(), output_idx);
+        values[name] = std::move(output_data);
+    }
+
+    return 0;
+}
+
+int ZipVoiceEngine::Sample(const std::vector<int32_t>& cat_tokens,
+                            int prompt_tokens_len,
+                            int text_tokens_len,
+                            const std::vector<float>& prompt_features,
+                            int prompt_features_len,
+                            float speed,
+                            float guidance_scale,
+                            int seed,
+                            std::vector<float>& out_features,
+                            Timing& out_timing) {
+    double t_total_start = GetCurrentTimeMs();
+
+    // 1. Run encoder
+    double t_start = GetCurrentTimeMs();
+    std::vector<float> encoded;
+    if (RunEncoder(cat_tokens, encoded) != 0) return -1;
+    out_timing.encoder_time_sec = static_cast<float>(GetCurrentTimeMs() - t_start) / 1000.0f;
+
+    // encoded shape: [max_tokens * feat_dim] (flattened, batch=1)
+    int feat_dim = m_config.feat_dim;
+
+    // 2. Duration expand
+    t_start = GetCurrentTimeMs();
+    std::vector<float> text_condition;
+    int features_len;
+    if (DurationExpand(encoded, prompt_tokens_len, text_tokens_len,
+                       prompt_features_len, speed,
+                       text_condition, features_len) != 0) return -1;
+    out_timing.duration_expand_time_sec = static_cast<float>(GetCurrentTimeMs() - t_start) / 1000.0f;
+
+    // 3. Prepare decoder inputs
+    int seq_len = m_decoder_seq_len > 0 ? m_decoder_seq_len : m_config.max_feat_len;
+
+    if (features_len > seq_len) {
+        printf("features_len=%d exceeds decoder seq_len=%d\n", features_len, seq_len);
+        return -1;
+    }
+    if (prompt_features_len > seq_len) {
+        printf("prompt_features_len=%d exceeds decoder seq_len=%d\n", prompt_features_len, seq_len);
+        return -1;
+    }
+
+    // text_cond_padded: [1, seq_len, feat_dim] (zeros, filled up to features_len)
+    std::vector<float> text_cond_padded(seq_len * feat_dim, 0.0f);
+    std::copy(text_condition.begin(),
+              text_condition.begin() + features_len * feat_dim,
+              text_cond_padded.begin());
+
+    // speech_cond_padded: [1, seq_len, feat_dim]
+    std::vector<float> speech_cond_padded(seq_len * feat_dim, 0.0f);
+    std::copy(prompt_features.begin(),
+              prompt_features.begin() + prompt_features_len * feat_dim,
+              speech_cond_padded.begin());
+
+    // padding_mask: [1, seq_len] as uint8_t (bool), NOT float32!
+    // Python: np.zeros((1, seq_len), dtype=np.bool_)
+    std::vector<uint8_t> padding_mask(seq_len, 0);
+    for (int i = features_len; i < seq_len; ++i) {
+        padding_mask[i] = 1;
+    }
+
+    // x: random init [1, seq_len, feat_dim]
+    std::vector<float> x(seq_len * feat_dim, 0.0f);
+    // Simple LCG random
+    uint32_t rng_state = static_cast<uint32_t>(seed > 0 ? seed : 42);
+    for (int i = 0; i < features_len * feat_dim; ++i) {
+        rng_state = rng_state * 1103515245 + 12345;
+        // Box-Muller for normal distribution
+        float u1 = static_cast<float>(rng_state & 0x7FFFFFFF) / 0x7FFFFFFF;
+        rng_state = rng_state * 1103515245 + 12345;
+        float u2 = static_cast<float>(rng_state & 0x7FFFFFFF) / 0x7FFFFFFF;
+        x[i] = std::sqrt(-2.0f * std::log(std::max(u1, 1e-10f)))
+               * std::cos(2.0f * M_PI * u2);
+    }
+
+    // Time steps
+    std::vector<float> timesteps = GetTimesteps(m_config.num_step, m_config.t_shift);
+
+    // Guidance scale as single float array
+    std::vector<float> gs = { guidance_scale };
+
+    // 4. Flow-matching decoder
+    double t_dec_total = 0.0;
+    for (int step = 0; step < m_config.num_step; ++step) {
+        double t_step_start = GetCurrentTimeMs();
+
+        // Prepare inputs for this step
+        std::map<std::string, std::vector<float>> values;
+
+        // t: scalar
+        std::vector<float> t_val = { timesteps[step] };
+        values["t"] = t_val;
+
+        // x: [1, seq_len, feat_dim]
+        values["x"] = x;
+
+        // text_condition
+        values["text_condition"] = text_cond_padded;
+
+        // speech_condition
+        values["speech_condition"] = speech_cond_padded;
+
+        // guidance_scale: scalar
+        values["guidance_scale"] = gs;
+
+        // padding_mask is passed separately as uint8_t (bool), not in values map
+        std::vector<uint8_t> padding_mask2_data;  // populated by part0, used by parts 1-3
+
+        // Run all decoder parts in sequence
+        for (auto& part : m_decoder_parts) {
+            if (RunDecoderPart(part, values, &padding_mask, &padding_mask2_data) != 0) return -1;
+        }
+
+        t_dec_total += GetCurrentTimeMs() - t_step_start;
+
+        // Get v (velocity) from last part output
+        const std::string& final_output_name = m_decoder_parts.back().outputs[0];
+        auto vit = values.find(final_output_name);
+        if (vit == values.end()) {
+            printf("Missing final output '%s'\n", final_output_name.c_str());
+            return -1;
+        }
+
+        const std::vector<float>& v = vit->second;
+
+        // Euler step: x = x + v * dt
+        float dt = timesteps[step + 1] - timesteps[step];
+        for (size_t i = 0; i < x.size(); ++i) {
+            x[i] += v[i] * dt;
+        }
+
+        // Zero out padding region
+        for (int i = features_len * feat_dim; i < seq_len * feat_dim; ++i) {
+            x[i] = 0.0f;
+        }
+    }
+
+    out_timing.decoder_time_sec = static_cast<float>(t_dec_total) / 1000.0f;
+
+    // 5. Extract generated features (excluding prompt region)
+    int generated_frames = features_len - prompt_features_len;
+    if (generated_frames <= 0) {
+        generated_frames = features_len;
+        out_features.assign(x.begin(), x.begin() + features_len * feat_dim);
+    } else {
+        int offset = prompt_features_len * feat_dim;
+        out_features.assign(x.begin() + offset,
+                            x.begin() + features_len * feat_dim);
+    }
+
+    out_timing.generated_frames = generated_frames;
+    out_timing.features_len = features_len;
+    out_timing.total_time_sec = static_cast<float>(GetCurrentTimeMs() - t_total_start) / 1000.0f;
+
+    printf("  encoder: %.3f s  dur_expand: %.3f s  decoder(%d steps): %.3f s (avg %.3f ms/step)  total: %.3f s\n",
+           out_timing.encoder_time_sec,
+           out_timing.duration_expand_time_sec,
+           m_config.num_step,
+           out_timing.decoder_time_sec,
+           out_timing.decoder_time_sec / m_config.num_step * 1000.0f,
+           out_timing.total_time_sec);
+
+    return 0;
+}

cpp/src/zipvoice_engine.hpp

@@ -0,0 +1,144 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * ZipVoiceEngine: the core TTS inference engine.
+ *
+ * Manages encoder + split-decoder4 axmodel inference, duration expansion,
+ * and flow-matching sampling. Mirrors the Python Decoder4ZipVoiceBoardRuntime.
+ *
+ * Model pipeline:
+ *   1. encoder.axmodel:  cat_tokens[n] → encoded[n, feat_dim]
+ *   2. Duration expand:  repeat tokens → text_condition[1, seq_len, feat_dim]
+ *   3. decoder_part0..3: flow-matching ODE solver (Euler, num_step steps)
+ *      part0: t, x, text_cond, speech_cond, guidance_scale, padding_mask
+ *             → decoder_hidden_p0, time_hidden, padding_mask2, cfg_scale
+ *      part1: decoder_hidden_p0, time_hidden, padding_mask2 → decoder_hidden_p1
+ *      part2: decoder_hidden_p1, time_hidden, padding_mask2 → decoder_hidden_p2
+ *      part3: decoder_hidden_p2, time_hidden, padding_mask2, cfg_scale → v
+ *      x = x + v * dt
+ **************************************************************************************************/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include <cstdint>
+
+#include "EngineWrapper.hpp"
+
+class ZipVoiceEngine {
+public:
+    struct Config {
+        std::string model_dir;
+        int max_feat_len = 1024;
+        int max_tokens = 384;
+        int feat_dim = 100;
+        int sampling_rate = 24000;
+        int hop_length = 256;
+        int num_step = 10;
+        float t_shift = 0.5f;
+    };
+
+    struct ModelInfo {
+        std::string name;
+        std::string file;
+        std::vector<std::string> inputs;
+        std::vector<std::string> outputs;
+    };
+
+    struct Timing {
+        float encoder_time_sec = 0.0f;
+        float duration_expand_time_sec = 0.0f;
+        float decoder_time_sec = 0.0f;
+        float total_time_sec = 0.0f;
+        int generated_frames = 0;
+        int features_len = 0;
+    };
+
+    ZipVoiceEngine();
+    ~ZipVoiceEngine();
+
+    /**
+     * Initialize from a model directory containing:
+     *   - runtime_config.json
+     *   - decoder4_split_manifest.json
+     *   - encoder.axmodel
+     *   - decoder_part0.axmodel .. decoder_part3.axmodel
+     */
+    int Init(const std::string& model_dir);
+
+    /**
+     * Run encoder: cat_tokens[1, max_tokens] → encoded[1, max_tokens, feat_dim].
+     * out_encoded should be pre-allocated with size: 1 * max_tokens * feat_dim floats.
+     */
+    int RunEncoder(const std::vector<int32_t>& cat_tokens, std::vector<float>& out_encoded);
+
+    /**
+     * Duration expand: token-level features → frame-level features.
+     */
+    int DurationExpand(const std::vector<float>& encoded,
+                       int prompt_tokens_len,
+                       int text_tokens_len,
+                       int prompt_features_len,
+                       float speed,
+                       std::vector<float>& out_text_condition,
+                       int& out_features_len);
+
+    /**
+     * Full sampling: encoder → duration_expand → decoder flow-matching.
+     *
+     * @param cat_tokens          [max_tokens] int32 token IDs
+     * @param prompt_tokens_len   number of prompt tokens
+     * @param text_tokens_len     number of text tokens
+     * @param prompt_features     [prompt_frames, feat_dim] mel features from prompt wav
+     * @param prompt_features_len number of prompt feature frames
+     * @param speed               speed factor (1.0 = normal)
+     * @param guidance_scale      classifier-free guidance scale
+     * @param seed                random seed
+     * @param out_features        output mel features [generated_frames, feat_dim]
+     * @param out_timing          timing breakdown
+     */
+    int Sample(const std::vector<int32_t>& cat_tokens,
+               int prompt_tokens_len,
+               int text_tokens_len,
+               const std::vector<float>& prompt_features,
+               int prompt_features_len,
+               float speed,
+               float guidance_scale,
+               int seed,
+               std::vector<float>& out_features,
+               Timing& out_timing);
+
+    const Config& GetConfig() const { return m_config; }
+    bool HasInit() const { return m_has_init; }
+
+private:
+    Config m_config;
+    bool m_has_init;
+
+    ModelInfo m_encoder_info;
+    std::vector<ModelInfo> m_decoder_parts;
+
+    // Model sessions (one per axmodel)
+    std::map<std::string, std::unique_ptr<EngineWrapper>> m_sessions;
+
+    // Decoder metadata
+    int m_decoder_seq_len;
+    bool m_decoder_has_padding_mask;
+
+    int LoadConfig(const std::string& model_dir);
+    int LoadManifest(const std::string& model_dir);
+    int LoadModels(const std::string& model_dir);
+    int LoadDecoderMetadata();
+
+    std::vector<float> GetTimesteps(int num_step, float t_shift) const;
+
+    int RunDecoderPart(const ModelInfo& part,
+                       std::map<std::string, std::vector<float>>& values,
+                       const std::vector<uint8_t>* padding_mask_data = nullptr,
+                       std::vector<uint8_t>* padding_mask2_out = nullptr);
+
+    static double GetCurrentTimeMs();
+};

cpp/third_party/kissfft/_kiss_fft_guts.h

@@ -0,0 +1,182 @@
+/*Copyright (c) 2003-2004, Mark Borgerding
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+    * 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 SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.*/
+
+#ifndef KISS_FFT_GUTS_H
+#define KISS_FFT_GUTS_H
+
+#define MIN(a,b) ((a)<(b) ? (a):(b))
+#define MAX(a,b) ((a)>(b) ? (a):(b))
+
+/* kiss_fft.h
+   defines kiss_fft_scalar as either short or a float type
+   and defines
+   typedef struct { kiss_fft_scalar r; kiss_fft_scalar i; }kiss_fft_cpx; */
+#include "kiss_fft.h"
+
+/*
+  Explanation of macros dealing with complex math:
+
+   C_MUL(m,a,b)         : m = a*b
+   C_FIXDIV( c , div )  : if a fixed point impl., c /= div. noop otherwise
+   C_SUB( res, a,b)     : res = a - b
+   C_SUBFROM( res , a)  : res -= a
+   C_ADDTO( res , a)    : res += a
+ * */
+#ifdef FIXED_POINT
+#include "arch.h"
+
+
+#define SAMP_MAX 2147483647
+#define TWID_MAX 32767
+#define TRIG_UPSCALE 1
+
+#define SAMP_MIN -SAMP_MAX
+
+
+#   define S_MUL(a,b) MULT16_32_Q15(b, a)
+
+#   define C_MUL(m,a,b) \
+      do{ (m).r = SUB32_ovflw(S_MUL((a).r,(b).r) , S_MUL((a).i,(b).i)); \
+          (m).i = ADD32_ovflw(S_MUL((a).r,(b).i) , S_MUL((a).i,(b).r)); }while(0)
+
+#   define C_MULC(m,a,b) \
+      do{ (m).r = ADD32_ovflw(S_MUL((a).r,(b).r) , S_MUL((a).i,(b).i)); \
+          (m).i = SUB32_ovflw(S_MUL((a).i,(b).r) , S_MUL((a).r,(b).i)); }while(0)
+
+#   define C_MULBYSCALAR( c, s ) \
+      do{ (c).r =  S_MUL( (c).r , s ) ;\
+          (c).i =  S_MUL( (c).i , s ) ; }while(0)
+
+#   define DIVSCALAR(x,k) \
+        (x) = S_MUL(  x, (TWID_MAX-((k)>>1))/(k)+1 )
+
+#   define C_FIXDIV(c,div) \
+        do {    DIVSCALAR( (c).r , div);  \
+                DIVSCALAR( (c).i  , div); }while (0)
+
+#define  C_ADD( res, a,b)\
+    do {(res).r=ADD32_ovflw((a).r,(b).r);  (res).i=ADD32_ovflw((a).i,(b).i); \
+    }while(0)
+#define  C_SUB( res, a,b)\
+    do {(res).r=SUB32_ovflw((a).r,(b).r);  (res).i=SUB32_ovflw((a).i,(b).i); \
+    }while(0)
+#define C_ADDTO( res , a)\
+    do {(res).r = ADD32_ovflw((res).r, (a).r);  (res).i = ADD32_ovflw((res).i,(a).i);\
+    }while(0)
+
+#define C_SUBFROM( res , a)\
+    do {(res).r = ADD32_ovflw((res).r,(a).r);  (res).i = SUB32_ovflw((res).i,(a).i); \
+    }while(0)
+
+#if defined(OPUS_ARM_INLINE_ASM)
+#include "arm/kiss_fft_armv4.h"
+#endif
+
+#if defined(OPUS_ARM_INLINE_EDSP)
+#include "arm/kiss_fft_armv5e.h"
+#endif
+#if defined(MIPSr1_ASM)
+#include "mips/kiss_fft_mipsr1.h"
+#endif
+
+#else  /* not FIXED_POINT*/
+
+#   define S_MUL(a,b) ( (a)*(b) )
+#define C_MUL(m,a,b) \
+    do{ (m).r = (a).r*(b).r - (a).i*(b).i;\
+        (m).i = (a).r*(b).i + (a).i*(b).r; }while(0)
+#define C_MULC(m,a,b) \
+    do{ (m).r = (a).r*(b).r + (a).i*(b).i;\
+        (m).i = (a).i*(b).r - (a).r*(b).i; }while(0)
+
+#define C_MUL4(m,a,b) C_MUL(m,a,b)
+
+#   define C_FIXDIV(c,div) /* NOOP */
+#   define C_MULBYSCALAR( c, s ) \
+    do{ (c).r *= (s);\
+        (c).i *= (s); }while(0)
+#endif
+
+#ifndef CHECK_OVERFLOW_OP
+#  define CHECK_OVERFLOW_OP(a,op,b) /* noop */
+#endif
+
+#ifndef C_ADD
+#define  C_ADD( res, a,b)\
+    do { \
+            CHECK_OVERFLOW_OP((a).r,+,(b).r)\
+            CHECK_OVERFLOW_OP((a).i,+,(b).i)\
+            (res).r=(a).r+(b).r;  (res).i=(a).i+(b).i; \
+    }while(0)
+#define  C_SUB( res, a,b)\
+    do { \
+            CHECK_OVERFLOW_OP((a).r,-,(b).r)\
+            CHECK_OVERFLOW_OP((a).i,-,(b).i)\
+            (res).r=(a).r-(b).r;  (res).i=(a).i-(b).i; \
+    }while(0)
+#define C_ADDTO( res , a)\
+    do { \
+            CHECK_OVERFLOW_OP((res).r,+,(a).r)\
+            CHECK_OVERFLOW_OP((res).i,+,(a).i)\
+            (res).r += (a).r;  (res).i += (a).i;\
+    }while(0)
+
+#define C_SUBFROM( res , a)\
+    do {\
+            CHECK_OVERFLOW_OP((res).r,-,(a).r)\
+            CHECK_OVERFLOW_OP((res).i,-,(a).i)\
+            (res).r -= (a).r;  (res).i -= (a).i; \
+    }while(0)
+#endif /* C_ADD defined */
+
+#ifdef FIXED_POINT
+/*#  define KISS_FFT_COS(phase)  TRIG_UPSCALE*floor(MIN(32767,MAX(-32767,.5+32768 * cos (phase))))
+#  define KISS_FFT_SIN(phase)  TRIG_UPSCALE*floor(MIN(32767,MAX(-32767,.5+32768 * sin (phase))))*/
+#  define KISS_FFT_COS(phase)  floor(.5+TWID_MAX*cos (phase))
+#  define KISS_FFT_SIN(phase)  floor(.5+TWID_MAX*sin (phase))
+#  define HALF_OF(x) ((x)>>1)
+#elif defined(USE_SIMD)
+#  define KISS_FFT_COS(phase) _mm_set1_ps( cos(phase) )
+#  define KISS_FFT_SIN(phase) _mm_set1_ps( sin(phase) )
+#  define HALF_OF(x) ((x)*_mm_set1_ps(.5f))
+#else
+#  define KISS_FFT_COS(phase) (kiss_fft_scalar) cos(phase)
+#  define KISS_FFT_SIN(phase) (kiss_fft_scalar) sin(phase)
+#  define HALF_OF(x) ((x)*.5f)
+#endif
+
+#define  kf_cexp(x,phase) \
+        do{ \
+                (x)->r = KISS_FFT_COS(phase);\
+                (x)->i = KISS_FFT_SIN(phase);\
+        }while(0)
+
+#define  kf_cexp2(x,phase) \
+   do{ \
+      (x)->r = TRIG_UPSCALE*celt_cos_norm((phase));\
+      (x)->i = TRIG_UPSCALE*celt_cos_norm((phase)-32768);\
+}while(0)
+
+#endif /* KISS_FFT_GUTS_H */

cpp/third_party/kissfft/arch.h

@@ -0,0 +1,261 @@
+/* Copyright (c) 2003-2008 Jean-Marc Valin
+   Copyright (c) 2007-2008 CSIRO
+   Copyright (c) 2007-2009 Xiph.Org Foundation
+   Written by Jean-Marc Valin */
+/**
+   @file arch.h
+   @brief Various architecture definitions for CELT
+*/
+/*
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - 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 SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS 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 THE COPYRIGHT OWNER
+   OR CONTRIBUTORS 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.
+*/
+
+#ifndef ARCH_H
+#define ARCH_H
+
+#include "opus_types.h"
+#include "common.h"
+
+# if !defined(__GNUC_PREREQ)
+#  if defined(__GNUC__)&&defined(__GNUC_MINOR__)
+#   define __GNUC_PREREQ(_maj,_min) \
+ ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
+#  else
+#   define __GNUC_PREREQ(_maj,_min) 0
+#  endif
+# endif
+
+#define CELT_SIG_SCALE 32768.f
+
+#define celt_fatal(str) _celt_fatal(str, __FILE__, __LINE__);
+#ifdef ENABLE_ASSERTIONS
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __GNUC__
+__attribute__((noreturn))
+#endif
+static OPUS_INLINE void _celt_fatal(const char *str, const char *file, int line)
+{
+   fprintf (stderr, "Fatal (internal) error in %s, line %d: %s\n", file, line, str);
+   abort();
+}
+#define celt_assert(cond) {if (!(cond)) {celt_fatal("assertion failed: " #cond);}}
+#define celt_assert2(cond, message) {if (!(cond)) {celt_fatal("assertion failed: " #cond "\n" message);}}
+#else
+#define celt_assert(cond)
+#define celt_assert2(cond, message)
+#endif
+
+#define IMUL32(a,b) ((a)*(b))
+
+#define MIN16(a,b) ((a) < (b) ? (a) : (b))   /**< Minimum 16-bit value.   */
+#define MAX16(a,b) ((a) > (b) ? (a) : (b))   /**< Maximum 16-bit value.   */
+#define MIN32(a,b) ((a) < (b) ? (a) : (b))   /**< Minimum 32-bit value.   */
+#define MAX32(a,b) ((a) > (b) ? (a) : (b))   /**< Maximum 32-bit value.   */
+#define IMIN(a,b) ((a) < (b) ? (a) : (b))   /**< Minimum int value.   */
+#define IMAX(a,b) ((a) > (b) ? (a) : (b))   /**< Maximum int value.   */
+#define UADD32(a,b) ((a)+(b))
+#define USUB32(a,b) ((a)-(b))
+
+/* Set this if opus_int64 is a native type of the CPU. */
+/* Assume that all LP64 architectures have fast 64-bit types; also x86_64
+   (which can be ILP32 for x32) and Win64 (which is LLP64). */
+#if defined(__x86_64__) || defined(__LP64__) || defined(_WIN64)
+#define OPUS_FAST_INT64 1
+#else
+#define OPUS_FAST_INT64 0
+#endif
+
+#define PRINT_MIPS(file)
+
+#ifdef FIXED_POINT
+
+typedef opus_int16 opus_val16;
+typedef opus_int32 opus_val32;
+typedef opus_int64 opus_val64;
+
+typedef opus_val32 celt_sig;
+typedef opus_val16 celt_norm;
+typedef opus_val32 celt_ener;
+
+#define Q15ONE 32767
+
+#define SIG_SHIFT 12
+/* Safe saturation value for 32-bit signals. Should be less than
+   2^31*(1-0.85) to avoid blowing up on DC at deemphasis.*/
+#define SIG_SAT (300000000)
+
+#define NORM_SCALING 16384
+
+#define DB_SHIFT 10
+
+#define EPSILON 1
+#define VERY_SMALL 0
+#define VERY_LARGE16 ((opus_val16)32767)
+#define Q15_ONE ((opus_val16)32767)
+
+#define SCALEIN(a)      (a)
+#define SCALEOUT(a)     (a)
+
+#define ABS16(x) ((x) < 0 ? (-(x)) : (x))
+#define ABS32(x) ((x) < 0 ? (-(x)) : (x))
+
+static OPUS_INLINE opus_int16 SAT16(opus_int32 x) {
+   return x > 32767 ? 32767 : x < -32768 ? -32768 : (opus_int16)x;
+}
+
+#ifdef FIXED_DEBUG
+#include "fixed_debug.h"
+#else
+
+#include "fixed_generic.h"
+
+#ifdef OPUS_ARM_PRESUME_AARCH64_NEON_INTR
+#include "arm/fixed_arm64.h"
+#elif OPUS_ARM_INLINE_EDSP
+#include "arm/fixed_armv5e.h"
+#elif defined (OPUS_ARM_INLINE_ASM)
+#include "arm/fixed_armv4.h"
+#elif defined (BFIN_ASM)
+#include "fixed_bfin.h"
+#elif defined (TI_C5X_ASM)
+#include "fixed_c5x.h"
+#elif defined (TI_C6X_ASM)
+#include "fixed_c6x.h"
+#endif
+
+#endif
+
+#else /* FIXED_POINT */
+
+typedef float opus_val16;
+typedef float opus_val32;
+typedef float opus_val64;
+
+typedef float celt_sig;
+typedef float celt_norm;
+typedef float celt_ener;
+
+#ifdef FLOAT_APPROX
+/* This code should reliably detect NaN/inf even when -ffast-math is used.
+   Assumes IEEE 754 format. */
+static OPUS_INLINE int celt_isnan(float x)
+{
+   union {float f; opus_uint32 i;} in;
+   in.f = x;
+   return ((in.i>>23)&0xFF)==0xFF && (in.i&0x007FFFFF)!=0;
+}
+#else
+#ifdef __FAST_MATH__
+#error Cannot build libopus with -ffast-math unless FLOAT_APPROX is defined. This could result in crashes on extreme (e.g. NaN) input
+#endif
+#define celt_isnan(x) ((x)!=(x))
+#endif
+
+#define Q15ONE 1.0f
+
+#define NORM_SCALING 1.f
+
+#define EPSILON 1e-15f
+#define VERY_SMALL 1e-30f
+#define VERY_LARGE16 1e15f
+#define Q15_ONE ((opus_val16)1.f)
+
+/* This appears to be the same speed as C99's fabsf() but it's more portable. */
+#define ABS16(x) ((float)fabs(x))
+#define ABS32(x) ((float)fabs(x))
+
+#define QCONST16(x,bits) (x)
+#define QCONST32(x,bits) (x)
+
+#define NEG16(x) (-(x))
+#define NEG32(x) (-(x))
+#define NEG32_ovflw(x) (-(x))
+#define EXTRACT16(x) (x)
+#define EXTEND32(x) (x)
+#define SHR16(a,shift) (a)
+#define SHL16(a,shift) (a)
+#define SHR32(a,shift) (a)
+#define SHL32(a,shift) (a)
+#define PSHR32(a,shift) (a)
+#define VSHR32(a,shift) (a)
+
+#define PSHR(a,shift)   (a)
+#define SHR(a,shift)    (a)
+#define SHL(a,shift)    (a)
+#define SATURATE(x,a)   (x)
+#define SATURATE16(x)   (x)
+
+#define ROUND16(a,shift)  (a)
+#define SROUND16(a,shift) (a)
+#define HALF16(x)       (.5f*(x))
+#define HALF32(x)       (.5f*(x))
+
+#define ADD16(a,b) ((a)+(b))
+#define SUB16(a,b) ((a)-(b))
+#define ADD32(a,b) ((a)+(b))
+#define SUB32(a,b) ((a)-(b))
+#define ADD32_ovflw(a,b) ((a)+(b))
+#define SUB32_ovflw(a,b) ((a)-(b))
+#define MULT16_16_16(a,b)     ((a)*(b))
+#define MULT16_16(a,b)     ((opus_val32)(a)*(opus_val32)(b))
+#define MAC16_16(c,a,b)     ((c)+(opus_val32)(a)*(opus_val32)(b))
+
+#define MULT16_32_Q15(a,b)     ((a)*(b))
+#define MULT16_32_Q16(a,b)     ((a)*(b))
+
+#define MULT32_32_Q31(a,b)     ((a)*(b))
+
+#define MAC16_32_Q15(c,a,b)     ((c)+(a)*(b))
+#define MAC16_32_Q16(c,a,b)     ((c)+(a)*(b))
+
+#define MULT16_16_Q11_32(a,b)     ((a)*(b))
+#define MULT16_16_Q11(a,b)     ((a)*(b))
+#define MULT16_16_Q13(a,b)     ((a)*(b))
+#define MULT16_16_Q14(a,b)     ((a)*(b))
+#define MULT16_16_Q15(a,b)     ((a)*(b))
+#define MULT16_16_P15(a,b)     ((a)*(b))
+#define MULT16_16_P13(a,b)     ((a)*(b))
+#define MULT16_16_P14(a,b)     ((a)*(b))
+#define MULT16_32_P16(a,b)     ((a)*(b))
+
+#define DIV32_16(a,b)     (((opus_val32)(a))/(opus_val16)(b))
+#define DIV32(a,b)     (((opus_val32)(a))/(opus_val32)(b))
+
+#define SCALEIN(a)      ((a)*CELT_SIG_SCALE)
+#define SCALEOUT(a)     ((a)*(1/CELT_SIG_SCALE))
+
+#define SIG2WORD16(x) (x)
+
+#endif /* !FIXED_POINT */
+
+#ifndef GLOBAL_STACK_SIZE
+#ifdef FIXED_POINT
+#define GLOBAL_STACK_SIZE 120000
+#else
+#define GLOBAL_STACK_SIZE 120000
+#endif
+#endif
+
+#endif /* ARCH_H */

cpp/third_party/kissfft/common.h

@@ -0,0 +1,56 @@
+
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include "stdlib.h"
+#include "string.h"
+
+#define RNN_INLINE inline
+#define OPUS_INLINE inline
+
+
+/** RNNoise wrapper for malloc(). To do your own dynamic allocation, all you need t
+o do is replace this function and rnnoise_free */
+#ifndef OVERRIDE_RNNOISE_ALLOC
+static RNN_INLINE void *rnnoise_alloc (size_t size)
+{
+   return malloc(size);
+}
+#endif
+
+/** RNNoise wrapper for free(). To do your own dynamic allocation, all you need to do is replace this function and rnnoise_alloc */
+#ifndef OVERRIDE_RNNOISE_FREE
+static RNN_INLINE void rnnoise_free (void *ptr)
+{
+   free(ptr);
+}
+#endif
+
+/** Copy n elements from src to dst. The 0* term provides compile-time type checking  */
+#ifndef OVERRIDE_RNN_COPY
+#define RNN_COPY(dst, src, n) (memcpy((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))
+#endif
+
+/** Copy n elements from src to dst, allowing overlapping regions. The 0* term
+    provides compile-time type checking */
+#ifndef OVERRIDE_RNN_MOVE
+#define RNN_MOVE(dst, src, n) (memmove((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))
+#endif
+
+/** Set n elements of dst to zero */
+#ifndef OVERRIDE_RNN_CLEAR
+#define RNN_CLEAR(dst, n) (memset((dst), 0, (n)*sizeof(*(dst))))
+#endif
+
+# if !defined(OPUS_GNUC_PREREQ)
+#  if defined(__GNUC__)&&defined(__GNUC_MINOR__)
+#   define OPUS_GNUC_PREREQ(_maj,_min) \
+ ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
+#  else
+#   define OPUS_GNUC_PREREQ(_maj,_min) 0
+#  endif
+# endif
+
+
+#endif

cpp/third_party/kissfft/kiss_fft.c

@@ -0,0 +1,601 @@
+/*Copyright (c) 2003-2004, Mark Borgerding
+  Lots of modifications by Jean-Marc Valin
+  Copyright (c) 2005-2007, Xiph.Org Foundation
+  Copyright (c) 2008,      Xiph.Org Foundation, CSIRO
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+    * 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 SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.*/
+
+/* This code is originally from Mark Borgerding's KISS-FFT but has been
+   heavily modified to better suit Opus */
+
+#ifndef SKIP_CONFIG_H
+#  ifdef HAVE_CONFIG_H
+#    include "config.h"
+#  endif
+#endif
+
+#include "_kiss_fft_guts.h"
+#define CUSTOM_MODES
+
+/* The guts header contains all the multiplication and addition macros that are defined for
+   complex numbers.  It also declares the kf_ internal functions.
+*/
+
+static void kf_bfly2(
+                     kiss_fft_cpx * Fout,
+                     int m,
+                     int N
+                    )
+{
+   kiss_fft_cpx * Fout2;
+   int i;
+   (void)m;
+#ifdef CUSTOM_MODES
+   if (m==1)
+   {
+      celt_assert(m==1);
+      for (i=0;i<N;i++)
+      {
+         kiss_fft_cpx t;
+         Fout2 = Fout + 1;
+         t = *Fout2;
+         C_SUB( *Fout2 ,  *Fout , t );
+         C_ADDTO( *Fout ,  t );
+         Fout += 2;
+      }
+   } else
+#endif
+   {
+      opus_val16 tw;
+      tw = QCONST16(0.7071067812f, 15);
+      /* We know that m==4 here because the radix-2 is just after a radix-4 */
+      celt_assert(m==4);
+      for (i=0;i<N;i++)
+      {
+         kiss_fft_cpx t;
+         Fout2 = Fout + 4;
+         t = Fout2[0];
+         C_SUB( Fout2[0] ,  Fout[0] , t );
+         C_ADDTO( Fout[0] ,  t );
+
+         t.r = S_MUL(ADD32_ovflw(Fout2[1].r, Fout2[1].i), tw);
+         t.i = S_MUL(SUB32_ovflw(Fout2[1].i, Fout2[1].r), tw);
+         C_SUB( Fout2[1] ,  Fout[1] , t );
+         C_ADDTO( Fout[1] ,  t );
+
+         t.r = Fout2[2].i;
+         t.i = -Fout2[2].r;
+         C_SUB( Fout2[2] ,  Fout[2] , t );
+         C_ADDTO( Fout[2] ,  t );
+
+         t.r = S_MUL(SUB32_ovflw(Fout2[3].i, Fout2[3].r), tw);
+         t.i = S_MUL(NEG32_ovflw(ADD32_ovflw(Fout2[3].i, Fout2[3].r)), tw);
+         C_SUB( Fout2[3] ,  Fout[3] , t );
+         C_ADDTO( Fout[3] ,  t );
+         Fout += 8;
+      }
+   }
+}
+
+static void kf_bfly4(
+                     kiss_fft_cpx * Fout,
+                     const size_t fstride,
+                     const kiss_fft_state *st,
+                     int m,
+                     int N,
+                     int mm
+                    )
+{
+   int i;
+
+   if (m==1)
+   {
+      /* Degenerate case where all the twiddles are 1. */
+      for (i=0;i<N;i++)
+      {
+         kiss_fft_cpx scratch0, scratch1;
+
+         C_SUB( scratch0 , *Fout, Fout[2] );
+         C_ADDTO(*Fout, Fout[2]);
+         C_ADD( scratch1 , Fout[1] , Fout[3] );
+         C_SUB( Fout[2], *Fout, scratch1 );
+         C_ADDTO( *Fout , scratch1 );
+         C_SUB( scratch1 , Fout[1] , Fout[3] );
+
+         Fout[1].r = ADD32_ovflw(scratch0.r, scratch1.i);
+         Fout[1].i = SUB32_ovflw(scratch0.i, scratch1.r);
+         Fout[3].r = SUB32_ovflw(scratch0.r, scratch1.i);
+         Fout[3].i = ADD32_ovflw(scratch0.i, scratch1.r);
+         Fout+=4;
+      }
+   } else {
+      int j;
+      kiss_fft_cpx scratch[6];
+      const kiss_twiddle_cpx *tw1,*tw2,*tw3;
+      const int m2=2*m;
+      const int m3=3*m;
+      kiss_fft_cpx * Fout_beg = Fout;
+      for (i=0;i<N;i++)
+      {
+         Fout = Fout_beg + i*mm;
+         tw3 = tw2 = tw1 = st->twiddles;
+         /* m is guaranteed to be a multiple of 4. */
+         for (j=0;j<m;j++)
+         {
+            C_MUL(scratch[0],Fout[m] , *tw1 );
+            C_MUL(scratch[1],Fout[m2] , *tw2 );
+            C_MUL(scratch[2],Fout[m3] , *tw3 );
+
+            C_SUB( scratch[5] , *Fout, scratch[1] );
+            C_ADDTO(*Fout, scratch[1]);
+            C_ADD( scratch[3] , scratch[0] , scratch[2] );
+            C_SUB( scratch[4] , scratch[0] , scratch[2] );
+            C_SUB( Fout[m2], *Fout, scratch[3] );
+            tw1 += fstride;
+            tw2 += fstride*2;
+            tw3 += fstride*3;
+            C_ADDTO( *Fout , scratch[3] );
+
+            Fout[m].r = ADD32_ovflw(scratch[5].r, scratch[4].i);
+            Fout[m].i = SUB32_ovflw(scratch[5].i, scratch[4].r);
+            Fout[m3].r = SUB32_ovflw(scratch[5].r, scratch[4].i);
+            Fout[m3].i = ADD32_ovflw(scratch[5].i, scratch[4].r);
+            ++Fout;
+         }
+      }
+   }
+}
+
+
+#ifndef RADIX_TWO_ONLY
+
+static void kf_bfly3(
+                     kiss_fft_cpx * Fout,
+                     const size_t fstride,
+                     const kiss_fft_state *st,
+                     int m,
+                     int N,
+                     int mm
+                    )
+{
+   int i;
+   size_t k;
+   const size_t m2 = 2*m;
+   const kiss_twiddle_cpx *tw1,*tw2;
+   kiss_fft_cpx scratch[5];
+   kiss_twiddle_cpx epi3;
+
+   kiss_fft_cpx * Fout_beg = Fout;
+#ifdef FIXED_POINT
+   /*epi3.r = -16384;*/ /* Unused */
+   epi3.i = -28378;
+#else
+   epi3 = st->twiddles[fstride*m];
+#endif
+   for (i=0;i<N;i++)
+   {
+      Fout = Fout_beg + i*mm;
+      tw1=tw2=st->twiddles;
+      /* For non-custom modes, m is guaranteed to be a multiple of 4. */
+      k=m;
+      do {
+
+         C_MUL(scratch[1],Fout[m] , *tw1);
+         C_MUL(scratch[2],Fout[m2] , *tw2);
+
+         C_ADD(scratch[3],scratch[1],scratch[2]);
+         C_SUB(scratch[0],scratch[1],scratch[2]);
+         tw1 += fstride;
+         tw2 += fstride*2;
+
+         Fout[m].r = SUB32_ovflw(Fout->r, HALF_OF(scratch[3].r));
+         Fout[m].i = SUB32_ovflw(Fout->i, HALF_OF(scratch[3].i));
+
+         C_MULBYSCALAR( scratch[0] , epi3.i );
+
+         C_ADDTO(*Fout,scratch[3]);
+
+         Fout[m2].r = ADD32_ovflw(Fout[m].r, scratch[0].i);
+         Fout[m2].i = SUB32_ovflw(Fout[m].i, scratch[0].r);
+
+         Fout[m].r = SUB32_ovflw(Fout[m].r, scratch[0].i);
+         Fout[m].i = ADD32_ovflw(Fout[m].i, scratch[0].r);
+
+         ++Fout;
+      } while(--k);
+   }
+}
+
+
+#ifndef OVERRIDE_kf_bfly5
+static void kf_bfly5(
+                     kiss_fft_cpx * Fout,
+                     const size_t fstride,
+                     const kiss_fft_state *st,
+                     int m,
+                     int N,
+                     int mm
+                    )
+{
+   kiss_fft_cpx *Fout0,*Fout1,*Fout2,*Fout3,*Fout4;
+   int i, u;
+   kiss_fft_cpx scratch[13];
+   const kiss_twiddle_cpx *tw;
+   kiss_twiddle_cpx ya,yb;
+   kiss_fft_cpx * Fout_beg = Fout;
+
+#ifdef FIXED_POINT
+   ya.r = 10126;
+   ya.i = -31164;
+   yb.r = -26510;
+   yb.i = -19261;
+#else
+   ya = st->twiddles[fstride*m];
+   yb = st->twiddles[fstride*2*m];
+#endif
+   tw=st->twiddles;
+
+   for (i=0;i<N;i++)
+   {
+      Fout = Fout_beg + i*mm;
+      Fout0=Fout;
+      Fout1=Fout0+m;
+      Fout2=Fout0+2*m;
+      Fout3=Fout0+3*m;
+      Fout4=Fout0+4*m;
+
+      /* For non-custom modes, m is guaranteed to be a multiple of 4. */
+      for ( u=0; u<m; ++u ) {
+         scratch[0] = *Fout0;
+
+         C_MUL(scratch[1] ,*Fout1, tw[u*fstride]);
+         C_MUL(scratch[2] ,*Fout2, tw[2*u*fstride]);
+         C_MUL(scratch[3] ,*Fout3, tw[3*u*fstride]);
+         C_MUL(scratch[4] ,*Fout4, tw[4*u*fstride]);
+
+         C_ADD( scratch[7],scratch[1],scratch[4]);
+         C_SUB( scratch[10],scratch[1],scratch[4]);
+         C_ADD( scratch[8],scratch[2],scratch[3]);
+         C_SUB( scratch[9],scratch[2],scratch[3]);
+
+         Fout0->r = ADD32_ovflw(Fout0->r, ADD32_ovflw(scratch[7].r, scratch[8].r));
+         Fout0->i = ADD32_ovflw(Fout0->i, ADD32_ovflw(scratch[7].i, scratch[8].i));
+
+         scratch[5].r = ADD32_ovflw(scratch[0].r, ADD32_ovflw(S_MUL(scratch[7].r,ya.r), S_MUL(scratch[8].r,yb.r)));
+         scratch[5].i = ADD32_ovflw(scratch[0].i, ADD32_ovflw(S_MUL(scratch[7].i,ya.r), S_MUL(scratch[8].i,yb.r)));
+
+         scratch[6].r =  ADD32_ovflw(S_MUL(scratch[10].i,ya.i), S_MUL(scratch[9].i,yb.i));
+         scratch[6].i = NEG32_ovflw(ADD32_ovflw(S_MUL(scratch[10].r,ya.i), S_MUL(scratch[9].r,yb.i)));
+
+         C_SUB(*Fout1,scratch[5],scratch[6]);
+         C_ADD(*Fout4,scratch[5],scratch[6]);
+
+         scratch[11].r = ADD32_ovflw(scratch[0].r, ADD32_ovflw(S_MUL(scratch[7].r,yb.r), S_MUL(scratch[8].r,ya.r)));
+         scratch[11].i = ADD32_ovflw(scratch[0].i, ADD32_ovflw(S_MUL(scratch[7].i,yb.r), S_MUL(scratch[8].i,ya.r)));
+         scratch[12].r = SUB32_ovflw(S_MUL(scratch[9].i,ya.i), S_MUL(scratch[10].i,yb.i));
+         scratch[12].i = SUB32_ovflw(S_MUL(scratch[10].r,yb.i), S_MUL(scratch[9].r,ya.i));
+
+         C_ADD(*Fout2,scratch[11],scratch[12]);
+         C_SUB(*Fout3,scratch[11],scratch[12]);
+
+         ++Fout0;++Fout1;++Fout2;++Fout3;++Fout4;
+      }
+   }
+}
+#endif /* OVERRIDE_kf_bfly5 */
+
+
+#endif
+
+
+#ifdef CUSTOM_MODES
+
+static
+void compute_bitrev_table(
+         int Fout,
+         opus_int32 *f,
+         const size_t fstride,
+         int in_stride,
+         opus_int16 * factors,
+         const kiss_fft_state *st
+            )
+{
+   const int p=*factors++; /* the radix  */
+   const int m=*factors++; /* stage's fft length/p */
+
+    /*printf ("fft %d %d %d %d %d %d\n", p*m, m, p, s2, fstride*in_stride, N);*/
+   if (m==1)
+   {
+      int j;
+      for (j=0;j<p;j++)
+      {
+         *f = Fout+j;
+         f += fstride*in_stride;
+      }
+   } else {
+      int j;
+      for (j=0;j<p;j++)
+      {
+         compute_bitrev_table( Fout , f, fstride*p, in_stride, factors,st);
+         f += fstride*in_stride;
+         Fout += m;
+      }
+   }
+}
+
+/*  facbuf is populated by p1,m1,p2,m2, ...
+    where
+    p[i] * m[i] = m[i-1]
+    m0 = n                  */
+static
+int kf_factor(int n,opus_int16 * facbuf)
+{
+    int p=4;
+    int i;
+    int stages=0;
+    int nbak = n;
+
+    /*factor out powers of 4, powers of 2, then any remaining primes */
+    do {
+        while (n % p) {
+            switch (p) {
+                case 4: p = 2; break;
+                case 2: p = 3; break;
+                default: p += 2; break;
+            }
+            if (p>32000 || (opus_int32)p*(opus_int32)p > n)
+                p = n;          /* no more factors, skip to end */
+        }
+        n /= p;
+#ifdef RADIX_TWO_ONLY
+        if (p!=2 && p != 4)
+#else
+        if (p>5)
+#endif
+        {
+           return 0;
+        }
+        facbuf[2*stages] = p;
+        if (p==2 && stages > 1)
+        {
+           facbuf[2*stages] = 4;
+           facbuf[2] = 2;
+        }
+        stages++;
+    } while (n > 1);
+    n = nbak;
+    /* Reverse the order to get the radix 4 at the end, so we can use the
+       fast degenerate case. It turns out that reversing the order also
+       improves the noise behaviour. */
+    for (i=0;i<stages/2;i++)
+    {
+       int tmp;
+       tmp = facbuf[2*i];
+       facbuf[2*i] = facbuf[2*(stages-i-1)];
+       facbuf[2*(stages-i-1)] = tmp;
+    }
+    for (i=0;i<stages;i++)
+    {
+        n /= facbuf[2*i];
+        facbuf[2*i+1] = n;
+    }
+    return 1;
+}
+
+static void compute_twiddles(kiss_twiddle_cpx *twiddles, int nfft)
+{
+   int i;
+#ifdef FIXED_POINT
+   for (i=0;i<nfft;++i) {
+      opus_val32 phase = -i;
+      kf_cexp2(twiddles+i, DIV32(SHL32(phase,17),nfft));
+   }
+#else
+   for (i=0;i<nfft;++i) {
+      const double pi=3.14159265358979323846264338327;
+      double phase = ( -2*pi /nfft ) * i;
+      kf_cexp(twiddles+i, phase );
+   }
+#endif
+}
+
+int rnn_fft_alloc_arch_c(kiss_fft_state *st) {
+   (void)st;
+   return 0;
+}
+
+/*
+ *
+ * Allocates all necessary storage space for the fft and ifft.
+ * The return value is a contiguous block of memory.  As such,
+ * It can be freed with free().
+ * */
+kiss_fft_state *rnn_fft_alloc_twiddles(int nfft,void * mem,size_t * lenmem,
+                                        const kiss_fft_state *base, int arch)
+{
+    kiss_fft_state *st=NULL;
+    size_t memneeded = sizeof(struct kiss_fft_state); /* twiddle factors*/
+
+    if ( lenmem==NULL ) {
+        st = ( kiss_fft_state*)KISS_FFT_MALLOC( memneeded );
+    }else{
+        if (mem != NULL && *lenmem >= memneeded)
+            st = (kiss_fft_state*)mem;
+        *lenmem = memneeded;
+    }
+    if (st) {
+        opus_int32 *bitrev;
+        kiss_twiddle_cpx *twiddles;
+
+        st->nfft=nfft;
+#ifdef FIXED_POINT
+        st->scale_shift = celt_ilog2(st->nfft);
+        if (st->nfft == 1<<st->scale_shift)
+           st->scale = Q15ONE;
+        else
+           st->scale = (1073741824+st->nfft/2)/st->nfft>>(15-st->scale_shift);
+#else
+        st->scale = 1.f/nfft;
+#endif
+        if (base != NULL)
+        {
+           st->twiddles = base->twiddles;
+           st->shift = 0;
+           while (st->shift < 32 && nfft<<st->shift != base->nfft)
+              st->shift++;
+           if (st->shift>=32)
+              goto fail;
+        } else {
+           st->twiddles = twiddles = (kiss_twiddle_cpx*)KISS_FFT_MALLOC(sizeof(kiss_twiddle_cpx)*nfft);
+           compute_twiddles(twiddles, nfft);
+           st->shift = -1;
+        }
+        if (!kf_factor(nfft,st->factors))
+        {
+           goto fail;
+        }
+
+        /* bitrev */
+        st->bitrev = bitrev = (opus_int32*)KISS_FFT_MALLOC(sizeof(opus_int32)*nfft);
+        if (st->bitrev==NULL)
+            goto fail;
+        compute_bitrev_table(0, bitrev, 1,1, st->factors,st);
+
+        /* Initialize architecture specific fft parameters */
+        if (rnn_fft_alloc_arch(st, arch))
+            goto fail;
+    }
+    return st;
+fail:
+    rnn_fft_free(st, arch);
+    return NULL;
+}
+
+kiss_fft_state *rnn_fft_alloc(int nfft,void * mem,size_t * lenmem, int arch)
+{
+   return rnn_fft_alloc_twiddles(nfft, mem, lenmem, NULL, arch);
+}
+
+void rnn_fft_free_arch_c(kiss_fft_state *st) {
+   (void)st;
+}
+
+void rnn_fft_free(const kiss_fft_state *cfg, int arch)
+{
+   if (cfg)
+   {
+      rnn_fft_free_arch((kiss_fft_state *)cfg, arch);
+      opus_free((opus_int32*)cfg->bitrev);
+      if (cfg->shift < 0)
+         opus_free((kiss_twiddle_cpx*)cfg->twiddles);
+      opus_free((kiss_fft_state*)cfg);
+   }
+}
+
+#endif /* CUSTOM_MODES */
+
+void rnn_fft_impl(const kiss_fft_state *st,kiss_fft_cpx *fout)
+{
+    int m2, m;
+    int p;
+    int L;
+    int fstride[MAXFACTORS];
+    int i;
+    int shift;
+
+    /* st->shift can be -1 */
+    shift = st->shift>0 ? st->shift : 0;
+
+    fstride[0] = 1;
+    L=0;
+    do {
+       p = st->factors[2*L];
+       m = st->factors[2*L+1];
+       fstride[L+1] = fstride[L]*p;
+       L++;
+    } while(m!=1);
+    m = st->factors[2*L-1];
+    for (i=L-1;i>=0;i--)
+    {
+       if (i!=0)
+          m2 = st->factors[2*i-1];
+       else
+          m2 = 1;
+       switch (st->factors[2*i])
+       {
+       case 2:
+          kf_bfly2(fout, m, fstride[i]);
+          break;
+       case 4:
+          kf_bfly4(fout,fstride[i]<<shift,st,m, fstride[i], m2);
+          break;
+ #ifndef RADIX_TWO_ONLY
+       case 3:
+          kf_bfly3(fout,fstride[i]<<shift,st,m, fstride[i], m2);
+          break;
+       case 5:
+          kf_bfly5(fout,fstride[i]<<shift,st,m, fstride[i], m2);
+          break;
+ #endif
+       }
+       m = m2;
+    }
+}
+
+void rnn_fft_c(const kiss_fft_state *st,const kiss_fft_cpx *fin,kiss_fft_cpx *fout)
+{
+   int i;
+   opus_val16 scale;
+#ifdef FIXED_POINT
+   /* Allows us to scale with MULT16_32_Q16(), which is faster than
+      MULT16_32_Q15() on ARM. */
+   int scale_shift = st->scale_shift-1;
+#endif
+   scale = st->scale;
+
+   celt_assert2 (fin != fout, "In-place FFT not supported");
+   /* Bit-reverse the input */
+   for (i=0;i<st->nfft;i++)
+   {
+      kiss_fft_cpx x = fin[i];
+      fout[st->bitrev[i]].r = SHR32(MULT16_32_Q16(scale, x.r), scale_shift);
+      fout[st->bitrev[i]].i = SHR32(MULT16_32_Q16(scale, x.i), scale_shift);
+   }
+   rnn_fft_impl(st, fout);
+}
+
+
+void rnn_ifft_c(const kiss_fft_state *st,const kiss_fft_cpx *fin,kiss_fft_cpx *fout)
+{
+   int i;
+   celt_assert2 (fin != fout, "In-place FFT not supported");
+   /* Bit-reverse the input */
+   for (i=0;i<st->nfft;i++)
+      fout[st->bitrev[i]] = fin[i];
+   for (i=0;i<st->nfft;i++)
+      fout[i].i = -fout[i].i;
+   rnn_fft_impl(st, fout);
+   for (i=0;i<st->nfft;i++)
+      fout[i].i = -fout[i].i;
+}

cpp/third_party/kissfft/kiss_fft.h

@@ -0,0 +1,203 @@
+/*Copyright (c) 2003-2004, Mark Borgerding
+  Lots of modifications by Jean-Marc Valin
+  Copyright (c) 2005-2007, Xiph.Org Foundation
+  Copyright (c) 2008,      Xiph.Org Foundation, CSIRO
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+    * 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 SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.*/
+
+#ifndef KISS_FFT_H
+#define KISS_FFT_H
+
+#include <stdlib.h>
+#include <math.h>
+#include "arch.h"
+
+#include <stdlib.h>
+#define opus_alloc(x) malloc(x)
+#define opus_free(x) free(x)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef USE_SIMD
+# include <xmmintrin.h>
+# define kiss_fft_scalar __m128
+#define KISS_FFT_MALLOC(nbytes) memalign(16,nbytes)
+#else
+#define KISS_FFT_MALLOC opus_alloc
+#endif
+
+#ifdef FIXED_POINT
+#include "arch.h"
+
+#  define kiss_fft_scalar opus_int32
+#  define kiss_twiddle_scalar opus_int16
+
+
+#else
+# ifndef kiss_fft_scalar
+/*  default is float */
+#   define kiss_fft_scalar float
+#   define kiss_twiddle_scalar float
+#   define KF_SUFFIX _celt_single
+# endif
+#endif
+
+typedef struct {
+    kiss_fft_scalar r;
+    kiss_fft_scalar i;
+}kiss_fft_cpx;
+
+typedef struct {
+   kiss_twiddle_scalar r;
+   kiss_twiddle_scalar i;
+}kiss_twiddle_cpx;
+
+#define MAXFACTORS 8
+/* e.g. an fft of length 128 has 4 factors
+ as far as kissfft is concerned
+ 4*4*4*2
+ */
+
+typedef struct arch_fft_state{
+   int is_supported;
+   void *priv;
+} arch_fft_state;
+
+typedef struct kiss_fft_state{
+    int nfft;
+    opus_val16 scale;
+#ifdef FIXED_POINT
+    int scale_shift;
+#endif
+    int shift;
+    opus_int16 factors[2*MAXFACTORS];
+    const opus_int32 *bitrev;
+    const kiss_twiddle_cpx *twiddles;
+    arch_fft_state *arch_fft;
+} kiss_fft_state;
+
+#if defined(HAVE_ARM_NE10)
+#include "arm/fft_arm.h"
+#endif
+
+/*typedef struct kiss_fft_state* kiss_fft_cfg;*/
+
+/**
+ *  opus_fft_alloc
+ *
+ *  Initialize a FFT (or IFFT) algorithm's cfg/state buffer.
+ *
+ *  typical usage:      kiss_fft_cfg mycfg=opus_fft_alloc(1024,0,NULL,NULL);
+ *
+ *  The return value from fft_alloc is a cfg buffer used internally
+ *  by the fft routine or NULL.
+ *
+ *  If lenmem is NULL, then opus_fft_alloc will allocate a cfg buffer using malloc.
+ *  The returned value should be free()d when done to avoid memory leaks.
+ *
+ *  The state can be placed in a user supplied buffer 'mem':
+ *  If lenmem is not NULL and mem is not NULL and *lenmem is large enough,
+ *      then the function places the cfg in mem and the size used in *lenmem
+ *      and returns mem.
+ *
+ *  If lenmem is not NULL and ( mem is NULL or *lenmem is not large enough),
+ *      then the function returns NULL and places the minimum cfg
+ *      buffer size in *lenmem.
+ * */
+
+kiss_fft_state *rnn_fft_alloc_twiddles(int nfft,void * mem,size_t * lenmem, const kiss_fft_state *base, int arch);
+
+kiss_fft_state *rnn_fft_alloc(int nfft,void * mem,size_t * lenmem, int arch);
+
+/**
+ * opus_fft(cfg,in_out_buf)
+ *
+ * Perform an FFT on a complex input buffer.
+ * for a forward FFT,
+ * fin should be  f[0] , f[1] , ... ,f[nfft-1]
+ * fout will be   F[0] , F[1] , ... ,F[nfft-1]
+ * Note that each element is complex and can be accessed like
+    f[k].r and f[k].i
+ * */
+void rnn_fft_c(const kiss_fft_state *cfg,const kiss_fft_cpx *fin,kiss_fft_cpx *fout);
+void rnn_ifft_c(const kiss_fft_state *cfg,const kiss_fft_cpx *fin,kiss_fft_cpx *fout);
+
+void rnn_fft_impl(const kiss_fft_state *st,kiss_fft_cpx *fout);
+void rnn_ifft_impl(const kiss_fft_state *st,kiss_fft_cpx *fout);
+
+void rnn_fft_free(const kiss_fft_state *cfg, int arch);
+
+
+void rnn_fft_free_arch_c(kiss_fft_state *st);
+int rnn_fft_alloc_arch_c(kiss_fft_state *st);
+
+#if !defined(OVERRIDE_OPUS_FFT)
+/* Is run-time CPU detection enabled on this platform? */
+#if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10))
+
+extern int (*const OPUS_FFT_ALLOC_ARCH_IMPL[OPUS_ARCHMASK+1])(
+ kiss_fft_state *st);
+
+#define opus_fft_alloc_arch(_st, arch) \
+         ((*OPUS_FFT_ALLOC_ARCH_IMPL[(arch)&OPUS_ARCHMASK])(_st))
+
+extern void (*const OPUS_FFT_FREE_ARCH_IMPL[OPUS_ARCHMASK+1])(
+ kiss_fft_state *st);
+#define opus_fft_free_arch(_st, arch) \
+         ((*OPUS_FFT_FREE_ARCH_IMPL[(arch)&OPUS_ARCHMASK])(_st))
+
+extern void (*const OPUS_FFT[OPUS_ARCHMASK+1])(const kiss_fft_state *cfg,
+ const kiss_fft_cpx *fin, kiss_fft_cpx *fout);
+#define opus_fft(_cfg, _fin, _fout, arch) \
+   ((*OPUS_FFT[(arch)&OPUS_ARCHMASK])(_cfg, _fin, _fout))
+
+extern void (*const OPUS_IFFT[OPUS_ARCHMASK+1])(const kiss_fft_state *cfg,
+ const kiss_fft_cpx *fin, kiss_fft_cpx *fout);
+#define opus_ifft(_cfg, _fin, _fout, arch) \
+   ((*OPUS_IFFT[(arch)&OPUS_ARCHMASK])(_cfg, _fin, _fout))
+
+#else /* else for if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10)) */
+
+#define rnn_fft_alloc_arch(_st, arch) \
+         ((void)(arch), rnn_fft_alloc_arch_c(_st))
+
+#define rnn_fft_free_arch(_st, arch) \
+         ((void)(arch), rnn_fft_free_arch_c(_st))
+
+#define rnn_fft(_cfg, _fin, _fout, arch) \
+         ((void)(arch), rnn_fft_c(_cfg, _fin, _fout))
+
+#define rnn_ifft(_cfg, _fin, _fout, arch) \
+         ((void)(arch), rnn_ifft_c(_cfg, _fin, _fout))
+
+#endif /* end if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10)) */
+#endif /* end if !defined(OVERRIDE_OPUS_FFT) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

cpp/third_party/kissfft/opus_types.h

@@ -0,0 +1,159 @@
+/* (C) COPYRIGHT 1994-2002 Xiph.Org Foundation */
+/* Modified by Jean-Marc Valin */
+/*
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - 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 SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS 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 THE COPYRIGHT OWNER
+   OR CONTRIBUTORS 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.
+*/
+/* opus_types.h based on ogg_types.h from libogg */
+
+/**
+   @file opus_types.h
+   @brief Opus reference implementation types
+*/
+#ifndef OPUS_TYPES_H
+#define OPUS_TYPES_H
+
+/* Use the real stdint.h if it's there (taken from Paul Hsieh's pstdint.h) */
+#if (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined(__GNUC__) && (defined(_STDINT_H) || defined(_STDINT_H_)) || defined (HAVE_STDINT_H))
+#include <stdint.h>
+
+   typedef int16_t opus_int16;
+   typedef uint16_t opus_uint16;
+   typedef int32_t opus_int32;
+   typedef uint32_t opus_uint32;
+#elif defined(_WIN32)
+
+#  if defined(__CYGWIN__)
+#    include <_G_config.h>
+     typedef _G_int32_t opus_int32;
+     typedef _G_uint32_t opus_uint32;
+     typedef _G_int16 opus_int16;
+     typedef _G_uint16 opus_uint16;
+#  elif defined(__MINGW32__)
+     typedef short opus_int16;
+     typedef unsigned short opus_uint16;
+     typedef int opus_int32;
+     typedef unsigned int opus_uint32;
+#  elif defined(__MWERKS__)
+     typedef int opus_int32;
+     typedef unsigned int opus_uint32;
+     typedef short opus_int16;
+     typedef unsigned short opus_uint16;
+#  else
+     /* MSVC/Borland */
+     typedef __int32 opus_int32;
+     typedef unsigned __int32 opus_uint32;
+     typedef __int16 opus_int16;
+     typedef unsigned __int16 opus_uint16;
+#  endif
+
+#elif defined(__MACOS__)
+
+#  include <sys/types.h>
+   typedef SInt16 opus_int16;
+   typedef UInt16 opus_uint16;
+   typedef SInt32 opus_int32;
+   typedef UInt32 opus_uint32;
+
+#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
+
+#  include <sys/types.h>
+   typedef int16_t opus_int16;
+   typedef u_int16_t opus_uint16;
+   typedef int32_t opus_int32;
+   typedef u_int32_t opus_uint32;
+
+#elif defined(__BEOS__)
+
+   /* Be */
+#  include <inttypes.h>
+   typedef int16 opus_int16;
+   typedef u_int16 opus_uint16;
+   typedef int32_t opus_int32;
+   typedef u_int32_t opus_uint32;
+
+#elif defined (__EMX__)
+
+   /* OS/2 GCC */
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#elif defined (DJGPP)
+
+   /* DJGPP */
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#elif defined(R5900)
+
+   /* PS2 EE */
+   typedef int opus_int32;
+   typedef unsigned opus_uint32;
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+
+#elif defined(__SYMBIAN32__)
+
+   /* Symbian GCC */
+   typedef signed short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef signed int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#elif defined(CONFIG_TI_C54X) || defined (CONFIG_TI_C55X)
+
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef long opus_int32;
+   typedef unsigned long opus_uint32;
+
+#elif defined(CONFIG_TI_C6X)
+
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#else
+
+   /* Give up, take a reasonable guess */
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#endif
+
+#define opus_int         int                     /* used for counters etc; at least 16 bits */
+#define opus_int64       long long
+#define opus_int8        signed char
+
+#define opus_uint        unsigned int            /* used for counters etc; at least 16 bits */
+#define opus_uint64      unsigned long long
+#define opus_uint8       unsigned char
+
+#endif  /* OPUS_TYPES_H */

cpp/toolchains/aarch64-none-linux-gnu.toolchain.cmake

@@ -0,0 +1,22 @@
+# AX650 / AX630C aarch64 cross-compile toolchain
+#
+# Download:
+#   wget https://developer.arm.com/-/media/Files/downloads/gnu-a/9.2-2019.12/binrel/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz
+#   tar -xf gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz
+#
+# Set TOOLCHAIN_DIR:  export TOOLCHAIN_DIR=/path/to/gcc-arm-...
+#   or pass:  cmake -DTOOLCHAIN_DIR=/path/to/...
+
+if(NOT DEFINED TOOLCHAIN_DIR)
+    set(TOOLCHAIN_DIR "$ENV{HOME}/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu")
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+set(CMAKE_C_COMPILER   "${TOOLCHAIN_DIR}/bin/aarch64-none-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "${TOOLCHAIN_DIR}/bin/aarch64-none-linux-gnu-g++")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

cpp/utils/checker.h

@@ -0,0 +1,27 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Utility: checker macros
+ *
+ * Adapted from melotts.axera-main
+ **************************************************************************************************/
+
+#pragma once
+
+#include "utils/logger.h"
+
+#define CHECK_PTR(p)                     \
+    do {                                 \
+        if (!p) {                        \
+            ALOGE("%s nil pointer\n", #p); \
+            return -1;                   \
+        }                                \
+    } while (0)
+
+#define CHECK_INITED(p)                     \
+    do {                                    \
+        if (!p->HasInit()) {                \
+            ALOGE("%s has not init\n", #p); \
+            return -1;                      \
+        }                                   \
+    } while (0)

cpp/utils/io.hpp

@@ -0,0 +1,212 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Utility: AX engine I/O helpers
+ *
+ * Adapted from melotts.axera-main
+ **************************************************************************************************/
+
+#pragma once
+
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <array>
+#include <string>
+#include <fstream>
+#include <cstdint>
+#include <cstdlib>
+
+#include "utils/checker.h"
+#include "ax_sys_api.h"
+#include "ax_engine_type.h"
+
+#define IO_CMM_ALIGN_SIZE 128
+
+namespace utils {
+
+typedef enum {
+    IO_BUFFER_STRATEGY_DEFAULT,
+    IO_BUFFER_STRATEGY_CACHED
+} IO_BUFFER_STRATEGY_T;
+
+static inline void brief_io_info(const std::string& strModel, const AX_ENGINE_IO_INFO_T* io_info) {
+    auto describe_shape_type = [](AX_ENGINE_TENSOR_LAYOUT_T type) -> const char* {
+        switch (type) {
+            case AX_ENGINE_TENSOR_LAYOUT_NHWC: return "NHWC";
+            case AX_ENGINE_TENSOR_LAYOUT_NCHW: return "NCHW";
+            default: return "unknown";
+        }
+    };
+    auto describe_data_type = [](AX_ENGINE_DATA_TYPE_T type) -> const char* {
+        switch (type) {
+            case AX_ENGINE_DT_UINT8:  return "uint8";
+            case AX_ENGINE_DT_UINT16: return "uint16";
+            case AX_ENGINE_DT_FLOAT32: return "float32";
+            case AX_ENGINE_DT_SINT16: return "sint16";
+            case AX_ENGINE_DT_SINT8:  return "sint8";
+            case AX_ENGINE_DT_SINT32: return "sint32";
+            case AX_ENGINE_DT_UINT32: return "uint32";
+            case AX_ENGINE_DT_FLOAT64: return "float64";
+            default: return "unknown";
+        }
+    };
+
+    printf("Model: %s\n", strModel.c_str());
+    for (uint32_t i = 0; i < io_info->nInputSize; ++i) {
+        auto& input = io_info->pInputs[i];
+        printf("  Input[%d]: %s size=%u\n", i, input.pName, input.nSize);
+    }
+    for (uint32_t i = 0; i < io_info->nOutputSize; ++i) {
+        auto& output = io_info->pOutputs[i];
+        printf("  Output[%d]: %s size=%u\n", i, output.pName, output.nSize);
+    }
+}
+
+static inline AX_S32 alloc_engine_buffer(const std::string& token, const std::string& appendix,
+                                          size_t index, const AX_ENGINE_IOMETA_T* pMeta,
+                                          AX_ENGINE_IO_BUFFER_T* pBuf,
+                                          IO_BUFFER_STRATEGY_T eStrategy = IO_BUFFER_STRATEGY_DEFAULT) {
+    memset(pBuf, 0, sizeof(AX_ENGINE_IO_BUFFER_T));
+    pBuf->nSize = pMeta->nSize;
+
+    const std::string token_name = "zipvoice_" + token + appendix + std::to_string(index);
+
+    AX_S32 ret;
+    if (eStrategy == IO_BUFFER_STRATEGY_CACHED) {
+        ret = AX_SYS_MemAllocCached((AX_U64*)&pBuf->phyAddr, &pBuf->pVirAddr,
+                                     pBuf->nSize, IO_CMM_ALIGN_SIZE,
+                                     (const AX_S8*)token_name.c_str());
+    } else {
+        ret = AX_SYS_MemAlloc((AX_U64*)&pBuf->phyAddr, &pBuf->pVirAddr,
+                               pBuf->nSize, IO_CMM_ALIGN_SIZE,
+                               (const AX_S8*)token_name.c_str());
+    }
+    return ret;
+}
+
+static inline AX_S32 free_engine_buffer(AX_ENGINE_IO_BUFFER_T* pBuf) {
+    if (pBuf->phyAddr == 0) {
+        delete[] reinterpret_cast<uint8_t*>(pBuf->pVirAddr);
+    } else {
+        AX_SYS_MemFree(pBuf->phyAddr, pBuf->pVirAddr);
+    }
+    pBuf->phyAddr = 0;
+    pBuf->pVirAddr = nullptr;
+    return 0;
+}
+
+static inline void free_io_index(AX_ENGINE_IO_BUFFER_T* io_buf, size_t index) {
+    free_engine_buffer(io_buf + index);
+}
+
+static inline void free_io(AX_ENGINE_IO_T &io) {
+    for (size_t j = 0; j < io.nInputSize; ++j) {
+        free_io_index(io.pInputs, j);
+    }
+    for (size_t j = 0; j < io.nOutputSize; ++j) {
+        free_io_index(io.pOutputs, j);
+    }
+    delete[] io.pInputs;
+    delete[] io.pOutputs;
+    io.pInputs = nullptr;
+    io.pOutputs = nullptr;
+}
+
+static inline int prepare_io(const std::string& token, const AX_ENGINE_IO_INFO_T* info,
+                              AX_ENGINE_IO_T &io, IO_BUFFER_STRATEGY_T strategy) {
+    memset(&io, 0, sizeof(io));
+
+    io.pInputs = new AX_ENGINE_IO_BUFFER_T[info->nInputSize];
+    if (!io.pInputs) return -1;
+    memset(io.pInputs, 0x00, sizeof(AX_ENGINE_IO_BUFFER_T) * info->nInputSize);
+    io.nInputSize = info->nInputSize;
+
+    for (AX_U32 i = 0; i < info->nInputSize; ++i) {
+        auto meta = info->pInputs[i];
+        auto buffer = &io.pInputs[i];
+        int ret = alloc_engine_buffer(token, "_input_", i, &meta, buffer, strategy);
+        if (ret != 0) {
+            for (AX_U32 j = 0; j < i; ++j) free_io_index(io.pInputs, j);
+            delete[] io.pInputs;
+            io.pInputs = nullptr;
+            return ret;
+        }
+    }
+
+    io.pOutputs = new AX_ENGINE_IO_BUFFER_T[info->nOutputSize];
+    if (!io.pOutputs) {
+        delete[] io.pInputs;
+        io.pInputs = nullptr;
+        return -1;
+    }
+    memset(io.pOutputs, 0x00, sizeof(AX_ENGINE_IO_BUFFER_T) * info->nOutputSize);
+    io.nOutputSize = info->nOutputSize;
+
+    for (size_t i = 0; i < info->nOutputSize; ++i) {
+        auto meta = info->pOutputs[i];
+        auto buffer = &io.pOutputs[i];
+        int ret = alloc_engine_buffer(token, "_output_", i, &meta, buffer, strategy);
+        if (ret != 0) {
+            for (AX_U32 j = 0; j < info->nInputSize; ++j) free_io_index(io.pInputs, j);
+            delete[] io.pInputs;
+            io.pInputs = nullptr;
+            for (size_t k = 0; k < i; ++k) free_io_index(io.pOutputs, k);
+            delete[] io.pOutputs;
+            io.pOutputs = nullptr;
+            return ret;
+        }
+    }
+    return 0;
+}
+
+static inline AX_S32 push_io_input(void* input, int index, AX_ENGINE_IO_T& io) {
+    AX_ENGINE_IO_BUFFER_T* pBuf = &io.pInputs[index];
+    memcpy(pBuf->pVirAddr, input, pBuf->nSize);
+    return 0;
+}
+
+static inline AX_S32 push_io_output(void* output, int index, AX_ENGINE_IO_T& io) {
+    AX_ENGINE_IO_BUFFER_T* pBuf = &io.pOutputs[index];
+    memcpy(output, pBuf->pVirAddr, pBuf->nSize);
+    return 0;
+}
+
+static inline bool read_file(const char* path, std::vector<char>& data) {
+    std::fstream fs(path, std::ios::in | std::ios::binary);
+    if (!fs.is_open()) return false;
+
+    fs.seekg(std::ios::end);
+    auto fs_end = fs.tellg();
+    fs.seekg(std::ios::beg);
+    auto fs_beg = fs.tellg();
+
+    auto file_size = static_cast<size_t>(fs_end - fs_beg);
+    auto vector_size = data.size();
+    data.reserve(vector_size + file_size);
+    data.insert(data.end(), std::istreambuf_iterator<char>(fs), std::istreambuf_iterator<char>());
+    fs.close();
+    return true;
+}
+
+static inline bool read_file(const char* path, AX_VOID **pModelBufferVirAddr,
+                              AX_U64 &u64ModelBufferPhyAddr, AX_U32 &nModelBufferSize) {
+    std::fstream fs(path, std::ios::in | std::ios::binary);
+    if (!fs.is_open()) return false;
+
+    fs.seekg(0, std::ios::end);
+    int file_size = fs.tellg();
+    fs.seekg(0, std::ios::beg);
+
+    nModelBufferSize = (AX_U32)file_size;
+    AX_SYS_MemAlloc(&u64ModelBufferPhyAddr, pModelBufferVirAddr, nModelBufferSize,
+                     0x100, (AX_S8 *)"ZIPVOICE-MODEL");
+
+    if (!pModelBufferVirAddr || (u64ModelBufferPhyAddr == 0)) return false;
+
+    fs.read((AX_CHAR *)*pModelBufferVirAddr, nModelBufferSize);
+    fs.close();
+    return true;
+}
+
+} // namespace utils

cpp/utils/logger.h

@@ -0,0 +1,64 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Utility: logger
+ *
+ * Adapted from melotts.axera-main
+ **************************************************************************************************/
+
+#pragma once
+
+#include <cstdio>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    SKEL_LOG_MIN         = -1,
+    SKEL_LOG_EMERGENCY   = 0,
+    SKEL_LOG_ALERT       = 1,
+    SKEL_LOG_CRITICAL    = 2,
+    SKEL_LOG_ERROR       = 3,
+    SKEL_LOG_WARN        = 4,
+    SKEL_LOG_NOTICE      = 5,
+    SKEL_LOG_INFO        = 6,
+    SKEL_LOG_DEBUG       = 7,
+    SKEL_LOG_MAX
+} SKEL_LOG_LEVEL_E;
+
+static SKEL_LOG_LEVEL_E log_level = SKEL_LOG_INFO;
+
+#if 1
+#define MACRO_BLACK "\033[1;30;30m"
+#define MACRO_RED "\033[1;30;31m"
+#define MACRO_GREEN "\033[1;30;32m"
+#define MACRO_YELLOW "\033[1;30;33m"
+#define MACRO_BLUE "\033[1;30;34m"
+#define MACRO_PURPLE "\033[1;30;35m"
+#define MACRO_WHITE "\033[1;30;37m"
+#define MACRO_END "\033[0m"
+#else
+#define MACRO_BLACK
+#define MACRO_RED
+#define MACRO_GREEN
+#define MACRO_YELLOW
+#define MACRO_BLUE
+#define MACRO_PURPLE
+#define MACRO_WHITE
+#define MACRO_END
+#endif
+
+#define ALOGE(fmt, ...) printf(MACRO_RED "[E][%32s][%4d]: " fmt MACRO_END "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
+#define ALOGW(fmt, ...) if (log_level >= SKEL_LOG_WARN) \
+    printf(MACRO_YELLOW "[W][%32s][%4d]: " fmt MACRO_END "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
+#define ALOGI(fmt, ...) if (log_level >= SKEL_LOG_INFO) \
+    printf(MACRO_GREEN "[I][%32s][%4d]: " fmt MACRO_END "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
+#define ALOGD(fmt, ...) if (log_level >= SKEL_LOG_DEBUG) \
+    printf(MACRO_WHITE "[D][%32s][%4d]: " fmt MACRO_END "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
+#define ALOGN(fmt, ...) if (log_level >= SKEL_LOG_NOTICE) \
+    printf(MACRO_PURPLE "[N][%32s][%4d]: " fmt MACRO_END "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif

cpp/vocoder/vocos_full.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70a7a897f6beb0b6e8536413a0ea6ee2132bec1257e51208e80eca506bda4c40
+size 15413002

cpp/zipvoice.cpp

@@ -0,0 +1,1082 @@
+/**************************************************************************************************
+ * ZipVoice AXERA C++ Port
+ *
+ * Main entry: Command-line TTS inference using ZipVoice encoder + split-decoder4
+ * axmodels on AXERA NPU boards.
+ *
+ * Pipeline:
+ *   1. Load tokenizer (tokens.txt)
+ *   2. Load prompt audio → extract mel filterbank features
+ *   3. Tokenize text → build cat_tokens
+ *   4. Encoder (encoder.axmodel) → encoded features
+ *   5. Duration expand
+ *   6. Decoder4 (decoder_part0..3.axmodel) → flow-matching → mel features
+ *   7. Save mel features as raw float32 binary (can be decoded with Python vocoder)
+ *
+ * Usage:
+ *   ./zipvoice_axera \
+ *     --model-dir ../models/zipvoice_ax650 \
+ *     --token-file ../resources/zipvoice_hf/zipvoice/tokens.txt \
+ *     --prompt-wav ../assets/moss_prompts/zh_1_4p5s.wav \
+ *     --prompt-text "你好，欢迎使用语音合成系统" \
+ *     --text "这是要合成的目标文本" \
+ *     --output-feat output_mel.bin
+ *
+ * Requirements: AX650 board with axengine SDK
+ *
+ * Based on ZipVoice.AXERA Python inference and melotts.axera-main C++ patterns.
+ **************************************************************************************************/
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <cmath>
+#include <algorithm>
+#include <sys/time.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "ax_sys_api.h"
+#include "src/cmdline.hpp"
+#include "src/EngineWrapper.hpp"
+#include "src/tokenizer.hpp"
+#include "src/fbank.hpp"
+#include "src/zipvoice_engine.hpp"
+#include "src/vocoder.hpp"
+#include "src/wav_writer.hpp"
+
+static double get_current_time_ms() {
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
+}
+
+// Persistent Python daemon for fast tokenization (imports jieba/pypinyin once at startup).
+// Communication via pipe: C++ writes commands to daemon's stdin, reads responses from stdout.
+struct PyDaemon {
+    int pid = -1;
+    FILE* write_pipe = nullptr;
+    FILE* read_pipe = nullptr;
+
+    ~PyDaemon() { Stop(); }
+
+    bool Start(const std::string& repo_dir, const std::string& daemon_script) {
+        int pipe_to_cpp[2], pipe_to_py[2];
+        if (pipe(pipe_to_cpp) != 0 || pipe(pipe_to_py) != 0) return false;
+
+        pid = fork();
+        if (pid < 0) { close(pipe_to_cpp[0]); close(pipe_to_cpp[1]); close(pipe_to_py[0]); close(pipe_to_py[1]); return false; }
+
+        if (pid == 0) {
+            // Child: Python daemon
+            close(pipe_to_cpp[0]);  // close read end of cpp-pipe
+            close(pipe_to_py[1]);   // close write end of py-pipe
+            dup2(pipe_to_py[0], STDIN_FILENO);
+            dup2(pipe_to_cpp[1], STDOUT_FILENO);
+            close(pipe_to_cpp[1]); close(pipe_to_py[0]);
+            execlp("python3", "python3", "-u", daemon_script.c_str(), repo_dir.c_str(), nullptr);
+            _exit(1);
+        }
+
+        // Parent
+        close(pipe_to_cpp[1]);  // close write end
+        close(pipe_to_py[0]);   // close read end
+        write_pipe = fdopen(pipe_to_py[1], "w");
+        read_pipe  = fdopen(pipe_to_cpp[0], "r");
+        if (!write_pipe || !read_pipe) { Stop(); return false; }
+        setlinebuf(write_pipe);
+
+        // Wait for READY signal
+        char buf[256];
+        if (!fgets(buf, sizeof(buf), read_pipe) || strncmp(buf, "READY", 5) != 0) {
+            printf("PyDaemon: failed to start (%s)\n", buf ? buf : "no response");
+            Stop(); return false;
+        }
+        printf("PyDaemon: started\n");
+        return true;
+    }
+
+    void Stop() {
+        if (write_pipe) { fprintf(write_pipe, "quit\n"); fflush(write_pipe); fclose(write_pipe); write_pipe = nullptr; }
+        if (read_pipe)  { fclose(read_pipe); read_pipe = nullptr; }
+        if (pid > 0)    { waitpid(pid, nullptr, 0); pid = -1; }
+    }
+};
+
+static int DaemonCountTokens(PyDaemon& py_daemon, const std::string& prompt_file,
+                             const std::string& text_file, int* prompt_len, int* text_len) {
+    if (!py_daemon.write_pipe || !py_daemon.read_pipe) return -1;
+    fprintf(py_daemon.write_pipe, "count\t%s\t%s\n", prompt_file.c_str(), text_file.c_str());
+    fflush(py_daemon.write_pipe);
+    char buf[256];
+    if (fgets(buf, sizeof(buf), py_daemon.read_pipe) && sscanf(buf, "COUNT %d %d", prompt_len, text_len) == 2) {
+        return 0;
+    }
+    return -1;
+}
+
+static int DaemonTokenize(PyDaemon& py_daemon, const std::string& prompt_file,
+                          const std::string& text_file, int max_tokens,
+                          const std::string& output_bin, int* prompt_len, int* text_len) {
+    if (!py_daemon.write_pipe || !py_daemon.read_pipe) return -1;
+    fprintf(py_daemon.write_pipe, "tokenize\t%s\t%s\t%d\t%s\n",
+            prompt_file.c_str(), text_file.c_str(), max_tokens, output_bin.c_str());
+    fflush(py_daemon.write_pipe);
+    char buf[256];
+    if (fgets(buf, sizeof(buf), py_daemon.read_pipe)) {
+        if (sscanf(buf, "TOKENS %d %d", prompt_len, text_len) == 2) return 0;
+        if (strncmp(buf, "ERROR", 5) == 0) {
+            printf("PyDaemon: %s", buf);
+            return -2;
+        }
+    }
+    return -1;
+}
+
+/**
+ * Read float32 WAV file and return samples.
+ * Supports 16-bit PCM and 32-bit float WAV files with basic header parsing.
+ */
+static int ReadWavFile(const std::string& path, std::vector<float>& samples, int& sample_rate) {
+    std::ifstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        printf("Failed to open: %s\n", path.c_str());
+        return -1;
+    }
+
+    // Read RIFF header
+    char riff[5] = {};
+    file.read(riff, 4);
+    if (std::strncmp(riff, "RIFF", 4) != 0) {
+        printf("Not a valid WAV file: %s\n", path.c_str());
+        return -1;
+    }
+
+    uint32_t file_size;
+    file.read(reinterpret_cast<char*>(&file_size), 4);
+
+    char wave[5] = {};
+    file.read(wave, 4);
+    if (std::strncmp(wave, "WAVE", 4) != 0) {
+        printf("Not a valid WAV file: %s\n", path.c_str());
+        return -1;
+    }
+
+    // Parse chunks
+    int num_channels = 1;
+    int bits_per_sample = 16;
+    sample_rate = 24000;
+    uint32_t data_size = 0;
+
+    while (file.good()) {
+        char chunk_id[5] = {};
+        file.read(chunk_id, 4);
+        uint32_t chunk_size;
+        file.read(reinterpret_cast<char*>(&chunk_size), 4);
+
+        if (std::strncmp(chunk_id, "fmt ", 4) == 0) {
+            uint16_t audio_format, num_ch, bps;
+            uint32_t sr, byte_rate;
+            uint16_t block_align;
+
+            file.read(reinterpret_cast<char*>(&audio_format), 2);
+            file.read(reinterpret_cast<char*>(&num_ch), 2);
+            file.read(reinterpret_cast<char*>(&sr), 4);
+            file.read(reinterpret_cast<char*>(&byte_rate), 4);
+            file.read(reinterpret_cast<char*>(&block_align), 2);
+            file.read(reinterpret_cast<char*>(&bps), 2);
+
+            num_channels = num_ch;
+            sample_rate = sr;
+            bits_per_sample = bps;
+
+            // Skip remaining fmt bytes
+            if (chunk_size > 16) {
+                file.seekg(chunk_size - 16, std::ios::cur);
+            }
+        } else if (std::strncmp(chunk_id, "data", 4) == 0) {
+            data_size = chunk_size;
+            break;
+        } else {
+            // Skip unknown chunk
+            file.seekg(chunk_size, std::ios::cur);
+        }
+    }
+
+    if (data_size == 0) {
+        printf("No data chunk found in WAV: %s\n", path.c_str());
+        return -1;
+    }
+
+    // Read audio data
+    int num_samples = data_size / (bits_per_sample / 8) / num_channels;
+
+    if (bits_per_sample == 16) {
+        std::vector<int16_t> raw(num_samples * num_channels);
+        file.read(reinterpret_cast<char*>(raw.data()), data_size);
+
+        samples.resize(num_samples);
+        for (int i = 0; i < num_samples; ++i) {
+            // Take first channel only
+            samples[i] = raw[i * num_channels] / 32768.0f;
+        }
+    } else if (bits_per_sample == 32) {
+        // Assume float32
+        samples.resize(num_samples * num_channels);
+        file.read(reinterpret_cast<char*>(samples.data()), data_size);
+
+        // Extract first channel
+        std::vector<float> mono(num_samples);
+        for (int i = 0; i < num_samples; ++i) {
+            mono[i] = samples[i * num_channels];
+        }
+        samples = std::move(mono);
+    } else {
+        printf("Unsupported bit depth: %d\n", bits_per_sample);
+        return -1;
+    }
+
+    printf("Read WAV: %s, sr=%d, ch=%d, samples=%d\n",
+           path.c_str(), sample_rate, num_channels, num_samples);
+    return 0;
+}
+
+/**
+ * Simple linear resampling.
+ */
+static std::vector<float> ResampleLinear(const std::vector<float>& samples,
+                                          int orig_sr, int target_sr) {
+    if (orig_sr == target_sr) return samples;
+
+    int old_len = static_cast<int>(samples.size());
+    int new_len = std::max(1, static_cast<int>(
+        std::round(static_cast<double>(old_len) * target_sr / orig_sr)));
+
+    std::vector<float> result(new_len);
+    for (int i = 0; i < new_len; ++i) {
+        double pos = static_cast<double>(i) * (old_len - 1) / (new_len - 1);
+        int idx = static_cast<int>(pos);
+        double frac = pos - idx;
+
+        if (idx + 1 < old_len) {
+            result[i] = static_cast<float>(
+                samples[idx] * (1.0 - frac) + samples[idx + 1] * frac);
+        } else {
+            result[i] = samples[old_len - 1];
+        }
+    }
+    return result;
+}
+
+/**
+ * Compute RMS of audio samples.
+ */
+static float ComputeRms(const std::vector<float>& samples) {
+    if (samples.empty()) return 0.0f;
+    float sum_sq = 0.0f;
+    for (float s : samples) sum_sq += s * s;
+    return std::sqrt(sum_sq / samples.size());
+}
+
+/**
+ * RMS normalize audio.
+ */
+static void RmsNormalize(std::vector<float>& samples, float target_rms) {
+    float rms = ComputeRms(samples);
+    if (rms < target_rms && rms > 1e-10f) {
+        float gain = target_rms / rms;
+        for (float& s : samples) s *= gain;
+    }
+}
+
+static bool IsUtf8Lead(unsigned char c) {
+    return (c & 0xC0) != 0x80;
+}
+
+static std::vector<std::string> SplitUtf8Chars(const std::string& text) {
+    std::vector<std::string> chars;
+    for (size_t i = 0; i < text.size();) {
+        unsigned char c = (unsigned char)text[i];
+        size_t len = 1;
+        if ((c & 0x80) == 0) len = 1;
+        else if ((c & 0xE0) == 0xC0) len = 2;
+        else if ((c & 0xF0) == 0xE0) len = 3;
+        else if ((c & 0xF8) == 0xF0) len = 4;
+        chars.push_back(text.substr(i, len));
+        i += len;
+    }
+    return chars;
+}
+
+static bool IsChineseUtf8Char(const std::string& ch) {
+    if (ch.size() != 3) return false;
+    unsigned char b0 = (unsigned char)ch[0];
+    unsigned char b1 = (unsigned char)ch[1];
+    unsigned char b2 = (unsigned char)ch[2];
+    uint32_t cp = ((b0 & 0x0F) << 12) | ((b1 & 0x3F) << 6) | (b2 & 0x3F);
+    return cp >= 0x4E00 && cp <= 0x9FFF;
+}
+
+static bool IsSplitPunct(const std::string& ch) {
+    static const char* puncts[] = {
+        ".", "!", "?", ";", ",", ":",
+        "。", "！", "？", "；", "，", "、", "："
+    };
+    for (auto* p : puncts) if (ch == p) return true;
+    return false;
+}
+
+static std::string TrimAsciiSpaces(const std::string& s) {
+    size_t start = 0, end = s.size();
+    while (start < end && (s[start] == ' ' || s[start] == '\t' || s[start] == '\n' || s[start] == '\r')) start++;
+    while (end > start && (s[end-1] == ' ' || s[end-1] == '\t' || s[end-1] == '\n' || s[end-1] == '\r')) end--;
+    return s.substr(start, end - start);
+}
+
+static std::string JoinUnits(const std::string& left, const std::string& right) {
+    if (left.empty()) return TrimAsciiSpaces(right);
+    std::string r = TrimAsciiSpaces(right);
+    if (r.empty()) return TrimAsciiSpaces(left);
+    auto left_chars = SplitUtf8Chars(left);
+    auto right_chars = SplitUtf8Chars(r);
+    bool zh_boundary = (!left_chars.empty() && IsChineseUtf8Char(left_chars.back())) ||
+                       (!right_chars.empty() && IsChineseUtf8Char(right_chars.front()));
+    return zh_boundary ? (TrimAsciiSpaces(left) + r) : (TrimAsciiSpaces(left) + " " + r);
+}
+
+static std::vector<std::string> SplitUnitsCpp(const std::string& text) {
+    std::vector<std::string> units;
+    auto chars = SplitUtf8Chars(TrimAsciiSpaces(text));
+    std::string current;
+    for (const auto& ch : chars) {
+        current += ch;
+        if (IsSplitPunct(ch)) {
+            std::string t = TrimAsciiSpaces(current);
+            if (!t.empty()) units.push_back(t);
+            current.clear();
+        }
+    }
+    current = TrimAsciiSpaces(current);
+    if (!current.empty()) units.push_back(current);
+    if (units.empty() && !text.empty()) units.push_back(TrimAsciiSpaces(text));
+    return units;
+}
+
+static int TokenCountCpp(Tokenizer& tokenizer, const std::string& text) {
+    return (int)tokenizer.TextToTokenIds(text).size();
+}
+
+struct SegmentInfoCpp {
+    std::string text;
+    int text_tokens = 0;
+    int raw_features_len = 0;
+    int features_len = 0;
+    int generated_frames = 0;
+};
+
+static std::vector<std::string> SplitLongUnitCpp(Tokenizer& tokenizer, const std::string& unit, int max_text_tokens) {
+    if (TokenCountCpp(tokenizer, unit) <= max_text_tokens) return {unit};
+
+    std::vector<std::string> chunks;
+    if (unit.find(' ') != std::string::npos) {
+        std::stringstream ss(unit);
+        std::string piece, current;
+        while (ss >> piece) {
+            std::string candidate = JoinUnits(current, piece);
+            if (!current.empty() && TokenCountCpp(tokenizer, candidate) > max_text_tokens) {
+                chunks.push_back(current);
+                current = piece;
+            } else {
+                current = candidate;
+            }
+        }
+        if (!current.empty()) chunks.push_back(current);
+        return chunks;
+    }
+
+    auto chars = SplitUtf8Chars(unit);
+    std::string current;
+    for (const auto& ch : chars) {
+        std::string candidate = current + ch;
+        if (!current.empty() && TokenCountCpp(tokenizer, candidate) > max_text_tokens) {
+            chunks.push_back(current);
+            current = ch;
+        } else {
+            current = candidate;
+        }
+    }
+    if (!current.empty()) chunks.push_back(current);
+    return chunks;
+}
+
+static SegmentInfoCpp EstimateSegmentCpp(Tokenizer& tokenizer, const std::string& text,
+                                         int prompt_frames, int prompt_tokens_len,
+                                         float speed, int max_feat_len) {
+    SegmentInfoCpp s;
+    s.text = text;
+    s.text_tokens = TokenCountCpp(tokenizer, text);
+    s.raw_features_len = (int)std::ceil((double)prompt_frames / prompt_tokens_len * (prompt_tokens_len + s.text_tokens) / speed);
+    s.features_len = std::min(s.raw_features_len, max_feat_len);
+    s.generated_frames = s.features_len - prompt_frames;
+    if (s.generated_frames <= 0) s.generated_frames = s.features_len;
+    return s;
+}
+
+static std::vector<SegmentInfoCpp> BuildSegmentsCpp(Tokenizer& tokenizer, const std::string& text,
+                                                    int prompt_frames, int prompt_tokens_len,
+                                                    float speed, int max_feat_len,
+                                                    int max_text_tokens, int min_generated_frames,
+                                                    int max_generated_frames, double max_raw_feat_ratio) {
+    auto raw_units = SplitUnitsCpp(text);
+    std::vector<std::string> units;
+    for (const auto& u : raw_units) {
+        auto split = SplitLongUnitCpp(tokenizer, u, max_text_tokens);
+        units.insert(units.end(), split.begin(), split.end());
+    }
+
+    std::vector<SegmentInfoCpp> segments;
+    std::string current;
+    for (const auto& unit : units) {
+        std::string candidate = JoinUnits(current, unit);
+        auto cand = EstimateSegmentCpp(tokenizer, candidate, prompt_frames, prompt_tokens_len, speed, max_feat_len);
+        bool raw_too_long = cand.raw_features_len > (int)(max_feat_len * max_raw_feat_ratio);
+        bool too_long = cand.text_tokens > max_text_tokens || cand.generated_frames > max_generated_frames || raw_too_long;
+        if (!current.empty() && too_long) {
+            segments.push_back(EstimateSegmentCpp(tokenizer, current, prompt_frames, prompt_tokens_len, speed, max_feat_len));
+            current = unit;
+        } else {
+            current = candidate;
+        }
+    }
+    if (!current.empty()) segments.push_back(EstimateSegmentCpp(tokenizer, current, prompt_frames, prompt_tokens_len, speed, max_feat_len));
+
+    if (segments.size() >= 2 && segments.back().generated_frames < min_generated_frames) {
+        std::string merged_text = JoinUnits(segments[segments.size()-2].text, segments.back().text);
+        auto merged = EstimateSegmentCpp(tokenizer, merged_text, prompt_frames, prompt_tokens_len, speed, max_feat_len);
+        bool raw_ok = merged.raw_features_len <= (int)(max_feat_len * max_raw_feat_ratio);
+        if (merged.text_tokens <= max_text_tokens && merged.generated_frames <= max_generated_frames && raw_ok) {
+            segments[segments.size()-2] = merged;
+            segments.pop_back();
+        }
+    }
+    return segments;
+}
+
+static std::vector<std::string> SplitLongUnitCppDaemon(PyDaemon& py_daemon,
+                                                        const std::string& prompt_text,
+                                                        const std::string& unit,
+                                                        int max_text_tokens) {
+    std::string tmp_prompt = "/tmp/zipvoice_prompt_count.txt";
+    std::string tmp_text = "/tmp/zipvoice_text_count.txt";
+    {
+        std::ofstream pf(tmp_prompt); pf << prompt_text; pf.close();
+    }
+
+    auto count_for = [&](const std::string& txt) -> int {
+        std::ofstream tf(tmp_text); tf << txt; tf.close();
+        int p = 0, t = 0;
+        if (DaemonCountTokens(py_daemon, tmp_prompt, tmp_text, &p, &t) != 0) return 1000000;
+        return t;
+    };
+
+    if (count_for(unit) <= max_text_tokens) return {unit};
+
+    std::vector<std::string> chunks;
+    if (unit.find(' ') != std::string::npos) {
+        std::stringstream ss(unit);
+        std::string piece, current;
+        while (ss >> piece) {
+            std::string candidate = JoinUnits(current, piece);
+            if (!current.empty() && count_for(candidate) > max_text_tokens) {
+                chunks.push_back(current);
+                current = piece;
+            } else {
+                current = candidate;
+            }
+        }
+        if (!current.empty()) chunks.push_back(current);
+        return chunks;
+    }
+
+    auto chars = SplitUtf8Chars(unit);
+    std::string current;
+    for (const auto& ch : chars) {
+        std::string candidate = current + ch;
+        if (!current.empty() && count_for(candidate) > max_text_tokens) {
+            chunks.push_back(current);
+            current = ch;
+        } else {
+            current = candidate;
+        }
+    }
+    if (!current.empty()) chunks.push_back(current);
+    return chunks;
+}
+
+static std::vector<SegmentInfoCpp> BuildSegmentsCppDaemon(PyDaemon& py_daemon,
+                                                          const std::string& prompt_text,
+                                                          const std::string& text,
+                                                          int prompt_frames,
+                                                          int prompt_tokens_len,
+                                                          float speed,
+                                                          int max_feat_len,
+                                                          int max_text_tokens,
+                                                          int min_generated_frames,
+                                                          int max_generated_frames,
+                                                          double max_raw_feat_ratio) {
+    std::string tmp_prompt = "/tmp/zipvoice_prompt_count.txt";
+    std::string tmp_text = "/tmp/zipvoice_text_count.txt";
+    {
+        std::ofstream pf(tmp_prompt); pf << prompt_text; pf.close();
+    }
+
+    auto token_count_daemon = [&](const std::string& txt) -> int {
+        std::ofstream tf(tmp_text); tf << txt; tf.close();
+        int p = 0, t = 0;
+        if (DaemonCountTokens(py_daemon, tmp_prompt, tmp_text, &p, &t) != 0) return 1000000;
+        return t;
+    };
+    auto estimate_segment = [&](const std::string& seg_text) -> SegmentInfoCpp {
+        SegmentInfoCpp s;
+        s.text = seg_text;
+        s.text_tokens = token_count_daemon(seg_text);
+        s.raw_features_len = (int)std::ceil((double)prompt_frames / prompt_tokens_len * (prompt_tokens_len + s.text_tokens) / speed);
+        s.features_len = std::min(s.raw_features_len, max_feat_len);
+        s.generated_frames = s.features_len - prompt_frames;
+        if (s.generated_frames <= 0) s.generated_frames = s.features_len;
+        return s;
+    };
+
+    auto raw_units = SplitUnitsCpp(text);
+    std::vector<std::string> units;
+    for (const auto& u : raw_units) {
+        auto split = SplitLongUnitCppDaemon(py_daemon, prompt_text, u, max_text_tokens);
+        units.insert(units.end(), split.begin(), split.end());
+    }
+
+    std::vector<SegmentInfoCpp> segments;
+    std::string current;
+    for (const auto& unit : units) {
+        std::string candidate = JoinUnits(current, unit);
+        auto cand = estimate_segment(candidate);
+        bool raw_too_long = cand.raw_features_len > (int)(max_feat_len * max_raw_feat_ratio);
+        bool too_long = cand.text_tokens > max_text_tokens || cand.generated_frames > max_generated_frames || raw_too_long;
+        if (!current.empty() && too_long) {
+            segments.push_back(estimate_segment(current));
+            current = unit;
+        } else {
+            current = candidate;
+        }
+    }
+    if (!current.empty()) segments.push_back(estimate_segment(current));
+
+    if (segments.size() >= 2 && segments.back().generated_frames < min_generated_frames) {
+        std::string merged_text = JoinUnits(segments[segments.size()-2].text, segments.back().text);
+        auto merged = estimate_segment(merged_text);
+        bool raw_ok = merged.raw_features_len <= (int)(max_feat_len * max_raw_feat_ratio);
+        if (merged.text_tokens <= max_text_tokens && merged.generated_frames <= max_generated_frames && raw_ok) {
+            segments[segments.size()-2] = merged;
+            segments.pop_back();
+        }
+    }
+    return segments;
+}
+
+
+/**
+ * Save features as raw float32 binary (compatible with numpy .fromfile).
+ */
+static bool SaveFeaturesBin(const std::string& path,
+                             const std::vector<float>& features,
+                             int num_frames, int feat_dim) {
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) return false;
+    file.write(reinterpret_cast<const char*>(features.data()),
+               num_frames * feat_dim * sizeof(float));
+    file.close();
+    printf("Saved features: %s [%d, %d]\n", path.c_str(), num_frames, feat_dim);
+    return true;
+}
+
+int main(int argc, char** argv) {
+    // --- Command line parsing ---
+    cmdline::parser cmd;
+
+    cmd.add<std::string>("model-dir", 'm', "Model directory containing axmodels and configs",
+                         true, "");
+    cmd.add<std::string>("token-file", 't', "Path to tokens.txt",
+                         false, "");
+    cmd.add<std::string>("prompt-wav", 'w', "Prompt audio WAV file", true, "");
+    cmd.add<std::string>("prompt-text", 'p', "Prompt text (for tokenization; optional with --cat-tokens-file)", false, "");
+    cmd.add<std::string>("text", 's', "Text to synthesize", false, "");
+    cmd.add<std::string>("text-file", 'f', "UTF-8 text file to synthesize", false, "");
+    cmd.add<std::string>("output-wav", 'o', "Output WAV file path",
+                         false, "output.wav");
+    cmd.add<std::string>("output-feat", 0, "Output mel features as raw float32 binary (optional)",
+                         false, "");
+    cmd.add<std::string>("repo-dir", 0, "Repo root dir. When set, auto-decode mel to WAV via Python vocoder (deprecated, use --vocoder-model).",
+                         false, "");
+    cmd.add<std::string>("vocoder-model", 0, "Path to vocos_full.axmodel for C++ vocoder. When set, all-C++ pipeline, no Python.",
+                         false, "");
+    cmd.add<std::string>("cat-tokens-file", 0, "Pre-computed cat_tokens int32 binary (from export_tokens.py). "
+                         "When set, skips built-in tokenizer.",
+                         false, "");
+    cmd.add<int>("prompt-tokens-len", 0, "Number of prompt tokens (required with --cat-tokens-file)", false, 0);
+    cmd.add<int>("text-tokens-len", 0, "Number of text tokens (required with --cat-tokens-file)", false, 0);
+
+    cmd.add<int>("max-tokens", 0, "Max token sequence length", false, 384);
+    cmd.add<int>("max-feat-len", 0, "Max feature sequence length", false, 1024);
+    cmd.add<int>("num-step", 0, "Number of flow-matching steps", false, 10);
+    cmd.add<float>("speed", 0, "Speech speed factor", false, 1.0f);
+    cmd.add<float>("guidance-scale", 0, "CFG guidance scale", false, 1.0f);
+    cmd.add<float>("t-shift", 0, "Time shift for flow scheduler", false, 0.5f);
+    cmd.add<float>("feat-scale", 0, "Feature scaling factor", false, 0.1f);
+    cmd.add<float>("target-rms", 0, "Target RMS for audio normalization", false, 0.1f);
+    cmd.add<int>("seed", 0, "Random seed", false, 42);
+    cmd.add<int>("min-generated-frames", 0, "Minimum generated frames per segment",
+                 false, 360);
+    cmd.add<int>("max-generated-frames", 0, "Maximum generated frames per segment",
+                 false, 620);
+
+    cmd.parse_check(argc, argv);
+
+    auto model_dir    = cmd.get<std::string>("model-dir");
+    auto token_file   = cmd.get<std::string>("token-file");
+    auto prompt_wav   = cmd.get<std::string>("prompt-wav");
+    auto prompt_text  = cmd.get<std::string>("prompt-text");
+    auto text         = cmd.get<std::string>("text");
+    auto text_file    = cmd.get<std::string>("text-file");
+    auto output_wav   = cmd.get<std::string>("output-wav");
+    auto output_feat  = cmd.get<std::string>("output-feat");
+    auto repo_dir     = cmd.get<std::string>("repo-dir");
+    auto vocoder_model = cmd.get<std::string>("vocoder-model");
+    auto cat_tokens_file = cmd.get<std::string>("cat-tokens-file");
+    int prompt_tokens_len_cmd = cmd.get<int>("prompt-tokens-len");
+    int text_tokens_len_cmd   = cmd.get<int>("text-tokens-len");
+
+    int max_tokens      = cmd.get<int>("max-tokens");
+    int max_feat_len    = cmd.get<int>("max-feat-len");
+    int num_step        = cmd.get<int>("num-step");
+    float speed         = cmd.get<float>("speed");
+    float guidance_scale = cmd.get<float>("guidance-scale");
+    float t_shift       = cmd.get<float>("t-shift");
+    float feat_scale    = cmd.get<float>("feat-scale");
+    float target_rms    = cmd.get<float>("target-rms");
+    int seed            = cmd.get<int>("seed");
+
+    // Load target text (not required when using pre-computed tokens)
+    std::string target_text = "(from cat-tokens-file)";
+    if (!cat_tokens_file.empty()) {
+        // Text not needed; pre-computed tokens are used
+    } else if (!text.empty()) {
+        target_text = text;
+    } else if (!text_file.empty()) {
+        std::ifstream file(text_file);
+        if (!file.is_open()) {
+            printf("Failed to open text file: %s\n", text_file.c_str());
+            return -1;
+        }
+        std::stringstream ss;
+        ss << file.rdbuf();
+        target_text = ss.str();
+    } else {
+        printf("ERROR: Either --text, --text-file, or --cat-tokens-file is required\n");
+        return -1;
+    }
+
+    // --- Load tokenizer first (needed for Python-aligned segmentation) ---
+    double t_tokenizer = get_current_time_ms();
+    Tokenizer tokenizer;
+    if (!token_file.empty()) {
+        if (tokenizer.Load(token_file) != 0) {
+            printf("Failed to load tokenizer\n");
+            return -1;
+        }
+        printf("Tokenizer load: %.0f ms\n", get_current_time_ms() - t_tokenizer);
+    } else {
+        printf("WARNING: No token file provided. Token IDs must be pre-computed.\n");
+    }
+
+    // Normalize whitespace only (Python load_text behavior)
+    {
+        std::string normalized;
+        bool last_was_space = false;
+        for (char c : target_text) {
+            if (c == '\n' || c == '\r' || c == '\t') c = ' ';
+            if (c == ' ') { if (!last_was_space) normalized += c; last_was_space = true; }
+            else { normalized += c; last_was_space = false; }
+        }
+        while (!normalized.empty() && normalized.back() == ' ') normalized.pop_back();
+        target_text = normalized;
+    }
+
+    // --- Start Python daemon early (needed for English long-text segmentation) ---
+    PyDaemon py_daemon;
+    if (!repo_dir.empty()) {
+        std::string daemon_path = repo_dir + "/cpp/scripts/py_daemon.py";
+        py_daemon.Start(repo_dir, daemon_path);
+    }
+
+    // Python-aligned long-text segmentation (text_processing.build_segments)
+    std::vector<std::string> sentences;
+    {
+        int prompt_tokens_len_actual = 0;
+        if (!repo_dir.empty()) {
+            // English: get true prompt token length from daemon
+            std::string tmp_prompt = "/tmp/zipvoice_prompt_seg.txt";
+            std::string tmp_dummy = "/tmp/zipvoice_dummy_seg.txt";
+            { std::ofstream pf(tmp_prompt); pf << prompt_text; pf.close(); }
+            { std::ofstream df(tmp_dummy); df << "x"; df.close(); }
+            int p = 0, t = 0;
+            if (DaemonCountTokens(py_daemon, tmp_prompt, tmp_dummy, &p, &t) != 0) {
+                printf("ERROR: failed to count prompt tokens via daemon\n");
+                return -1;
+            }
+            prompt_tokens_len_actual = p;
+        } else {
+            // Chinese: C++ tokenizer
+            prompt_tokens_len_actual = TokenCountCpp(tokenizer, prompt_text);
+        }
+
+        int max_text_tokens = max_tokens - prompt_tokens_len_actual - 1;
+        int min_generated_frames = 360;
+        int max_generated_frames = 620;
+        double max_raw_feat_ratio = 1.2;
+        if (!repo_dir.empty()) {
+            // English path: use Python daemon token counts inside build_segments
+            auto segments = BuildSegmentsCppDaemon(py_daemon, prompt_text, target_text,
+                                                   422, prompt_tokens_len_actual,
+                                                   speed, max_feat_len,
+                                                   max_text_tokens,
+                                                   min_generated_frames,
+                                                   max_generated_frames,
+                                                   max_raw_feat_ratio);
+            for (const auto& seg : segments) sentences.push_back(seg.text);
+        } else {
+            // Chinese path: use C++ tokenizer token counts
+            auto segments = BuildSegmentsCpp(tokenizer, target_text,
+                                             422, prompt_tokens_len_actual,
+                                             speed, max_feat_len,
+                                             max_text_tokens,
+                                             min_generated_frames,
+                                             max_generated_frames,
+                                             max_raw_feat_ratio);
+            for (const auto& seg : segments) sentences.push_back(seg.text);
+        }
+    }
+
+    printf("After build_segments: %zu segments\n", sentences.size());
+
+    printf("========================================\n");
+    printf("ZipVoice AXERA C++ Inference\n");
+    printf("========================================\n");
+    printf("model-dir:     %s\n", model_dir.c_str());
+    printf("token-file:    %s\n", token_file.c_str());
+    printf("prompt-wav:    %s\n", prompt_wav.c_str());
+    printf("prompt-text:   %s\n", prompt_text.c_str());
+    printf("target-text:   %s\n", target_text.c_str());
+    printf("output-wav:    %s\n", output_wav.c_str());
+    printf("max-tokens:    %d\n", max_tokens);
+    printf("max-feat-len:  %d\n", max_feat_len);
+    printf("num-step:      %d\n", num_step);
+    printf("speed:         %.2f\n", speed);
+    printf("guidance-scale:%.2f\n", guidance_scale);
+    printf("t-shift:       %.2f\n", t_shift);
+    printf("seed:          %d\n", seed);
+    printf("========================================\n");
+
+    // --- Init AX system ---
+    double t_total_start = get_current_time_ms();
+    int ret = AX_SYS_Init();
+    if (0 != ret) {
+        fprintf(stderr, "AX_SYS_Init failed! ret = 0x%x\n", ret);
+        return -1;
+    }
+
+    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, "AX_ENGINE_Init failed{0x%8x}.\n", ret);
+        return -1;
+    }
+
+    // tokenizer already loaded above for Python-aligned segmentation
+
+    // --- Load prompt audio & extract features ---
+    double t_feat_start = get_current_time_ms();
+    std::vector<float> prompt_audio;
+    int prompt_sr;
+    if (ReadWavFile(prompt_wav, prompt_audio, prompt_sr) != 0) {
+        return -1;
+    }
+
+    // Resample to 24kHz if needed
+    std::vector<float> prompt_resampled = ResampleLinear(prompt_audio, prompt_sr, 24000);
+
+    // RMS normalize
+    float prompt_rms = ComputeRms(prompt_resampled);
+    RmsNormalize(prompt_resampled, target_rms);
+
+    // Extract mel filterbank features
+    MelFilterBank fbank;
+    MelFilterBank::Config fbank_cfg;
+    fbank_cfg.sampling_rate = 24000;
+    fbank_cfg.n_mels = 100;
+    fbank_cfg.n_fft = 1024;
+    fbank_cfg.hop_length = 256;
+    fbank.Init(fbank_cfg);
+
+    std::vector<float> prompt_mel = fbank.Extract(prompt_resampled, 24000);
+    int prompt_frames = MelFilterBank::ComputeNumFrames(
+        static_cast<int>(prompt_resampled.size()), 256);
+
+    // Scale features
+    for (float& v : prompt_mel) v *= feat_scale;
+
+    printf("Prompt features: %d frames x %d mels (%.0f ms)\n",
+           prompt_frames, fbank_cfg.n_mels,
+           get_current_time_ms() - t_feat_start);
+    double t_fbank_ms = get_current_time_ms() - t_feat_start;
+
+    // ---- RTF timing starts here (excludes one-time init) ----
+    double t_rtf_start = get_current_time_ms();
+
+    // --- Initialize ZipVoice engine (once, before sentence loop) ---
+    double t_load_start = get_current_time_ms();
+    ZipVoiceEngine engine;
+
+    if (engine.Init(model_dir) != 0) {
+        printf("Failed to initialize ZipVoice engine\n");
+        return -1;
+    }
+    printf("Engine load: %.0f ms\n", get_current_time_ms() - t_load_start);
+
+    // --- Load vocoder axmodel (once, before sentence loop) ---
+    Vocoder vocoder;
+    if (!vocoder_model.empty()) {
+        double t_vocoder_load = get_current_time_ms();
+        Vocoder::Config vcfg;
+        vcfg.model_path = vocoder_model;
+        if (vocoder.Init(vcfg) != 0) {
+            printf("ERROR: Failed to load vocoder model\n");
+            return -1;
+        }
+        printf("Vocoder load: %.0f ms\n", get_current_time_ms() - t_vocoder_load);
+    }
+
+    // --- Process sentences ---
+    std::vector<float> all_audio;
+    double total_npu_ms = 0.0;
+    double total_vocoder_ms = 0.0;
+    int silence_samples = (int)(24000 * 0.14);  // 140ms silence between sentences (matching Python)
+    std::vector<float> silence(silence_samples, 0.0f);
+
+    for (size_t si = 0; si < sentences.size(); ++si) {
+        std::string target_text = sentences[si];
+        if (sentences.size() > 1) printf("\n--- Sentence %zu/%zu: %s ---\n", si+1, sentences.size(), target_text.substr(0, 60).c_str());
+
+    double t_tokenize = get_current_time_ms();
+
+    std::vector<int> prompt_tokens;
+    std::vector<int> text_tokens;
+    int prompt_tokens_len = 0;
+    int text_tokens_len = 0;
+
+    std::string actual_cat_tokens_file = cat_tokens_file;
+    std::string tmp_tokens_file;
+
+    if (!cat_tokens_file.empty()) {
+        // Use pre-computed cat_tokens file
+        prompt_tokens_len = prompt_tokens_len_cmd;
+        text_tokens_len   = text_tokens_len_cmd;
+        if (prompt_tokens_len <= 0 || text_tokens_len <= 0) {
+            printf("ERROR: --prompt-tokens-len and --text-tokens-len required with --cat-tokens-file\n");
+            return -1;
+        }
+        printf("Using pre-computed tokens: %s (prompt=%d, text=%d)\n",
+               cat_tokens_file.c_str(), prompt_tokens_len, text_tokens_len);
+    } else if (tokenizer.IsLoaded()) {
+        // Fast: use built-in C++ tokenizer (requires --token-file)
+        prompt_tokens = tokenizer.TextToTokenIds(prompt_text);
+        text_tokens = tokenizer.TextToTokenIds(target_text);
+        prompt_tokens_len = (int)prompt_tokens.size();
+        text_tokens_len = (int)text_tokens.size();
+        printf("C++ tokenizer: prompt=%d, text=%d (%.0f ms)\n",
+               prompt_tokens_len, text_tokens_len, get_current_time_ms() - t_tokenize);
+    } else if (!repo_dir.empty()) {
+        // Fast: use persistent Python daemon (imports done once at startup)
+        std::string tmp_prompt = "/tmp/zipvoice_prompt.txt";
+        std::string tmp_target = "/tmp/zipvoice_target.txt";
+        tmp_tokens_file = "/tmp/zipvoice_cat_tokens.bin";
+        {
+            std::ofstream pf(tmp_prompt); pf << prompt_text; pf.close();
+            std::ofstream tf(tmp_target); tf << target_text; tf.close();
+        }
+        if (DaemonTokenize(py_daemon, tmp_prompt, tmp_target, max_tokens,
+                           tmp_tokens_file, &prompt_tokens_len, &text_tokens_len) == 0) {
+            actual_cat_tokens_file = tmp_tokens_file;
+            printf("Python tokenizer: prompt=%d, text=%d (%.0f ms)\n",
+                   prompt_tokens_len, text_tokens_len, get_current_time_ms() - t_tokenize);
+        } else {
+            printf("ERROR: Python daemon tokenization failed\n");
+            return -1;
+        }
+    } else {
+        printf("ERROR: Provide --token-file, --cat-tokens-file, or --repo-dir\n");
+        return -1;
+    }
+
+    // Build or load cat_tokens [prompt + text + pad]
+    std::vector<int32_t> cat_tokens;
+    if (!actual_cat_tokens_file.empty()) {
+        // Read int32 binary
+        std::ifstream ctf(actual_cat_tokens_file, std::ios::binary);
+        if (!ctf.is_open()) {
+            printf("Failed to open: %s\n", actual_cat_tokens_file.c_str());
+            return -1;
+        }
+        ctf.seekg(0, std::ios::end);
+        size_t file_size = ctf.tellg();
+        ctf.seekg(0, std::ios::beg);
+        cat_tokens.resize(file_size / sizeof(int32_t));
+        ctf.read(reinterpret_cast<char*>(cat_tokens.data()), file_size);
+        ctf.close();
+        printf("Loaded %zu cat_tokens\n", cat_tokens.size());
+        if ((int)cat_tokens.size() > max_tokens) {
+            max_tokens = (int)cat_tokens.size();
+        }
+    } else if (tokenizer.IsLoaded()) {
+        tokenizer.BuildCatTokens(prompt_tokens, text_tokens, max_tokens, cat_tokens);
+    } else {
+        printf("ERROR: Cannot build cat_tokens\n");
+        return -1;
+    }
+
+    int feat_dim = fbank_cfg.n_mels;
+
+    ZipVoiceEngine::Timing timing;
+    std::vector<float> output_features;
+
+    if (engine.Sample(cat_tokens,
+                      prompt_tokens_len,
+                      text_tokens_len,
+                      prompt_mel,
+                      prompt_frames,
+                      speed,
+                      guidance_scale,
+                      seed,
+                      output_features,
+                      timing) != 0) {
+        printf("Inference failed!\n");
+        return -1;
+    }
+
+    double t_infer_end = get_current_time_ms();
+
+    int generated_frames = timing.generated_frames;
+    total_npu_ms += timing.total_time_sec * 1000.0;
+
+    // --- Save mel features ---
+    if (!output_feat.empty()) {
+        SaveFeaturesBin(output_feat, output_features, generated_frames, feat_dim);
+    }
+
+    // --- Decode mel to WAV ---
+    float audio_sec = 0.0f;
+    if (!vocoder_model.empty()) {
+        // C++ vocoder (axmodel): fast, all NPU
+        printf("\nDecoding via C++ vocoder...\n");
+        double t_vocoder_start = get_current_time_ms();
+
+        std::vector<float> audio;
+        if (vocoder.Decode(output_features, generated_frames, feat_scale, audio) != 0) {
+            printf("ERROR: Vocoder decode failed\n");
+            return -1;
+        }
+
+        double t_vocoder_decode = get_current_time_ms() - t_vocoder_start;
+        audio_sec = audio.size() / 24000.0f;
+
+        // RMS normalize (matching Python vocoder_decode_loaded)
+        RmsNormalize(audio, target_rms);
+        if (prompt_rms < target_rms) {
+            float scale = prompt_rms / target_rms;
+            for (float& s : audio) s *= scale;
+        }
+
+        // Accumulate audio + silence between sentences
+        if (!all_audio.empty()) all_audio.insert(all_audio.end(), silence.begin(), silence.end());
+        all_audio.insert(all_audio.end(), audio.begin(), audio.end());
+        total_vocoder_ms += t_vocoder_decode;
+
+        double t_rtf_ms = get_current_time_ms() - t_rtf_start;
+        double t_npu_ms = timing.total_time_sec * 1000.0;
+
+    } else if (!repo_dir.empty()) {
+        // Python vocoder (deprecated fallback)
+        printf("\nDecoding mel to WAV via Python vocoder...\n");
+        double t_vocoder_start = get_current_time_ms();
+        char cmdline[2048];
+        snprintf(cmdline, sizeof(cmdline),
+            "python3 -c \""
+            "import numpy as np, soundfile as sf, sys;"
+            "sys.path.insert(0, '%s');"
+            "from scripts.common_infer import load_vocoder, vocoder_decode_loaded;"
+            "feat = np.fromfile('%s', dtype=np.float32).reshape(1, -1, 100);"
+            "v = load_vocoder('%s');"
+            "audio = vocoder_decode_loaded(v, feat, feat_scale=%.2f, target_rms=%.2f, prompt_rms=%.4f);"
+            "sf.write('%s', audio, 24000);"
+            "print('AUDIO_SEC=%%f' %% (len(audio)/24000))"
+            "\"",
+            repo_dir.c_str(), output_feat.c_str(), repo_dir.c_str(),
+            feat_scale, target_rms, prompt_rms,
+            output_wav.c_str());
+        FILE* fp = popen(cmdline, "r");
+        if (fp) {
+            char buf[256];
+            while (fgets(buf, sizeof(buf), fp)) {
+                printf("%s", buf);
+                sscanf(buf, "AUDIO_SEC=%f", &audio_sec);
+            }
+            pclose(fp);
+        }
+        double t_vocoder = get_current_time_ms() - t_vocoder_start;
+        double t_rtf_ms = get_current_time_ms() - t_rtf_start;
+        double t_npu_ms = timing.total_time_sec * 1000.0;
+        printf("  NPU inference: %.0f ms  vocoder: %.0f ms\n", t_npu_ms, t_vocoder);
+        if (audio_sec > 0.0f) {
+            printf("  RTF (NPU only): %.4f (%.3f s / audio %.2f s)\n",
+                   t_npu_ms / 1000.0 / audio_sec, t_npu_ms / 1000.0, audio_sec);
+        }
+        total_vocoder_ms += t_vocoder;
+    } else {
+        printf("\nTo decode mel to WAV, add --vocoder-model <path/to/vocos_full.axmodel>\n");
+    }
+    }  // end for each sentence
+
+    // Write concatenated audio
+    if (!all_audio.empty()) {
+        if (!WavWriter::Write(output_wav, all_audio, 24000)) {
+            printf("ERROR: Failed to write WAV\n");
+            return -1;
+        }
+        float total_audio_sec = all_audio.size() / 24000.0f;
+        printf("\n========================================\n");
+        printf("Long-text synthesis complete\n");
+        printf("  Segments:        %zu\n", sentences.size());
+        printf("  Audio duration:  %.2f s\n", total_audio_sec);
+        printf("  NPU total:       %.3f s\n", total_npu_ms / 1000.0);
+        printf("  Vocoder total:   %.3f s\n", total_vocoder_ms / 1000.0);
+        printf("  RTF (NPU only):  %.4f\n", total_npu_ms / 1000.0 / total_audio_sec);
+        printf("  RTF (end-to-end):%.4f\n", (total_npu_ms + total_vocoder_ms) / 1000.0 / total_audio_sec);
+        printf("  Saved:           %s\n", output_wav.c_str());
+        printf("========================================\n");
+    }
+
+    printf("\nDone!\n");
+    return 0;
+}