First commit

.gitattributes

@@ -10,7 +10,6 @@
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
-*.axmodel filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
 *.npy filter=lfs diff=lfs merge=lfs -text
 *.npz filter=lfs diff=lfs merge=lfs -text
@@ -34,3 +33,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__alexa_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__embedding_model.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__hey_jarvis_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__hey_mycroft_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__hey_rhasspy_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__melspectrogram.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__timer_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/630C/openwakeword__weather_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__alexa_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__embedding_model.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__hey_jarvis_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__hey_mycroft_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__hey_rhasspy_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__melspectrogram.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__timer_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text
+models/650/openwakeword__weather_v0.1.axmodel filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,125 @@
----
-license: mit
----
+# openWakeWord.AXERA
+
+[openWakeWord](https://github.com/dscripka/openWakeWord) 语音唤醒 AXERA 推理 demo。
+
+## 功能
+
+- 支持 AX650 和 AX630C；
+- 支持 Python 和 C++ 板端推理；
+
+## 目录结构
+
+```text
+OpenWakeWord.AXERA/
+├── models/
+│   ├── 650/          # AX650 axmodel
+│   └── 630C/         # AX630C axmodel
+├── config/           # STFT/mel 权重
+├── audio/openwakeword/
+├── scripts/          # Python 推理代码
+├── cpp/              # C++ 源码、编译和运行脚本
+└── README.md
+```
+
+
+## Python
+
+```bash
+创建虚拟环境
+conda create -n OpenWakeWord python=3.10
+conda activate OpenWakeWord
+
+安装 [pyaxengine](https://github.com/AXERA-TECH/pyaxengine/releases/latest)：
+pip install axengine-x.x.x-py3-none-any.whl
+
+pip install -r requirements.txt
+```
+
+AX650：
+
+```bash
+python scripts/openwakeword_ax650.py
+```
+
+AX630C：
+
+```bash
+python scripts/openwakeword_ax630c.py
+```
+
+自定义音频目录、阈值和输出文件：
+
+```bash
+python scripts/openwakeword_ax630c.py \
+  --audio-dir audio/openwakeword \
+  --threshold 0.5 \
+  --output outputs/openwakeword_ax630c.json
+```
+
+## C++
+
+### 编译环境
+
+AX650 和 AX630C 共用 Arm GNU 9.2 AArch64 交叉编译器：
+
+<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>
+
+```bash
+mkdir -p cpp/toolchains
+wget -P cpp/toolchains \
+  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 cpp/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz \
+  -C cpp/toolchains
+```
+
+BSP SDK 下载地址：
+
+| 平台 | BSP SDK |
+| --- | --- |
+| AX650 | <https://github.com/ZHEQIUSHUI/assets/releases/download/ax_3.6.2/msp_50_3.10.2.zip> |
+| AX630C | <https://github.com/ZHEQIUSHUI/assets/releases/download/ax_3.6.2/msp_20e_3.0.0.zip> |
+
+下载并整理到 `cpp/toolchains/`：
+
+```bash
+bash cpp/download_bsp.sh all
+```
+
+### 交叉编译
+
+```bash
+export TOOLCHAIN_ROOT="cpp/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu"
+
+bash cpp/build_ax650.sh
+bash cpp/build_ax630c.sh
+```
+
+编译结果：
+
+```text
+cpp/bin/openwakeword_ax650
+cpp/bin/openwakeword_ax630c
+```
+
+### 板端批量测试
+
+AX650：
+
+```bash
+THRESHOLD=0.5 bash cpp/run_batch_openwakeword_ax650.sh
+```
+
+AX630C：
+
+```bash
+THRESHOLD=0.5 bash cpp/run_batch_openwakeword_ax630c.sh
+```
+
+结果分别写入 `outputs/cpp_ax650_batch/` 和 `outputs/cpp_ax630c_batch/`。
+
+详细 C++ 说明见 `cpp/README.md`。
+
+## 参考
+
+- [openWakeWord](https://github.com/dscripka/openWakeWord)
+- [Pulsar2](https://pulsar2-docs.readthedocs.io/en/latest/pulsar2/introduction.html)

config.json

@@ -0,0 +1,9 @@
+{
+  "model_type": "keyword-spotting",
+  "source": "openWakeWord",
+  "target_hardware": "AX630C/AX650",
+  "runtime": "axengine",
+  "sample_rate": 16000,
+  "default_threshold": 0.5,
+  "mel_backend": "numpy"
+}

config/openwakeword_mel_weights.bin

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

config/openwakeword_mel_weights.npz

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

cpp/CMakeLists.txt

@@ -0,0 +1,57 @@
+cmake_minimum_required(VERSION 3.13)
+project(openwakeword_axera_cpp LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_BUILD_TYPE Release CACHE STRING "")
+
+set(AXERA_TARGET "AX650" CACHE STRING "AXERA target: AX650 or AX630C")
+set_property(CACHE AXERA_TARGET PROPERTY STRINGS AX650 AX630C)
+string(TOUPPER "${AXERA_TARGET}" AXERA_TARGET)
+if(AXERA_TARGET STREQUAL "AX650")
+  set(KWS_EXECUTABLE openwakeword_ax650)
+  set(DEFAULT_BSP_MSP_DIR
+      "${CMAKE_SOURCE_DIR}/toolchains/ax650n_bsp_sdk/msp/out")
+elseif(AXERA_TARGET STREQUAL "AX630C")
+  set(KWS_EXECUTABLE openwakeword_ax630c)
+  set(DEFAULT_BSP_MSP_DIR
+      "${CMAKE_SOURCE_DIR}/toolchains/ax620e_bsp_sdk/msp/out/arm64_glibc")
+else()
+  message(FATAL_ERROR "AXERA_TARGET must be AX650 or AX630C")
+endif()
+
+set(BSP_MSP_DIR "${DEFAULT_BSP_MSP_DIR}" CACHE PATH
+    "BSP directory containing include/ and lib/")
+if(NOT EXISTS "${BSP_MSP_DIR}/include/ax_engine_api.h")
+  message(FATAL_ERROR
+          "${AXERA_TARGET} BSP not found: ${BSP_MSP_DIR}. "
+          "Set BSP_MSP_DIR to the directory containing include/ and lib/.")
+endif()
+
+add_executable(${KWS_EXECUTABLE}
+  openwakeword_ax.cpp
+  src/engine_wrapper.cpp
+)
+target_include_directories(${KWS_EXECUTABLE} PRIVATE
+  ${CMAKE_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}/src
+  ${BSP_MSP_DIR}/include
+)
+target_link_directories(${KWS_EXECUTABLE} PRIVATE ${BSP_MSP_DIR}/lib)
+target_compile_definitions(${KWS_EXECUTABLE} PRIVATE
+  AXERA_TARGET_NAME="${AXERA_TARGET}"
+)
+target_compile_options(${KWS_EXECUTABLE} PRIVATE
+  -O3 -Wall -Wextra -Wpedantic
+  -fvisibility=hidden -fdata-sections -ffunction-sections
+)
+target_link_libraries(${KWS_EXECUTABLE} PRIVATE
+  ax_sys ax_engine ax_interpreter pthread dl m
+)
+target_link_options(${KWS_EXECUTABLE} PRIVATE
+  -Wl,--enable-new-dtags -Wl,--allow-shlib-undefined
+)
+set_target_properties(${KWS_EXECUTABLE} PROPERTIES
+  BUILD_WITH_INSTALL_RPATH TRUE
+  INSTALL_RPATH "$ORIGIN"
+)

cpp/README.md

@@ -0,0 +1,89 @@
+# openWakeWord C++ 推理
+
+本目录提供 AX650 和 AX630C C++ 推理程序。WAV、STFT、mel 和缓存更新在 CPU
+端完成，embedding 与 classifier 使用对应平台的 `axmodel`。
+
+## 编译环境
+
+AX650 与 AX630C 共用 Arm GNU 9.2 AArch64 交叉编译器：
+
+```bash
+mkdir -p cpp/toolchains
+wget -P cpp/toolchains \
+  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 cpp/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz \
+  -C cpp/toolchains
+```
+
+下载 BSP：
+
+```bash
+bash cpp/download_bsp.sh all
+```
+
+| 平台 | BSP 压缩包 | 编译目录 |
+| --- | --- | --- |
+| AX650 | `msp_50_3.10.2.zip` | `cpp/toolchains/ax650n_bsp_sdk/msp/out` |
+| AX630C | `msp_20e_3.0.0.zip` | `cpp/toolchains/ax620e_bsp_sdk/msp/out/arm64_glibc` |
+
+## 交叉编译
+
+```bash
+export TOOLCHAIN_ROOT="cpp/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu"
+
+bash cpp/build_ax650.sh
+bash cpp/build_ax630c.sh
+```
+
+生成：
+
+```text
+cpp/bin/openwakeword_ax650
+cpp/bin/openwakeword_ax630c
+```
+
+如 BSP 放在其他位置，可设置 `BSP_MSP_DIR`。AX650 应指向包含 `include/` 和
+`lib/` 的 `msp/out`；AX630C 应指向 `msp/out/arm64_glibc`。
+
+## 板端运行
+
+AX650 单条推理：
+
+```bash
+AUDIO=audio/openwakeword/alexa_test.wav \
+bash cpp/run_openwakeword_ax650.sh
+```
+
+AX630C 单条推理：
+
+```bash
+AUDIO=audio/openwakeword/alexa_test.wav \
+bash cpp/run_openwakeword_ax630c.sh
+```
+
+批量测试：
+
+```bash
+THRESHOLD=0.5 bash cpp/run_batch_openwakeword_ax650.sh
+THRESHOLD=0.5 bash cpp/run_batch_openwakeword_ax630c.sh
+```
+
+模型目录必须与平台对应：
+
+```text
+models/650/
+models/630C/
+```
+
+运行脚本会检查 embedding 和 6 个 classifier 模型，避免误用其他平台的 axmodel。
+输入音频必须为 16 kHz、单声道、16-bit PCM WAV。
+
+单条推理会输出 classifier 分数和 `WAKEUP`，并只输出一个 `rtf`。`rtf` 包含
+CPU mel 和 NPU 推理，不包含一次性模型加载与初始化。
+
+阈值可通过环境变量调整：
+
+```bash
+THRESHOLD=0.6 AUDIO=audio/openwakeword/hey_mycroft_test.wav \
+bash cpp/run_openwakeword_ax630c.sh
+```

cpp/build_ax630c.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CPP_DIR="${ROOT}/cpp"
+TOOLCHAIN_ROOT="${TOOLCHAIN_ROOT:-${CPP_DIR}/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu}"
+BSP_MSP_DIR="${BSP_MSP_DIR:-${CPP_DIR}/toolchains/ax620e_bsp_sdk/msp/out/arm64_glibc}"
+BUILD_DIR="${CPP_DIR}/build/ax630c"
+
+if [[ ! -x "${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-g++" ]]; then
+  echo "ERROR: AArch64 toolchain not found: ${TOOLCHAIN_ROOT}" >&2
+  exit 2
+fi
+if [[ ! -f "${BSP_MSP_DIR}/include/ax_engine_api.h" ]]; then
+  echo "ERROR: AX630C BSP arm64_glibc directory not found: ${BSP_MSP_DIR}" >&2
+  exit 2
+fi
+
+mkdir -p "${BUILD_DIR}" "${CPP_DIR}/bin"
+cmake -S "${CPP_DIR}" -B "${BUILD_DIR}" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_SYSTEM_NAME=Linux \
+  -DCMAKE_SYSTEM_PROCESSOR=aarch64 \
+  -DCMAKE_C_COMPILER="${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-gcc" \
+  -DCMAKE_CXX_COMPILER="${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-g++" \
+  -DAXERA_TARGET=AX630C \
+  -DBSP_MSP_DIR="${BSP_MSP_DIR}"
+cmake --build "${BUILD_DIR}" -j"$(nproc)"
+cp "${BUILD_DIR}/openwakeword_ax630c" "${CPP_DIR}/bin/"
+"${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-strip" --strip-unneeded \
+  "${CPP_DIR}/bin/openwakeword_ax630c"
+echo "Built ${CPP_DIR}/bin/openwakeword_ax630c"

cpp/build_ax650.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CPP_DIR="${ROOT}/cpp"
+TOOLCHAIN_ROOT="${TOOLCHAIN_ROOT:-${CPP_DIR}/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu}"
+BSP_MSP_DIR="${BSP_MSP_DIR:-${CPP_DIR}/toolchains/ax650n_bsp_sdk/msp/out}"
+BUILD_DIR="${CPP_DIR}/build/ax650"
+
+if [[ ! -x "${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-g++" ]]; then
+  echo "ERROR: AArch64 toolchain not found: ${TOOLCHAIN_ROOT}" >&2
+  exit 2
+fi
+if [[ ! -f "${BSP_MSP_DIR}/include/ax_engine_api.h" ]]; then
+  echo "ERROR: AX650 BSP msp/out not found: ${BSP_MSP_DIR}" >&2
+  exit 2
+fi
+
+mkdir -p "${BUILD_DIR}" "${CPP_DIR}/bin"
+cmake -S "${CPP_DIR}" -B "${BUILD_DIR}" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_SYSTEM_NAME=Linux \
+  -DCMAKE_SYSTEM_PROCESSOR=aarch64 \
+  -DCMAKE_C_COMPILER="${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-gcc" \
+  -DCMAKE_CXX_COMPILER="${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-g++" \
+  -DAXERA_TARGET=AX650 \
+  -DBSP_MSP_DIR="${BSP_MSP_DIR}"
+cmake --build "${BUILD_DIR}" -j"$(nproc)"
+cp "${BUILD_DIR}/openwakeword_ax650" "${CPP_DIR}/bin/"
+"${TOOLCHAIN_ROOT}/bin/aarch64-none-linux-gnu-strip" --strip-unneeded \
+  "${CPP_DIR}/bin/openwakeword_ax650"
+echo "Built ${CPP_DIR}/bin/openwakeword_ax650"

cpp/download_bsp.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+CPP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TOOLCHAINS_DIR="${CPP_DIR}/toolchains"
+PLATFORM="${1:-all}"
+
+download_sdk() {
+  local directory="$1"
+  local archive_name="$2"
+  local extracted_name="$3"
+  local url="$4"
+
+  if [[ -d "${TOOLCHAINS_DIR}/${directory}" ]]; then
+    echo "Found ${TOOLCHAINS_DIR}/${directory}"
+    return
+  fi
+  mkdir -p "${TOOLCHAINS_DIR}"
+  wget -c "${url}" -O "${TOOLCHAINS_DIR}/${archive_name}"
+  unzip -q "${TOOLCHAINS_DIR}/${archive_name}" -d "${TOOLCHAINS_DIR}"
+  mv "${TOOLCHAINS_DIR}/${extracted_name}" "${TOOLCHAINS_DIR}/${directory}"
+  rm -f "${TOOLCHAINS_DIR}/${archive_name}"
+  echo "Downloaded ${TOOLCHAINS_DIR}/${directory}"
+}
+
+case "${PLATFORM}" in
+  650|AX650|ax650)
+    download_sdk \
+      ax650n_bsp_sdk msp_50_3.10.2.zip msp_50_3.10.2 \
+      https://github.com/ZHEQIUSHUI/assets/releases/download/ax_3.6.2/msp_50_3.10.2.zip
+    ;;
+  630C|AX630C|ax630c)
+    download_sdk \
+      ax620e_bsp_sdk msp_20e_3.0.0.zip msp_20e_3.0.0 \
+      https://github.com/ZHEQIUSHUI/assets/releases/download/ax_3.6.2/msp_20e_3.0.0.zip
+    ;;
+  all)
+    bash "${BASH_SOURCE[0]}" 650
+    bash "${BASH_SOURCE[0]}" 630C
+    ;;
+  *)
+    echo "Usage: bash cpp/download_bsp.sh [650|630C|all]" >&2
+    exit 2
+    ;;
+esac

cpp/openwakeword_ax.cpp

@@ -0,0 +1,379 @@
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "ax_engine_api.h"
+#include "ax_sys_api.h"
+#include "src/engine_wrapper.hpp"
+#include "src/wav_reader.hpp"
+
+#ifndef AXERA_TARGET_NAME
+#define AXERA_TARGET_NAME "AXERA"
+#endif
+
+namespace {
+constexpr int kSampleRate = 16000;
+constexpr int kChunkSamples = 1280;
+constexpr int kHistorySamples = 480;
+constexpr int kFftSize = 512;
+constexpr int kSpectrumBins = 257;
+constexpr int kMelBins = 32;
+constexpr int kMelFrames = 8;
+constexpr int kEmbeddingFrames = 76;
+constexpr int kEmbeddingSize = 96;
+constexpr int kFeatureFrames = 34;
+using Clock = std::chrono::steady_clock;
+
+double ElapsedSeconds(Clock::time_point begin, Clock::time_point end) {
+  return std::chrono::duration<double>(end - begin).count();
+}
+
+struct Args {
+  std::string models_dir = "models";
+  std::string weights = "config/openwakeword_mel_weights.bin";
+  std::string audio = "audio/openwakeword/alexa_test.wav";
+  float threshold = 0.5f;
+};
+
+void Usage(const char *program) {
+  std::printf(
+      "Usage: %s [--models-dir DIR] [--mel-weights FILE] [--audio WAV] "
+      "[--threshold VALUE]\n",
+      program);
+}
+
+Args ParseArgs(int argc, char **argv) {
+  Args args;
+  for (int i = 1; i < argc; ++i) {
+    const std::string key = argv[i];
+    auto value = [&]() -> std::string {
+      if (++i >= argc) throw std::runtime_error("Missing value for " + key);
+      return argv[i];
+    };
+    if (key == "--models-dir") {
+      args.models_dir = value();
+    } else if (key == "--mel-weights") {
+      args.weights = value();
+    } else if (key == "--audio") {
+      args.audio = value();
+    } else if (key == "--threshold") {
+      args.threshold = std::stof(value());
+    } else if (key == "-h" || key == "--help") {
+      Usage(argv[0]);
+      std::exit(0);
+    } else {
+      throw std::runtime_error("Unknown argument: " + key);
+    }
+  }
+  return args;
+}
+
+std::string Join(const std::string &left, const std::string &right) {
+  return left.empty() || left.back() == '/' ? left + right
+                                             : left + "/" + right;
+}
+
+class AxRuntime {
+ public:
+  AxRuntime() {
+    if (AX_SYS_Init() != 0) throw std::runtime_error("AX_SYS_Init failed");
+    sys_initialized_ = true;
+    AX_ENGINE_NPU_ATTR_T attr{};
+    if (AX_ENGINE_Init(&attr) != 0) {
+      AX_SYS_Deinit();
+      sys_initialized_ = false;
+      throw std::runtime_error("AX_ENGINE_Init failed");
+    }
+    engine_initialized_ = true;
+  }
+  ~AxRuntime() {
+    if (engine_initialized_) AX_ENGINE_Deinit();
+    if (sys_initialized_) AX_SYS_Deinit();
+  }
+
+ private:
+  bool sys_initialized_ = false;
+  bool engine_initialized_ = false;
+};
+
+template <typename T>
+T ReadScalar(std::istream &input) {
+  T value{};
+  input.read(reinterpret_cast<char *>(&value), sizeof(value));
+  if (!input) throw std::runtime_error("Truncated mel weight file");
+  return value;
+}
+
+struct MelWeights {
+  std::vector<float> real;
+  std::vector<float> imag;
+  std::vector<float> mel;
+  float floor = 0.0f;
+
+  static MelWeights Load(const std::string &path) {
+    std::ifstream input(path, std::ios::binary);
+    if (!input) throw std::runtime_error("Cannot open mel weights: " + path);
+    char magic[8]{};
+    input.read(magic, 8);
+    if (std::memcmp(magic, "OWWMEL1", 7) != 0 ||
+        ReadScalar<uint32_t>(input) != 1) {
+      throw std::runtime_error("Invalid openWakeWord mel weight file");
+    }
+    const uint32_t real_rows = ReadScalar<uint32_t>(input);
+    const uint32_t real_cols = ReadScalar<uint32_t>(input);
+    const uint32_t imag_rows = ReadScalar<uint32_t>(input);
+    const uint32_t imag_cols = ReadScalar<uint32_t>(input);
+    const uint32_t mel_rows = ReadScalar<uint32_t>(input);
+    const uint32_t mel_cols = ReadScalar<uint32_t>(input);
+    MelWeights result;
+    result.floor = ReadScalar<float>(input);
+    if (real_rows != kSpectrumBins || real_cols != kFftSize ||
+        imag_rows != kSpectrumBins || imag_cols != kFftSize ||
+        mel_rows != kSpectrumBins || mel_cols != kMelBins) {
+      throw std::runtime_error("Unexpected openWakeWord mel weight shapes");
+    }
+    result.real.resize(static_cast<std::size_t>(real_rows) * real_cols);
+    result.imag.resize(static_cast<std::size_t>(imag_rows) * imag_cols);
+    result.mel.resize(static_cast<std::size_t>(mel_rows) * mel_cols);
+    input.read(reinterpret_cast<char *>(result.real.data()),
+               result.real.size() * sizeof(float));
+    input.read(reinterpret_cast<char *>(result.imag.data()),
+               result.imag.size() * sizeof(float));
+    input.read(reinterpret_cast<char *>(result.mel.data()),
+               result.mel.size() * sizeof(float));
+    if (!input) throw std::runtime_error("Truncated openWakeWord mel weights");
+    return result;
+  }
+};
+
+std::array<float, kMelFrames * kMelBins> ComputeMel(
+    const std::array<float, kHistorySamples + kChunkSamples> &samples,
+    const MelWeights &weights) {
+  std::array<float, kMelFrames * kMelBins> result{};
+  std::array<float, kSpectrumBins> power{};
+  float max_db = -std::numeric_limits<float>::infinity();
+  for (int frame = 0; frame < kMelFrames; ++frame) {
+    const float *frame_samples = samples.data() + frame * 160;
+    for (int frequency = 0; frequency < kSpectrumBins; ++frequency) {
+      const float *real = weights.real.data() + frequency * kFftSize;
+      const float *imag = weights.imag.data() + frequency * kFftSize;
+      float real_sum = 0.0f;
+      float imag_sum = 0.0f;
+      for (int n = 0; n < kFftSize; ++n) {
+        real_sum += frame_samples[n] * real[n];
+        imag_sum += frame_samples[n] * imag[n];
+      }
+      power[frequency] = real_sum * real_sum + imag_sum * imag_sum;
+    }
+    for (int bin = 0; bin < kMelBins; ++bin) {
+      float value = 0.0f;
+      for (int frequency = 0; frequency < kSpectrumBins; ++frequency) {
+        value += power[frequency] *
+                 weights.mel[frequency * kMelBins + bin];
+      }
+      value = std::max(value, weights.floor);
+      const float db = std::log(value) * 10.0f / 2.3025851249694824f;
+      result[frame * kMelBins + bin] = db;
+      max_db = std::max(max_db, db);
+    }
+  }
+  const float minimum = max_db - 80.0f;
+  for (float &value : result) {
+    value = std::max(value, minimum) / 10.0f + 2.0f;
+  }
+  return result;
+}
+
+struct Classifier {
+  std::string name;
+  int frames;
+  EngineWrapper engine;
+  std::vector<float> maximum;
+};
+
+void Run(const Args &args) {
+  const PcmWav wav = ReadPcmWav(args.audio);
+  if (wav.sample_rate != kSampleRate) {
+    throw std::runtime_error("Input WAV must use 16 kHz sample rate");
+  }
+  const double audio_seconds =
+      static_cast<double>(wav.samples.size()) / kSampleRate;
+  if (audio_seconds <= 0.0) {
+    throw std::runtime_error("Input WAV contains no samples");
+  }
+  const MelWeights weights = MelWeights::Load(args.weights);
+  const auto model_load_begin = Clock::now();
+  AxRuntime runtime;
+
+  EngineWrapper embedding;
+  if (embedding.Init(Join(args.models_dir,
+                          "openwakeword__embedding_model.axmodel")) != 0) {
+    throw std::runtime_error("Failed to load embedding model");
+  }
+  const std::array<std::pair<const char *, int>, 6> definitions{{
+      {"alexa_v0.1", 16},
+      {"hey_jarvis_v0.1", 16},
+      {"hey_mycroft_v0.1", 16},
+      {"hey_rhasspy_v0.1", 16},
+      {"timer_v0.1", 34},
+      {"weather_v0.1", 22},
+  }};
+  std::array<Classifier, 6> classifiers;
+  for (std::size_t classifier_index = 0;
+       classifier_index < definitions.size(); ++classifier_index) {
+    const auto &definition = definitions[classifier_index];
+    Classifier &classifier = classifiers[classifier_index];
+    classifier.name = definition.first;
+    classifier.frames = definition.second;
+    const std::string model =
+        Join(args.models_dir, "openwakeword__" + classifier.name + ".axmodel");
+    if (classifier.engine.Init(model) != 0) {
+      throw std::runtime_error("Failed to load classifier: " + classifier.name);
+    }
+    const int output_bytes = classifier.engine.GetOutputSizeByName(
+        classifier.engine.OutputName(0));
+    if (output_bytes <= 0 || output_bytes % sizeof(float) != 0) {
+      throw std::runtime_error("Unexpected classifier output: " +
+                               classifier.name);
+    }
+    classifier.maximum.assign(output_bytes / sizeof(float),
+                              -std::numeric_limits<float>::infinity());
+  }
+  const double model_load_seconds =
+      ElapsedSeconds(model_load_begin, Clock::now());
+
+  std::vector<int16_t> padded = wav.samples;
+  const std::size_t remainder = padded.size() % kChunkSamples;
+  if (remainder != 0) padded.resize(padded.size() + kChunkSamples - remainder);
+  std::array<int16_t, kHistorySamples> history{};
+  std::array<float, kEmbeddingFrames * kMelBins> mel_buffer{};
+  mel_buffer.fill(1.0f);
+  std::array<float, kFeatureFrames * kEmbeddingSize> feature_buffer{};
+  int chunks = 0;
+  double feature_seconds = 0.0;
+  double npu_seconds = 0.0;
+  const auto inference_begin = Clock::now();
+
+  for (std::size_t start = 0; start < padded.size(); start += kChunkSamples) {
+    std::array<float, kHistorySamples + kChunkSamples> mel_input{};
+    for (int i = 0; i < kHistorySamples; ++i) mel_input[i] = history[i];
+    for (int i = 0; i < kChunkSamples; ++i) {
+      mel_input[kHistorySamples + i] = padded[start + i];
+    }
+    for (int i = 0; i < kHistorySamples; ++i) {
+      history[i] = padded[start + kChunkSamples - kHistorySamples + i];
+    }
+    const auto feature_begin = Clock::now();
+    const auto mel = ComputeMel(mel_input, weights);
+    feature_seconds += ElapsedSeconds(feature_begin, Clock::now());
+    std::memmove(mel_buffer.data(), mel_buffer.data() + kMelFrames * kMelBins,
+                 (kEmbeddingFrames - kMelFrames) * kMelBins * sizeof(float));
+    std::memcpy(mel_buffer.data() +
+                    (kEmbeddingFrames - kMelFrames) * kMelBins,
+                mel.data(), mel.size() * sizeof(float));
+
+    const std::string &embedding_input = embedding.InputName(0);
+    if (embedding.SetInputByName(embedding_input, mel_buffer.data(),
+                                 mel_buffer.size() * sizeof(float)) != 0) {
+      throw std::runtime_error("Failed to set embedding input");
+    }
+    const auto embedding_begin = Clock::now();
+    const int embedding_ret = embedding.RunSync();
+    npu_seconds += ElapsedSeconds(embedding_begin, Clock::now());
+    if (embedding_ret != 0) {
+      throw std::runtime_error("Embedding inference failed");
+    }
+    std::array<float, kEmbeddingSize> feature{};
+    if (embedding.GetOutputByName(embedding.OutputName(0), feature.data(),
+                                  feature.size() * sizeof(float)) != 0) {
+      throw std::runtime_error("Failed to read embedding output");
+    }
+    std::memmove(feature_buffer.data(), feature_buffer.data() + kEmbeddingSize,
+                 (kFeatureFrames - 1) * kEmbeddingSize * sizeof(float));
+    std::memcpy(feature_buffer.data() +
+                    (kFeatureFrames - 1) * kEmbeddingSize,
+                feature.data(), feature.size() * sizeof(float));
+
+    for (Classifier &classifier : classifiers) {
+      const float *input =
+          feature_buffer.data() +
+          (kFeatureFrames - classifier.frames) * kEmbeddingSize;
+      const std::string &input_name = classifier.engine.InputName(0);
+      if (classifier.engine.SetInputByName(
+              input_name, input,
+              classifier.frames * kEmbeddingSize * sizeof(float)) != 0) {
+        throw std::runtime_error("Failed to set classifier input: " +
+                                 classifier.name);
+      }
+      const auto classifier_begin = Clock::now();
+      const int classifier_ret = classifier.engine.RunSync();
+      npu_seconds += ElapsedSeconds(classifier_begin, Clock::now());
+      if (classifier_ret != 0) {
+        throw std::runtime_error("Classifier inference failed: " +
+                                 classifier.name);
+      }
+      std::vector<float> output(classifier.maximum.size());
+      if (classifier.engine.GetOutputByName(
+              classifier.engine.OutputName(0), output.data(),
+              output.size() * sizeof(float)) != 0) {
+        throw std::runtime_error("Failed to read classifier output");
+      }
+      for (std::size_t i = 0; i < output.size(); ++i) {
+        classifier.maximum[i] = std::max(classifier.maximum[i], output[i]);
+      }
+    }
+    ++chunks;
+  }
+  const double inference_seconds =
+      ElapsedSeconds(inference_begin, Clock::now());
+  const double rtf = inference_seconds / audio_seconds;
+
+  std::printf("\nopenWakeWord C++ inference complete\n");
+  std::printf("target: %s\naudio: %s\nchunks: %d\nthreshold: %.3f\n",
+              AXERA_TARGET_NAME, args.audio.c_str(), chunks, args.threshold);
+  bool detected = false;
+  for (const Classifier &classifier : classifiers) {
+    std::printf("%-22s", classifier.name.c_str());
+    float score = -std::numeric_limits<float>::infinity();
+    for (std::size_t i = 0; i < classifier.maximum.size(); ++i) {
+      const float value = classifier.maximum[i];
+      std::printf(" %.6f", value);
+      if (classifier.name != "timer_v0.1" || i != 0) {
+        score = std::max(score, value);
+      }
+    }
+    if (score >= args.threshold) {
+      std::printf("  WAKEUP");
+      detected = true;
+    }
+    std::printf("\n");
+  }
+  std::printf("detected: %s\n", detected ? "true" : "false");
+  std::printf("audio_seconds: %.6f\n", audio_seconds);
+  std::printf("feature_seconds: %.6f\n", feature_seconds);
+  std::printf("npu_seconds: %.6f\n", npu_seconds);
+  std::printf("model_load_seconds: %.6f\n", model_load_seconds);
+  std::printf("inference_seconds: %.6f\n", inference_seconds);
+  std::printf("rtf: %.6f\n", rtf);
+}
+}  // namespace
+
+int main(int argc, char **argv) {
+  try {
+    const Args args = ParseArgs(argc, argv);
+    Run(args);
+    return 0;
+  } catch (const std::exception &error) {
+    std::fprintf(stderr, "ERROR: %s\n", error.what());
+    return 1;
+  }
+}

cpp/run_batch_openwakeword_ax.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TARGET="${AXERA_TARGET:-AX650}"
+AUDIO_DIR="${AUDIO_DIR:-${ROOT}/audio/openwakeword}"
+THRESHOLD="${THRESHOLD:-0.5}"
+
+case "${TARGET}" in
+  AX650)
+    TARGET_SLUG="ax650"
+    BINARY="${ROOT}/cpp/bin/openwakeword_ax650"
+    MODELS_DIR="${MODELS_DIR:-${ROOT}/models/650}"
+    BSP_LIB_DIR="${AXERA_BSP_LIB_DIR:-${AX650_BSP_LIB_DIR:-${ROOT}/cpp/toolchains/ax650n_bsp_sdk/msp/out/lib}}"
+    BUILD_SCRIPT="cpp/build_ax650.sh"
+    ;;
+  AX630C)
+    TARGET_SLUG="ax630c"
+    BINARY="${ROOT}/cpp/bin/openwakeword_ax630c"
+    MODELS_DIR="${MODELS_DIR:-${ROOT}/models/630C}"
+    BSP_LIB_DIR="${AXERA_BSP_LIB_DIR:-${AX630C_BSP_LIB_DIR:-${ROOT}/cpp/toolchains/ax620e_bsp_sdk/msp/out/arm64_glibc/lib}}"
+    BUILD_SCRIPT="cpp/build_ax630c.sh"
+    ;;
+  *)
+    echo "ERROR: AXERA_TARGET must be AX650 or AX630C" >&2
+    exit 2
+    ;;
+esac
+
+OUTPUT_DIR="${OUTPUT_DIR:-${ROOT}/outputs/cpp_${TARGET_SLUG}_batch}"
+if [[ ! -x "${BINARY}" ]]; then
+  echo "ERROR: ${BINARY} is missing; run bash ${BUILD_SCRIPT} first" >&2
+  exit 2
+fi
+if [[ ! -d "${AUDIO_DIR}" ]]; then
+  echo "ERROR: audio directory does not exist: ${AUDIO_DIR}" >&2
+  exit 2
+fi
+for name in embedding_model alexa_v0.1 hey_jarvis_v0.1 hey_mycroft_v0.1 \
+    hey_rhasspy_v0.1 timer_v0.1 weather_v0.1; do
+  model="${MODELS_DIR}/openwakeword__${name}.axmodel"
+  if [[ ! -f "${model}" ]]; then
+    echo "ERROR: ${TARGET} model is missing: ${model}" >&2
+    exit 2
+  fi
+done
+
+mapfile -d '' AUDIO_FILES < <(
+  find "${AUDIO_DIR}" -maxdepth 1 -type f -iname '*.wav' -print0 | sort -z
+)
+if [[ "${#AUDIO_FILES[@]}" -eq 0 ]]; then
+  echo "ERROR: no WAV files found under ${AUDIO_DIR}" >&2
+  exit 2
+fi
+
+mkdir -p "${OUTPUT_DIR}/logs"
+RESULTS="${OUTPUT_DIR}/results.tsv"
+SUMMARY="${OUTPUT_DIR}/summary.txt"
+printf 'file\taudio_seconds\tfeature_seconds\tnpu_seconds\tinference_seconds\trtf\tmodel_load_seconds\tdetections\n' > "${RESULTS}"
+
+export LD_LIBRARY_PATH="${BSP_LIB_DIR}:${LD_LIBRARY_PATH:-}"
+for audio in "${AUDIO_FILES[@]}"; do
+  name="$(basename "${audio}")"
+  stem="${name%.*}"
+  log="${OUTPUT_DIR}/logs/${stem}.log"
+  echo "[RUN] target=${TARGET} ${name} threshold=${THRESHOLD}"
+  "${BINARY}" \
+    --models-dir "${MODELS_DIR}" \
+    --mel-weights "${ROOT}/config/openwakeword_mel_weights.bin" \
+    --audio "${audio}" \
+    --threshold "${THRESHOLD}" > "${log}" 2>&1
+  cat "${log}"
+
+  field() {
+    awk -F': ' -v key="$1" '$1 == key {print $2; exit}' "${log}"
+  }
+  audio_seconds="$(field audio_seconds)"
+  feature_seconds="$(field feature_seconds)"
+  npu_seconds="$(field npu_seconds)"
+  inference_seconds="$(field inference_seconds)"
+  rtf="$(field rtf)"
+  model_load_seconds="$(field model_load_seconds)"
+  detections="$(awk '$NF == "WAKEUP" {print $1}' "${log}" | paste -sd ',' -)"
+  detections="${detections:-none}"
+
+  for value in "${audio_seconds}" "${feature_seconds}" "${npu_seconds}" \
+      "${inference_seconds}" "${rtf}" "${model_load_seconds}"; do
+    if [[ -z "${value}" ]]; then
+      echo "ERROR: timing field missing from ${log}" >&2
+      exit 1
+    fi
+  done
+  printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
+    "${name}" "${audio_seconds}" "${feature_seconds}" "${npu_seconds}" \
+    "${inference_seconds}" "${rtf}" "${model_load_seconds}" "${detections}" \
+    >> "${RESULTS}"
+done
+
+awk -F'\t' '
+  NR > 1 {
+    files += 1
+    audio += $2
+    feature += $3
+    npu += $4
+    inference += $5
+    model_load += $7
+  }
+  END {
+    printf "files: %d\n", files
+    printf "total_audio_seconds: %.6f\n", audio
+    printf "total_feature_seconds: %.6f\n", feature
+    printf "total_npu_seconds: %.6f\n", npu
+    printf "total_inference_seconds: %.6f\n", inference
+    printf "total_model_load_seconds: %.6f\n", model_load
+    printf "rtf: %.6f\n", inference / audio
+  }
+' "${RESULTS}" > "${SUMMARY}"
+
+echo "[SUMMARY]"
+cat "${SUMMARY}"
+echo "results: ${RESULTS}"
+echo "logs: ${OUTPUT_DIR}/logs"

cpp/run_batch_openwakeword_ax630c.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+AXERA_TARGET=AX630C exec bash "${ROOT}/cpp/run_batch_openwakeword_ax.sh"

cpp/run_batch_openwakeword_ax650.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+AXERA_TARGET=AX650 exec bash "${ROOT}/cpp/run_batch_openwakeword_ax.sh"

cpp/run_openwakeword_ax.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TARGET="${AXERA_TARGET:-AX650}"
+AUDIO="${AUDIO:-${ROOT}/audio/openwakeword/alexa_test.wav}"
+THRESHOLD="${THRESHOLD:-0.5}"
+
+case "${TARGET}" in
+  AX650)
+    BINARY="${ROOT}/cpp/bin/openwakeword_ax650"
+    MODELS_DIR="${MODELS_DIR:-${ROOT}/models/650}"
+    BSP_LIB_DIR="${AXERA_BSP_LIB_DIR:-${AX650_BSP_LIB_DIR:-${ROOT}/cpp/toolchains/ax650n_bsp_sdk/msp/out/lib}}"
+    BUILD_SCRIPT="cpp/build_ax650.sh"
+    ;;
+  AX630C)
+    BINARY="${ROOT}/cpp/bin/openwakeword_ax630c"
+    MODELS_DIR="${MODELS_DIR:-${ROOT}/models/630C}"
+    BSP_LIB_DIR="${AXERA_BSP_LIB_DIR:-${AX630C_BSP_LIB_DIR:-${ROOT}/cpp/toolchains/ax620e_bsp_sdk/msp/out/arm64_glibc/lib}}"
+    BUILD_SCRIPT="cpp/build_ax630c.sh"
+    ;;
+  *)
+    echo "ERROR: AXERA_TARGET must be AX650 or AX630C" >&2
+    exit 2
+    ;;
+esac
+
+if [[ ! -x "${BINARY}" ]]; then
+  echo "ERROR: ${BINARY} is missing; run bash ${BUILD_SCRIPT} first" >&2
+  exit 2
+fi
+for name in embedding_model alexa_v0.1 hey_jarvis_v0.1 hey_mycroft_v0.1 \
+    hey_rhasspy_v0.1 timer_v0.1 weather_v0.1; do
+  model="${MODELS_DIR}/openwakeword__${name}.axmodel"
+  if [[ ! -f "${model}" ]]; then
+    echo "ERROR: ${TARGET} model is missing: ${model}" >&2
+    exit 2
+  fi
+done
+
+export LD_LIBRARY_PATH="${BSP_LIB_DIR}:${LD_LIBRARY_PATH:-}"
+exec "${BINARY}" \
+  --models-dir "${MODELS_DIR}" \
+  --mel-weights "${ROOT}/config/openwakeword_mel_weights.bin" \
+  --audio "${AUDIO}" \
+  --threshold "${THRESHOLD}"

cpp/run_openwakeword_ax630c.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+AXERA_TARGET=AX630C exec bash "${ROOT}/cpp/run_openwakeword_ax.sh"

cpp/run_openwakeword_ax650.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+AXERA_TARGET=AX650 exec bash "${ROOT}/cpp/run_openwakeword_ax.sh"

cpp/src/engine_wrapper.cpp

@@ -0,0 +1,197 @@
+#include "engine_wrapper.hpp"
+
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <vector>
+
+#include "ax_sys_api.h"
+
+namespace {
+constexpr int kAlignment = 128;
+
+void FreeIo(AX_ENGINE_IO_T *io) {
+  for (AX_U32 i = 0; io->pInputs && i < io->nInputSize; ++i) {
+    if (io->pInputs[i].pVirAddr) {
+      AX_SYS_MemFree(io->pInputs[i].phyAddr, io->pInputs[i].pVirAddr);
+    }
+  }
+  for (AX_U32 i = 0; io->pOutputs && i < io->nOutputSize; ++i) {
+    if (io->pOutputs[i].pVirAddr) {
+      AX_SYS_MemFree(io->pOutputs[i].phyAddr, io->pOutputs[i].pVirAddr);
+    }
+  }
+  delete[] io->pInputs;
+  delete[] io->pOutputs;
+  std::memset(io, 0, sizeof(*io));
+}
+}  // namespace
+
+EngineWrapper::~EngineWrapper() { Release(); }
+
+int EngineWrapper::Init(const std::string &path) {
+  std::ifstream input(path, std::ios::binary);
+  if (!input) {
+    std::fprintf(stderr, "Failed to read model: %s\n", path.c_str());
+    return -1;
+  }
+  input.seekg(0, std::ios::end);
+  const std::streamoff model_size = input.tellg();
+  if (model_size <= 0 || model_size > static_cast<std::streamoff>(UINT32_MAX)) {
+    std::fprintf(stderr, "Invalid model size: %s\n", path.c_str());
+    return -1;
+  }
+  input.seekg(0, std::ios::beg);
+  std::vector<char> model(static_cast<std::size_t>(model_size));
+  input.read(model.data(), model_size);
+  if (!input) {
+    std::fprintf(stderr, "Failed to read model: %s\n", path.c_str());
+    return -1;
+  }
+  const AX_S32 create_ret = AX_ENGINE_CreateHandle(
+      &handle_, model.data(), static_cast<AX_U32>(model.size()));
+  if (create_ret != 0 || !handle_) {
+    std::fprintf(stderr, "AX_ENGINE_CreateHandle failed: %s ret=0x%x\n",
+                 path.c_str(), static_cast<unsigned>(create_ret));
+    return -1;
+  }
+  if (AX_ENGINE_CreateContext(handle_) != 0 ||
+      AX_ENGINE_GetIOInfo(handle_, &info_) != 0 || !info_) {
+    Release();
+    return -1;
+  }
+
+  io_.nInputSize = info_->nInputSize;
+  io_.nOutputSize = info_->nOutputSize;
+  io_.pInputs = new AX_ENGINE_IO_BUFFER_T[io_.nInputSize]{};
+  io_.pOutputs = new AX_ENGINE_IO_BUFFER_T[io_.nOutputSize]{};
+  AX_S8 input_tag[] = "KWS-INPUT";
+  AX_S8 output_tag[] = "KWS-OUTPUT";
+  for (AX_U32 i = 0; i < io_.nInputSize; ++i) {
+    io_.pInputs[i].nSize = info_->pInputs[i].nSize;
+    if (AX_SYS_MemAlloc(&io_.pInputs[i].phyAddr,
+                        &io_.pInputs[i].pVirAddr, io_.pInputs[i].nSize,
+                        kAlignment, input_tag) != 0) {
+      Release();
+      return -1;
+    }
+    const std::string name = info_->pInputs[i].pName;
+    inputs_[name] = static_cast<int>(i);
+    input_names_.push_back(name);
+  }
+  for (AX_U32 i = 0; i < io_.nOutputSize; ++i) {
+    io_.pOutputs[i].nSize = info_->pOutputs[i].nSize;
+    if (AX_SYS_MemAlloc(&io_.pOutputs[i].phyAddr,
+                        &io_.pOutputs[i].pVirAddr, io_.pOutputs[i].nSize,
+                        kAlignment, output_tag) != 0) {
+      Release();
+      return -1;
+    }
+    const std::string name = info_->pOutputs[i].pName;
+    outputs_[name] = static_cast<int>(i);
+    output_names_.push_back(name);
+  }
+  initialized_ = true;
+  std::printf("Loaded %s (inputs=%u outputs=%u)\n", path.c_str(),
+              io_.nInputSize, io_.nOutputSize);
+  return 0;
+}
+
+void EngineWrapper::Release() {
+  FreeIo(&io_);
+  if (handle_) AX_ENGINE_DestroyHandle(handle_);
+  initialized_ = false;
+  handle_ = nullptr;
+  info_ = nullptr;
+  inputs_.clear();
+  outputs_.clear();
+  input_names_.clear();
+  output_names_.clear();
+}
+
+int EngineWrapper::InputIndex(const std::string &name) const {
+  const auto it = inputs_.find(name);
+  return it == inputs_.end() ? -1 : it->second;
+}
+
+int EngineWrapper::OutputIndex(const std::string &name) const {
+  const auto it = outputs_.find(name);
+  return it == outputs_.end() ? -1 : it->second;
+}
+
+int EngineWrapper::SetInputByName(const std::string &name, const void *data,
+                                  std::size_t size) {
+  const int index = InputIndex(name);
+  if (!initialized_ || index < 0 || !data) return -1;
+  const std::size_t expected = io_.pInputs[index].nSize;
+  if (size != 0 && size != expected) return -1;
+  std::memcpy(io_.pInputs[index].pVirAddr, data, expected);
+  return 0;
+}
+
+int EngineWrapper::ZeroInputByName(const std::string &name) {
+  const int index = InputIndex(name);
+  if (!initialized_ || index < 0) return -1;
+  std::memset(io_.pInputs[index].pVirAddr, 0, io_.pInputs[index].nSize);
+  return 0;
+}
+
+int EngineWrapper::RunSync() {
+  if (!initialized_) return -1;
+  for (AX_U32 i = 0; i < io_.nInputSize; ++i) {
+    const AX_S32 flush_ret = AX_SYS_MflushCache(
+        io_.pInputs[i].phyAddr, io_.pInputs[i].pVirAddr,
+        io_.pInputs[i].nSize);
+    if (flush_ret != 0) {
+      std::fprintf(stderr, "AX_SYS_MflushCache failed input=%u ret=0x%x\n", i,
+                   static_cast<unsigned>(flush_ret));
+      return flush_ret;
+    }
+  }
+  const AX_S32 ret = AX_ENGINE_RunSync(handle_, &io_);
+  if (ret != 0) {
+    std::fprintf(stderr, "AX_ENGINE_RunSync failed ret=0x%x\n",
+                 static_cast<unsigned>(ret));
+    return ret;
+  }
+  for (AX_U32 i = 0; i < io_.nOutputSize; ++i) {
+    const AX_S32 invalidate_ret = AX_SYS_MinvalidateCache(
+        io_.pOutputs[i].phyAddr, io_.pOutputs[i].pVirAddr,
+        io_.pOutputs[i].nSize);
+    if (invalidate_ret != 0) {
+      std::fprintf(stderr,
+                   "AX_SYS_MinvalidateCache failed output=%u ret=0x%x\n", i,
+                   static_cast<unsigned>(invalidate_ret));
+      return invalidate_ret;
+    }
+  }
+  return 0;
+}
+
+int EngineWrapper::GetOutputByName(const std::string &name, void *data,
+                                   std::size_t size) const {
+  const int index = OutputIndex(name);
+  if (!initialized_ || index < 0 || !data) return -1;
+  const std::size_t expected = io_.pOutputs[index].nSize;
+  if (size != 0 && size != expected) return -1;
+  std::memcpy(data, io_.pOutputs[index].pVirAddr, expected);
+  return 0;
+}
+
+int EngineWrapper::GetInputSizeByName(const std::string &name) const {
+  const int index = InputIndex(name);
+  return index < 0 ? -1 : static_cast<int>(io_.pInputs[index].nSize);
+}
+
+int EngineWrapper::GetOutputSizeByName(const std::string &name) const {
+  const int index = OutputIndex(name);
+  return index < 0 ? -1 : static_cast<int>(io_.pOutputs[index].nSize);
+}
+
+const std::string &EngineWrapper::InputName(std::size_t index) const {
+  return input_names_.at(index);
+}
+
+const std::string &EngineWrapper::OutputName(std::size_t index) const {
+  return output_names_.at(index);
+}

cpp/src/engine_wrapper.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "ax_engine_api.h"
+
+class EngineWrapper {
+ public:
+  EngineWrapper() = default;
+  ~EngineWrapper();
+
+  EngineWrapper(const EngineWrapper &) = delete;
+  EngineWrapper &operator=(const EngineWrapper &) = delete;
+
+  int Init(const std::string &model_path);
+  void Release();
+  int SetInputByName(const std::string &name, const void *data,
+                     std::size_t size = 0);
+  int ZeroInputByName(const std::string &name);
+  int RunSync();
+  int GetOutputByName(const std::string &name, void *data,
+                      std::size_t size = 0) const;
+  int GetInputSizeByName(const std::string &name) const;
+  int GetOutputSizeByName(const std::string &name) const;
+  const std::string &InputName(std::size_t index) const;
+  const std::string &OutputName(std::size_t index) const;
+
+ private:
+  int InputIndex(const std::string &name) const;
+  int OutputIndex(const std::string &name) const;
+
+  bool initialized_ = false;
+  AX_ENGINE_HANDLE handle_ = nullptr;
+  AX_ENGINE_IO_INFO_T *info_ = nullptr;
+  AX_ENGINE_IO_T io_{};
+  std::unordered_map<std::string, int> inputs_;
+  std::unordered_map<std::string, int> outputs_;
+  std::vector<std::string> input_names_;
+  std::vector<std::string> output_names_;
+};

cpp/src/wav_reader.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+struct PcmWav {
+  int sample_rate = 0;
+  std::vector<int16_t> samples;
+};
+
+inline uint16_t ReadLe16(std::istream &input) {
+  uint8_t bytes[2]{};
+  input.read(reinterpret_cast<char *>(bytes), 2);
+  return static_cast<uint16_t>(bytes[0]) |
+         (static_cast<uint16_t>(bytes[1]) << 8);
+}
+
+inline uint32_t ReadLe32(std::istream &input) {
+  uint8_t bytes[4]{};
+  input.read(reinterpret_cast<char *>(bytes), 4);
+  return static_cast<uint32_t>(bytes[0]) |
+         (static_cast<uint32_t>(bytes[1]) << 8) |
+         (static_cast<uint32_t>(bytes[2]) << 16) |
+         (static_cast<uint32_t>(bytes[3]) << 24);
+}
+
+inline PcmWav ReadPcmWav(const std::string &path) {
+  std::ifstream input(path, std::ios::binary);
+  if (!input) throw std::runtime_error("Cannot open WAV: " + path);
+  char riff[4]{};
+  char wave[4]{};
+  input.read(riff, 4);
+  ReadLe32(input);
+  input.read(wave, 4);
+  if (std::memcmp(riff, "RIFF", 4) != 0 ||
+      std::memcmp(wave, "WAVE", 4) != 0) {
+    throw std::runtime_error("Invalid RIFF/WAVE file: " + path);
+  }
+
+  uint16_t format = 0;
+  uint16_t channels = 0;
+  uint16_t bits = 0;
+  uint32_t sample_rate = 0;
+  std::vector<uint8_t> data;
+  while (input && (!format || data.empty())) {
+    char id[4]{};
+    input.read(id, 4);
+    if (!input) break;
+    const uint32_t size = ReadLe32(input);
+    if (std::memcmp(id, "fmt ", 4) == 0) {
+      if (size < 16) throw std::runtime_error("Invalid WAV fmt chunk");
+      format = ReadLe16(input);
+      channels = ReadLe16(input);
+      sample_rate = ReadLe32(input);
+      ReadLe32(input);
+      ReadLe16(input);
+      bits = ReadLe16(input);
+      input.seekg(size - 16, std::ios::cur);
+    } else if (std::memcmp(id, "data", 4) == 0) {
+      data.resize(size);
+      input.read(reinterpret_cast<char *>(data.data()), size);
+    } else {
+      input.seekg(size, std::ios::cur);
+    }
+    if (size & 1U) input.seekg(1, std::ios::cur);
+  }
+  if (format != 1 || channels != 1 || bits != 16 || sample_rate == 0 ||
+      data.empty() || data.size() % sizeof(int16_t) != 0) {
+    throw std::runtime_error("Expected mono 16-bit PCM WAV: " + path);
+  }
+  PcmWav result;
+  result.sample_rate = static_cast<int>(sample_rate);
+  result.samples.resize(data.size() / sizeof(int16_t));
+  std::memcpy(result.samples.data(), data.data(), data.size());
+  return result;
+}

manifest.json

@@ -0,0 +1,217 @@
+{
+  "target_hardware": "AX630C/AX650",
+  "runtime": "axengine",
+  "axmodel_count": 8,
+  "files": [
+    {
+      "path": ".gitattributes",
+      "size_bytes": 179,
+      "sha256": "7b33e03d32f81ffc4bf98649921ff61fdbdfcff7477345dffc00bd5472351478"
+    },
+    {
+      "path": ".gitignore",
+      "size_bytes": 74,
+      "sha256": "496c11fcbfe22bd803d39235e6539b04e2fc8b0e7d747479302176ae84ae181a"
+    },
+    {
+      "path": "README.md",
+      "size_bytes": 3689,
+      "sha256": "7d609fad6c1e359a68551ce097e64e047056739be92a6311fd701ead738f5cd4"
+    },
+    {
+      "path": "audio/openwakeword/alexa_test.wav",
+      "size_bytes": 20044,
+      "sha256": "915dba88a2b936f3ba3ee91affcdbe9041ffbe532613d3aca58d8a15447fbd81"
+    },
+    {
+      "path": "audio/openwakeword/hey_jane.wav",
+      "size_bytes": 75820,
+      "sha256": "cf1b938bd8ca1a7e9bb042665b9cf92a772a6673c6b98e264b27176ea4d3f443"
+    },
+    {
+      "path": "audio/openwakeword/hey_mycroft_test.wav",
+      "size_bytes": 30508,
+      "sha256": "8d728ce1dbd54a97c6cddf0c80acec3113285407a967368f4abe476119c1a8c6"
+    },
+    {
+      "path": "config.json",
+      "size_bytes": 207,
+      "sha256": "67d68940a1ef8586cad523779ea86876b3bd2362c593c2d4e74ef6dd0557f892"
+    },
+    {
+      "path": "config/openwakeword_mel_weights.bin",
+      "size_bytes": 1085608,
+      "sha256": "f5d3a5bafe0def6c1efb4874d724c272d78edadada6652ef885059db2ba147a7"
+    },
+    {
+      "path": "config/openwakeword_mel_weights.npz",
+      "size_bytes": 1086554,
+      "sha256": "a3de443a7383dc51a4bf8b1d2dc9bbc767f7e33e17af617d993700a5f9947ed6"
+    },
+    {
+      "path": "cpp/CMakeLists.txt",
+      "size_bytes": 1948,
+      "sha256": "89980c1323031f9b1689562f493325b5ad1e1bd7960f85bd1e932ba097d42360"
+    },
+    {
+      "path": "cpp/README.md",
+      "size_bytes": 2197,
+      "sha256": "8b1abab04850f18bbd980b6f4de0f42334bfc1086fac97607606c7f6c914422f"
+    },
+    {
+      "path": "cpp/bin/openwakeword_ax630c",
+      "size_bytes": 39688,
+      "sha256": "309405a685c6928975ec732525ab069316bf43a3495de80c99d6aa566e6c37a3"
+    },
+    {
+      "path": "cpp/bin/openwakeword_ax650",
+      "size_bytes": 39688,
+      "sha256": "cea03dc9b00f40c4508bb82ee8e1dfa2a8775088f4e193fc413ba781e4607984"
+    },
+    {
+      "path": "cpp/build_ax630c.sh",
+      "size_bytes": 1299,
+      "sha256": "4d594ea058d6563fa9177698f0af0e3409959672f399d9729a378de2a47ebc09"
+    },
+    {
+      "path": "cpp/build_ax650.sh",
+      "size_bytes": 1267,
+      "sha256": "fbf962de8ed6433fef6b2aac7332bf84e18720f01b6bf7955e9d32eb409f8e01"
+    },
+    {
+      "path": "cpp/download_bsp.sh",
+      "size_bytes": 1290,
+      "sha256": "0c5afbc290c6d8341df2e8b356626642935a5c9971b0b6b603d30a9b32e69f7a"
+    },
+    {
+      "path": "cpp/openwakeword_ax.cpp",
+      "size_bytes": 14122,
+      "sha256": "6c4ef28769f1321624819a6c915e43d2127989cefc58a39e8600631d57f98d8d"
+    },
+    {
+      "path": "cpp/run_batch_openwakeword_ax.sh",
+      "size_bytes": 3938,
+      "sha256": "5c4a4d3d9e399fb98d0a9b794389fb03ce585cfe9e24d884772052fd1f948c88"
+    },
+    {
+      "path": "cpp/run_batch_openwakeword_ax630c.sh",
+      "size_bytes": 168,
+      "sha256": "f6545c7db37deb52ea727c8f641f000a2c7c1805fc7b40fbc06ec6841b3a259c"
+    },
+    {
+      "path": "cpp/run_batch_openwakeword_ax650.sh",
+      "size_bytes": 167,
+      "sha256": "8711184e6284d9de1ac5b11fdfb23de7c02b9667596d3cb060be702b38b6a858"
+    },
+    {
+      "path": "cpp/run_openwakeword_ax.sh",
+      "size_bytes": 1510,
+      "sha256": "2cf5332a4a6457b1356609fd66e8777d3cc89cc871aa176695cd868d4667f948"
+    },
+    {
+      "path": "cpp/run_openwakeword_ax630c.sh",
+      "size_bytes": 162,
+      "sha256": "f2bd3486e9e8db53835a6d09f9f6a73769342f2a032939842559268342264cc8"
+    },
+    {
+      "path": "cpp/run_openwakeword_ax650.sh",
+      "size_bytes": 161,
+      "sha256": "4ac47b1d3535d6351e595ec8c4594d9a696ae22e4224076f654bb2969f9e7dd8"
+    },
+    {
+      "path": "cpp/src/engine_wrapper.cpp",
+      "size_bytes": 6489,
+      "sha256": "d5ee6d04eaaa6cff492b1b2cd8c60d8519b630b1fc66fd93ee4085cf2121f4ea"
+    },
+    {
+      "path": "cpp/src/engine_wrapper.hpp",
+      "size_bytes": 1313,
+      "sha256": "6a160d748e4fda7c4a69cd2113c36f36c66bf7292e32ffe3df966d24eac51ede"
+    },
+    {
+      "path": "cpp/src/wav_reader.hpp",
+      "size_bytes": 2447,
+      "sha256": "c4890925751e81c78a8429e06fd7fc1e35673d4c9b84989d0f9fd64a364b4d34"
+    },
+    {
+      "path": "models/630C/.gitkeep",
+      "size_bytes": 1,
+      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b"
+    },
+    {
+      "path": "models/650/openwakeword__alexa_v0.1.axmodel",
+      "size_bytes": 241041,
+      "sha256": "3595cd242ddf38aca019042d593c45ac1e90107a6d54836ea5593e3dc55f9784"
+    },
+    {
+      "path": "models/650/openwakeword__embedding_model.axmodel",
+      "size_bytes": 451068,
+      "sha256": "a9c579200c4e9c076d86181343cdbe5cf2c786016cd60b333463784b5c2fa9b4"
+    },
+    {
+      "path": "models/650/openwakeword__hey_jarvis_v0.1.axmodel",
+      "size_bytes": 365733,
+      "sha256": "c878a73a9f187505a9496c0b12c479c94de9102d7851bc31a7d75de15a7298ef"
+    },
+    {
+      "path": "models/650/openwakeword__hey_mycroft_v0.1.axmodel",
+      "size_bytes": 247553,
+      "sha256": "1ff391da1aefc04f20df5a24be0d063941459caeef0d5e6d6892c5561049fdf2"
+    },
+    {
+      "path": "models/650/openwakeword__hey_rhasspy_v0.1.axmodel",
+      "size_bytes": 64073,
+      "sha256": "4e13babcf713a3b62ca871bd6d7df50315a09da17ab35c294fa41034baed4a69"
+    },
+    {
+      "path": "models/650/openwakeword__melspectrogram.axmodel",
+      "size_bytes": 340028,
+      "sha256": "9ea2c5293ef3c05c3c5681b947f270d3fe77a0464308d67cf43d9090e9e7fb5f"
+    },
+    {
+      "path": "models/650/openwakeword__timer_v0.1.axmodel",
+      "size_bytes": 482100,
+      "sha256": "4b7c243daadeed2e7ac2b398e5ee13fd7a3c40a5a857ad835809cbfc5d687b5a"
+    },
+    {
+      "path": "models/650/openwakeword__weather_v0.1.axmodel",
+      "size_bytes": 320785,
+      "sha256": "f94fe025de680f18cfb55b7ca8f7cfabb94624f96b9f51424d73e75a9e0b471c"
+    },
+    {
+      "path": "outputs/.gitkeep",
+      "size_bytes": 1,
+      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b"
+    },
+    {
+      "path": "reference/local_inference_results.json",
+      "size_bytes": 15035,
+      "sha256": "3e4319055ee7b4a7fae93203411acdf71d5596427c63beb2ee07b749ca090a1f"
+    },
+    {
+      "path": "requirements.txt",
+      "size_bytes": 12,
+      "sha256": "a83a2a4ed7ab2e022b9b8a83cfa2b8cf52cc243006c597e8b96f90a8365590ac"
+    },
+    {
+      "path": "scripts/openwakeword_ax.py",
+      "size_bytes": 11767,
+      "sha256": "4ad53f63027b7a650cbd95c6a038cde28d7a047b16cc25b5b54aa4b3b1ec865d"
+    },
+    {
+      "path": "scripts/openwakeword_ax630c.py",
+      "size_bytes": 327,
+      "sha256": "8f00e9bb9edc80dcff413c652eb1878b5174529a6d33a83e1a4f39eab52e6ed2"
+    },
+    {
+      "path": "scripts/openwakeword_ax650.py",
+      "size_bytes": 324,
+      "sha256": "c9b37219849cca038434abeae54d3a5d2f0fdf585126fb8649e7ecffaa643ee4"
+    },
+    {
+      "path": "scripts/runtime.py",
+      "size_bytes": 5296,
+      "sha256": "99b9f762b630a186cf3b010f57b11987564cb76e41ab403e78d3ada57729b0fb"
+    }
+  ]
+}

models/630C/.gitkeep

@@ -0,0 +1 @@
+

models/630C/openwakeword__alexa_v0.1.axmodel

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

models/630C/openwakeword__embedding_model.axmodel

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

models/630C/openwakeword__hey_jarvis_v0.1.axmodel

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

models/630C/openwakeword__hey_mycroft_v0.1.axmodel

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

models/630C/openwakeword__hey_rhasspy_v0.1.axmodel

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

models/630C/openwakeword__melspectrogram.axmodel

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

models/630C/openwakeword__timer_v0.1.axmodel

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

models/630C/openwakeword__weather_v0.1.axmodel

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

models/650/openwakeword__alexa_v0.1.axmodel

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

models/650/openwakeword__embedding_model.axmodel

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

models/650/openwakeword__hey_jarvis_v0.1.axmodel

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

models/650/openwakeword__hey_mycroft_v0.1.axmodel

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

models/650/openwakeword__hey_rhasspy_v0.1.axmodel

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

models/650/openwakeword__melspectrogram.axmodel

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

models/650/openwakeword__timer_v0.1.axmodel

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

models/650/openwakeword__weather_v0.1.axmodel

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

outputs/.gitkeep

@@ -0,0 +1 @@
+

outputs/cpp_batch/logs/alexa_test.log

@@ -0,0 +1,25 @@
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__embedding_model.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__alexa_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_jarvis_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_mycroft_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_rhasspy_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__timer_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__weather_v0.1.axmodel (inputs=1 outputs=1)
+
+openWakeWord C++ inference complete
+audio: audio/openwakeword/alexa_test.wav
+chunks: 8
+threshold: 0.500
+alexa_v0.1             1.000000  WAKEUP
+hey_jarvis_v0.1        0.000005
+hey_mycroft_v0.1       0.000839
+hey_rhasspy_v0.1       0.001408
+timer_v0.1             0.997989 0.011197 0.011197 0.012590 0.011609 0.011197 0.011197
+weather_v0.1           0.010740
+detected: true
+audio_seconds: 0.625000
+feature_seconds: 0.038823
+npu_seconds: 0.005308
+model_load_seconds: 0.310009
+inference_seconds: 0.044567
+rtf: 0.071308

outputs/cpp_batch/logs/hey_jane.log

@@ -0,0 +1,25 @@
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__embedding_model.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__alexa_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_jarvis_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_mycroft_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_rhasspy_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__timer_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__weather_v0.1.axmodel (inputs=1 outputs=1)
+
+openWakeWord C++ inference complete
+audio: audio/openwakeword/hey_jane.wav
+chunks: 30
+threshold: 0.500
+alexa_v0.1             0.001312
+hey_jarvis_v0.1        0.017346
+hey_mycroft_v0.1       0.000000
+hey_rhasspy_v0.1       0.004955
+timer_v0.1             1.000000 0.009932 0.008854 0.009936 0.009849 0.008854 0.021674
+weather_v0.1           0.387996
+detected: false
+audio_seconds: 2.368000
+feature_seconds: 0.145612
+npu_seconds: 0.022135
+model_load_seconds: 0.653880
+inference_seconds: 0.169402
+rtf: 0.071538

outputs/cpp_batch/logs/hey_mycroft_test.log

@@ -0,0 +1,25 @@
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__embedding_model.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__alexa_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_jarvis_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_mycroft_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__hey_rhasspy_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__timer_v0.1.axmodel (inputs=1 outputs=1)
+Loaded /mnt/huyuan/workspace/kws_quant/huggingface/openwakeword-axera-inference/models/openwakeword__weather_v0.1.axmodel (inputs=1 outputs=1)
+
+openWakeWord C++ inference complete
+audio: audio/openwakeword/hey_mycroft_test.wav
+chunks: 12
+threshold: 0.500
+alexa_v0.1             0.001801
+hey_jarvis_v0.1        0.000025
+hey_mycroft_v0.1       1.000000  WAKEUP
+hey_rhasspy_v0.1       0.002780
+timer_v0.1             0.998750 0.010560 0.010560 0.011588 0.011225 0.010560 0.010560
+weather_v0.1           0.279959
+detected: true
+audio_seconds: 0.952000
+feature_seconds: 0.058748
+npu_seconds: 0.007945
+model_load_seconds: 0.862838
+inference_seconds: 0.067336
+rtf: 0.070731

outputs/cpp_batch/results.tsv

@@ -0,0 +1,4 @@
+file	audio_seconds	feature_seconds	npu_seconds	inference_seconds	rtf	model_load_seconds	detections
+alexa_test.wav	0.625000	0.038823	0.005308	0.044567	0.071308	0.310009	alexa_v0.1
+hey_jane.wav	2.368000	0.145612	0.022135	0.169402	0.071538	0.653880	none
+hey_mycroft_test.wav	0.952000	0.058748	0.007945	0.067336	0.070731	0.862838	hey_mycroft_v0.1

outputs/cpp_batch/summary.txt

@@ -0,0 +1,7 @@
+files: 3
+total_audio_seconds: 3.945000
+total_feature_seconds: 0.243183
+total_npu_seconds: 0.035388
+total_inference_seconds: 0.281305
+total_model_load_seconds: 1.826727
+rtf: 0.071307

reference/local_inference_results.json

@@ -0,0 +1,497 @@
+{
+  "environment": {
+    "python": "3.12.0",
+    "numpy": "1.26.4",
+    "onnxruntime": "1.23.1",
+    "platform": "Linux-5.15.0-94-generic-x86_64-with-glibc2.35"
+  },
+  "openwakeword": {
+    "pipeline": "fixed 80 ms streaming chunks with 30 ms PCM history",
+    "clips": [
+      {
+        "audio": "openWakeWord/tests/data/alexa_test.wav",
+        "sample_rate": 16000,
+        "sample_count": 10240,
+        "frame_count": 8,
+        "initial_context": "480 zero PCM samples for fixed [1,1760] mel input",
+        "stage_metrics": {
+          "melspectrogram": {
+            "shape_match": true,
+            "comparisons": 8,
+            "minimum_cosine": 0.9999999999999984,
+            "maximum_mse": 2.3590018827235326e-11,
+            "maximum_abs": 1.52587890625e-05
+          },
+          "embedding": {
+            "shape_match": true,
+            "comparisons": 8,
+            "minimum_cosine": 0.9999999999996391,
+            "maximum_mse": 2.417571698387633e-10,
+            "maximum_abs": 3.814697265625e-05
+          },
+          "classifiers": {
+            "shape_match": true,
+            "comparisons": 48,
+            "minimum_cosine": 0.9999999999999992,
+            "maximum_mse": 7.993605777301127e-15,
+            "maximum_abs": 1.1920928955078125e-07
+          }
+        },
+        "source_max_scores": {
+          "alexa_v0.1.onnx": [
+            1.0
+          ],
+          "hey_jarvis_v0.1.onnx": [
+            4.9173831939697266e-06
+          ],
+          "hey_mycroft_v0.1.onnx": [
+            0.0007033348083496094
+          ],
+          "hey_rhasspy_v0.1.onnx": [
+            0.0013944804668426514
+          ],
+          "timer_v0.1.onnx": [
+            0.9979174733161926,
+            0.011717854999005795,
+            0.011717854999005795,
+            0.01298792939633131,
+            0.012006871402263641,
+            0.011717854999005795,
+            0.011717854999005795
+          ],
+          "weather_v0.1.onnx": [
+            0.011630207300186157
+          ]
+        },
+        "static_max_scores": {
+          "alexa_v0.1.onnx": [
+            1.0
+          ],
+          "hey_jarvis_v0.1.onnx": [
+            4.947185516357422e-06
+          ],
+          "hey_mycroft_v0.1.onnx": [
+            0.0007033348083496094
+          ],
+          "hey_rhasspy_v0.1.onnx": [
+            0.0013944804668426514
+          ],
+          "timer_v0.1.onnx": [
+            0.9979174733161926,
+            0.011717865243554115,
+            0.011717865243554115,
+            0.012987940572202206,
+            0.012006882578134537,
+            0.011717865243554115,
+            0.011717865243554115
+          ],
+          "weather_v0.1.onnx": [
+            0.011630237102508545
+          ]
+        },
+        "expected_model": "alexa_v0.1.onnx",
+        "expected_score": 1.0,
+        "expected_detected": true,
+        "numerical_match": true,
+        "passed": true
+      },
+      {
+        "audio": "openWakeWord/tests/data/hey_mycroft_test.wav",
+        "sample_rate": 16000,
+        "sample_count": 15360,
+        "frame_count": 12,
+        "initial_context": "480 zero PCM samples for fixed [1,1760] mel input",
+        "stage_metrics": {
+          "melspectrogram": {
+            "shape_match": true,
+            "comparisons": 12,
+            "minimum_cosine": 0.9999999999999982,
+            "maximum_mse": 2.4101609596982598e-11,
+            "maximum_abs": 1.52587890625e-05
+          },
+          "embedding": {
+            "shape_match": true,
+            "comparisons": 12,
+            "minimum_cosine": 0.9999999999998549,
+            "maximum_mse": 1.3607677947409988e-10,
+            "maximum_abs": 4.1961669921875e-05
+          },
+          "classifiers": {
+            "shape_match": true,
+            "comparisons": 72,
+            "minimum_cosine": 0.9999999999999998,
+            "maximum_mse": 1.9454660105111543e-11,
+            "maximum_abs": 4.410743713378906e-06
+          }
+        },
+        "source_max_scores": {
+          "alexa_v0.1.onnx": [
+            0.0016120076179504395
+          ],
+          "hey_jarvis_v0.1.onnx": [
+            2.256035804748535e-05
+          ],
+          "hey_mycroft_v0.1.onnx": [
+            1.0
+          ],
+          "hey_rhasspy_v0.1.onnx": [
+            0.0026790201663970947
+          ],
+          "timer_v0.1.onnx": [
+            0.9988803267478943,
+            0.011138674803078175,
+            0.011138674803078175,
+            0.012048495002090931,
+            0.011720946989953518,
+            0.011138674803078175,
+            0.011138674803078175
+          ],
+          "weather_v0.1.onnx": [
+            0.18771854043006897
+          ]
+        },
+        "static_max_scores": {
+          "alexa_v0.1.onnx": [
+            0.0016120672225952148
+          ],
+          "hey_jarvis_v0.1.onnx": [
+            2.2590160369873047e-05
+          ],
+          "hey_mycroft_v0.1.onnx": [
+            1.0
+          ],
+          "hey_rhasspy_v0.1.onnx": [
+            0.0026790201663970947
+          ],
+          "timer_v0.1.onnx": [
+            0.9988803267478943,
+            0.011138674803078175,
+            0.011138674803078175,
+            0.012048495002090931,
+            0.011720946989953518,
+            0.011138674803078175,
+            0.011138674803078175
+          ],
+          "weather_v0.1.onnx": [
+            0.18771809339523315
+          ]
+        },
+        "expected_model": "hey_mycroft_v0.1.onnx",
+        "expected_score": 1.0,
+        "expected_detected": true,
+        "numerical_match": true,
+        "passed": true
+      },
+      {
+        "audio": "openWakeWord/tests/data/hey_jane.wav",
+        "sample_rate": 16000,
+        "sample_count": 38400,
+        "frame_count": 30,
+        "initial_context": "480 zero PCM samples for fixed [1,1760] mel input",
+        "stage_metrics": {
+          "melspectrogram": {
+            "shape_match": true,
+            "comparisons": 30,
+            "minimum_cosine": 0.9999999999999951,
+            "maximum_mse": 1.836042429204099e-11,
+            "maximum_abs": 1.52587890625e-05
+          },
+          "embedding": {
+            "shape_match": true,
+            "comparisons": 30,
+            "minimum_cosine": 0.9999999999996753,
+            "maximum_mse": 1.5618928372873597e-10,
+            "maximum_abs": 3.910064697265625e-05
+          },
+          "classifiers": {
+            "shape_match": true,
+            "comparisons": 180,
+            "minimum_cosine": 0.0,
+            "maximum_mse": 4.3520742565306136e-14,
+            "maximum_abs": 2.086162567138672e-07
+          }
+        },
+        "source_max_scores": {
+          "alexa_v0.1.onnx": [
+            0.001211315393447876
+          ],
+          "hey_jarvis_v0.1.onnx": [
+            0.0183732807636261
+          ],
+          "hey_mycroft_v0.1.onnx": [
+            3.1888484954833984e-06
+          ],
+          "hey_rhasspy_v0.1.onnx": [
+            0.0046852827072143555
+          ],
+          "timer_v0.1.onnx": [
+            0.9999986886978149,
+            0.01402811985462904,
+            0.009387511759996414,
+            0.010385164059698582,
+            0.012926612980663776,
+            0.009387511759996414,
+            0.03614084795117378
+          ],
+          "weather_v0.1.onnx": [
+            0.31700584292411804
+          ]
+        },
+        "static_max_scores": {
+          "alexa_v0.1.onnx": [
+            0.001211315393447876
+          ],
+          "hey_jarvis_v0.1.onnx": [
+            0.018373221158981323
+          ],
+          "hey_mycroft_v0.1.onnx": [
+            3.159046173095703e-06
+          ],
+          "hey_rhasspy_v0.1.onnx": [
+            0.0046852827072143555
+          ],
+          "timer_v0.1.onnx": [
+            0.9999986886978149,
+            0.01402811985462904,
+            0.009387511759996414,
+            0.010385164059698582,
+            0.012926612980663776,
+            0.009387511759996414,
+            0.036140866577625275
+          ],
+          "weather_v0.1.onnx": [
+            0.31700563430786133
+          ]
+        },
+        "expected_model": null,
+        "expected_score": null,
+        "expected_detected": null,
+        "numerical_match": true,
+        "passed": true
+      }
+    ],
+    "passed": true
+  },
+  "sherpa": {
+    "sherpa_onnx_version": "1.13.4",
+    "variants": [
+      {
+        "chunk_size": 8,
+        "max_active_paths": 1,
+        "audio_count": 9,
+        "comparisons": [
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/en_0.wav",
+            "source_detections": [
+              "LIGHT_UP"
+            ],
+            "static_detections": [
+              "LIGHT_UP"
+            ],
+            "source_decode_calls": 45,
+            "static_decode_calls": 45,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/en_1.wav",
+            "source_detections": [
+              "LOVELY_CHILD"
+            ],
+            "static_detections": [
+              "LOVELY_CHILD"
+            ],
+            "source_decode_calls": 108,
+            "static_decode_calls": 108,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_0.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 39,
+            "static_decode_calls": 39,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_1.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 36,
+            "static_decode_calls": 36,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_2.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 32,
+            "static_decode_calls": 32,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_3.wav",
+            "source_detections": [
+              "法国"
+            ],
+            "static_detections": [
+              "法国"
+            ],
+            "source_decode_calls": 54,
+            "static_decode_calls": 54,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_4.wav",
+            "source_detections": [
+              "蒋友伯",
+              "女儿"
+            ],
+            "static_detections": [
+              "蒋友伯",
+              "女儿"
+            ],
+            "source_decode_calls": 32,
+            "static_decode_calls": 32,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_5.wav",
+            "source_detections": [
+              "周望军",
+              "落实"
+            ],
+            "static_detections": [
+              "周望军",
+              "落实"
+            ],
+            "source_decode_calls": 30,
+            "static_decode_calls": 30,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_6.wav",
+            "source_detections": [
+              "朱丽楠"
+            ],
+            "static_detections": [
+              "朱丽楠"
+            ],
+            "source_decode_calls": 26,
+            "static_decode_calls": 26,
+            "match": true
+          }
+        ],
+        "detected_audio_count": 6,
+        "passed": true
+      },
+      {
+        "chunk_size": 16,
+        "max_active_paths": 1,
+        "audio_count": 9,
+        "comparisons": [
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/en_0.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 22,
+            "static_decode_calls": 22,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/en_1.wav",
+            "source_detections": [
+              "LOVELY_CHILD"
+            ],
+            "static_detections": [
+              "LOVELY_CHILD"
+            ],
+            "source_decode_calls": 54,
+            "static_decode_calls": 54,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_0.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 19,
+            "static_decode_calls": 19,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_1.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 18,
+            "static_decode_calls": 18,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_2.wav",
+            "source_detections": [],
+            "static_detections": [],
+            "source_decode_calls": 16,
+            "static_decode_calls": 16,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_3.wav",
+            "source_detections": [
+              "法国"
+            ],
+            "static_detections": [
+              "法国"
+            ],
+            "source_decode_calls": 27,
+            "static_decode_calls": 27,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_4.wav",
+            "source_detections": [
+              "蒋友伯",
+              "女儿"
+            ],
+            "static_detections": [
+              "蒋友伯",
+              "女儿"
+            ],
+            "source_decode_calls": 16,
+            "static_decode_calls": 16,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_5.wav",
+            "source_detections": [
+              "周望军",
+              "落实"
+            ],
+            "static_detections": [
+              "周望军",
+              "落实"
+            ],
+            "source_decode_calls": 15,
+            "static_decode_calls": 15,
+            "match": true
+          },
+          {
+            "audio": "sherpa-onnx-kws-zipformer-zh-en-3M-2025-12-20/test_wavs/zh_6.wav",
+            "source_detections": [
+              "朱丽楠"
+            ],
+            "static_detections": [
+              "朱丽楠"
+            ],
+            "source_decode_calls": 13,
+            "static_decode_calls": 13,
+            "match": true
+          }
+        ],
+        "detected_audio_count": 5,
+        "passed": true
+      }
+    ],
+    "passed": true
+  },
+  "elapsed_seconds": 9.052458902820945,
+  "all_passed": true
+}