Remove C++ sources/build scripts from HF release (keep precompiled binaries only)

Per HF release convention, only prebuilt artifacts belong on the Hub:
- keep cpp/bin/openwakeword_ax650 / openwakeword_ax630c
- remove cpp sources (openwakeword_ax.cpp, engine_wrapper, wav_reader),
CMakeLists.txt, build/download scripts; source stays in the GitHub repo
- also drop tracked __pycache__ from scripts/

cpp/CMakeLists.txt

@@ -1,57 +0,0 @@
-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

@@ -87,3 +87,10 @@ CPU mel 和 NPU 推理，不包含一次性模型加载与初始化。
 THRESHOLD=0.6 AUDIO=audio/openwakeword/hey_mycroft_test.wav \
 bash cpp/run_openwakeword_ax630c.sh
 ```
+
+## 源码
+
+C++ 源码、构建脚本与 BSP 下载脚本在 GitHub 仓库：
+https://github.com/AXERA-TECH/openWakeWord.AXERA
+（HuggingFace 仅发布预编译二进制。）
+

cpp/build_ax630c.sh

@@ -1,32 +0,0 @@
-#!/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

@@ -1,32 +0,0 @@
-#!/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

@@ -1,45 +0,0 @@
-#!/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

@@ -1,379 +0,0 @@
-#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/src/engine_wrapper.cpp

@@ -1,197 +0,0 @@
-#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

@@ -1,43 +0,0 @@
-#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

@@ -1,80 +0,0 @@
-#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;
-}