@siteed/audio-studio 3.0.0

package/cpp/AudioFeaturesBridge.cpp

@@ -0,0 +1,146 @@
+#include "AudioFeaturesBridge.h"
+#include "AudioFeatures.h"
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <mutex>
+
+static std::unique_ptr<AudioFeaturesProcessor> cachedProcessor;
+static std::mutex cachedMutex;
+
+static CAudioFeaturesResult* resultFromCpp(const AudioFeaturesResult& src) {
+    CAudioFeaturesResult* r = (CAudioFeaturesResult*)malloc(sizeof(CAudioFeaturesResult));
+    if (!r) return nullptr;
+    r->spectralCentroid = src.spectralCentroid;
+    r->spectralFlatness = src.spectralFlatness;
+    r->spectralRolloff = src.spectralRolloff;
+    r->spectralBandwidth = src.spectralBandwidth;
+
+    r->mfccCount = static_cast<int>(src.mfcc.size());
+    if (r->mfccCount > 0) {
+        r->mfcc = (float*)malloc(r->mfccCount * sizeof(float));
+        if (!r->mfcc) { r->mfccCount = 0; }
+        else { std::memcpy(r->mfcc, src.mfcc.data(), r->mfccCount * sizeof(float)); }
+    } else {
+        r->mfcc = nullptr;
+    }
+
+    r->chromagramCount = static_cast<int>(src.chromagram.size());
+    if (r->chromagramCount > 0) {
+        r->chromagram = (float*)malloc(r->chromagramCount * sizeof(float));
+        if (!r->chromagram) { r->chromagramCount = 0; }
+        else { std::memcpy(r->chromagram, src.chromagram.data(), r->chromagramCount * sizeof(float)); }
+    } else {
+        r->chromagram = nullptr;
+    }
+
+    return r;
+}
+
+static void fillResultFromCpp(const AudioFeaturesResult& src, CAudioFeaturesResult* r) {
+    r->spectralCentroid = src.spectralCentroid;
+    r->spectralFlatness = src.spectralFlatness;
+    r->spectralRolloff = src.spectralRolloff;
+    r->spectralBandwidth = src.spectralBandwidth;
+
+    // Free prior allocations to prevent leaks on repeated calls
+    if (r->mfcc) { free(r->mfcc); r->mfcc = nullptr; }
+    if (r->chromagram) { free(r->chromagram); r->chromagram = nullptr; }
+
+    r->mfccCount = static_cast<int>(src.mfcc.size());
+    if (r->mfccCount > 0) {
+        r->mfcc = (float*)malloc(r->mfccCount * sizeof(float));
+        if (!r->mfcc) { r->mfccCount = 0; }
+        else { std::memcpy(r->mfcc, src.mfcc.data(), r->mfccCount * sizeof(float)); }
+    } else {
+        r->mfcc = nullptr;
+    }
+
+    r->chromagramCount = static_cast<int>(src.chromagram.size());
+    if (r->chromagramCount > 0) {
+        r->chromagram = (float*)malloc(r->chromagramCount * sizeof(float));
+        if (!r->chromagram) { r->chromagramCount = 0; }
+        else { std::memcpy(r->chromagram, src.chromagram.data(), r->chromagramCount * sizeof(float)); }
+    } else {
+        r->chromagram = nullptr;
+    }
+}
+
+extern "C" {
+
+CAudioFeaturesResult* audio_features_compute(
+    const float* samples, int numSamples, int sampleRate,
+    int fftLength, int nMfcc, int nMelFilters,
+    int computeMfcc, int computeChroma)
+{
+    AudioFeaturesConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.nMfcc = nMfcc;
+    config.nMelFilters = nMelFilters;
+    config.computeMfcc = (computeMfcc != 0);
+    config.computeChroma = (computeChroma != 0);
+
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<AudioFeaturesProcessor>(config);
+    }
+
+    AudioFeaturesResult result = cachedProcessor->compute(samples, numSamples);
+    return resultFromCpp(result);
+}
+
+void audio_features_free(CAudioFeaturesResult* result) {
+    if (result) {
+        if (result->mfcc) free(result->mfcc);
+        if (result->chromagram) free(result->chromagram);
+        free(result);
+    }
+}
+
+void audio_features_free_arrays(CAudioFeaturesResult* result) {
+    if (result) {
+        if (result->mfcc) { free(result->mfcc); result->mfcc = nullptr; }
+        if (result->chromagram) { free(result->chromagram); result->chromagram = nullptr; }
+    }
+}
+
+void audio_features_init(int sampleRate, int fftLength,
+    int nMfcc, int nMelFilters, int computeMfcc, int computeChroma)
+{
+    AudioFeaturesConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.nMfcc = nMfcc;
+    config.nMelFilters = nMelFilters;
+    config.computeMfcc = (computeMfcc != 0);
+    config.computeChroma = (computeChroma != 0);
+
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<AudioFeaturesProcessor>(config);
+    }
+}
+
+int audio_features_compute_frame(const float* samples, int numSamples,
+    CAudioFeaturesResult* result)
+{
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !samples || !result) {
+        return 0;
+    }
+
+    AudioFeaturesResult cppResult = cachedProcessor->compute(samples, numSamples);
+    fillResultFromCpp(cppResult, result);
+    return 1;
+}
+
+int audio_features_get_n_mfcc(void) {
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor) {
+        return 0;
+    }
+    return cachedProcessor->config().nMfcc;
+}
+
+} // extern "C"

package/cpp/AudioFeaturesBridge.h

@@ -0,0 +1,47 @@
+#ifndef AUDIO_FEATURES_BRIDGE_H
+#define AUDIO_FEATURES_BRIDGE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    float spectralCentroid;
+    float spectralFlatness;
+    float spectralRolloff;
+    float spectralBandwidth;
+    float* mfcc;         // nMfcc coefficients (caller must free via audio_features_free)
+    int mfccCount;
+    float* chromagram;   // 12 bins (caller must free via audio_features_free)
+    int chromagramCount;
+} CAudioFeaturesResult;
+
+// Batch API: compute features for a buffer of samples
+CAudioFeaturesResult* audio_features_compute(
+    const float* samples, int numSamples, int sampleRate,
+    int fftLength, int nMfcc, int nMelFilters,
+    int computeMfcc, int computeChroma);
+
+void audio_features_free(CAudioFeaturesResult* result);
+
+// Streaming API: init processor, then compute per-frame
+void audio_features_init(int sampleRate, int fftLength,
+    int nMfcc, int nMelFilters, int computeMfcc, int computeChroma);
+
+// Returns 1 on success, 0 on failure.
+// Output written to the provided CAudioFeaturesResult (caller-allocated).
+// mfcc and chromagram pointers inside result are allocated by this function
+// and must be freed by the caller via audio_features_free_arrays().
+int audio_features_compute_frame(const float* samples, int numSamples,
+    CAudioFeaturesResult* result);
+
+// Free only the internal arrays (mfcc, chromagram) of a stack-allocated result
+void audio_features_free_arrays(CAudioFeaturesResult* result);
+
+int audio_features_get_n_mfcc(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AUDIO_FEATURES_BRIDGE_H

package/cpp/MelSpectrogram.cpp

@@ -0,0 +1,227 @@
+#include "MelSpectrogram.h"
+
+#include <algorithm>
+#include <cstring>
+#include <limits>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+MelSpectrogramProcessor::MelSpectrogramProcessor(const MelSpectrogramConfig& config)
+    : config_(config), fftCfg_(nullptr) {
+    // Clamp invalid values to safe defaults to prevent division by zero
+    if (config_.fftLength <= 0) config_.fftLength = 2048;
+    if (config_.hopLengthSamples <= 0) config_.hopLengthSamples = 160;
+    if (config_.windowSizeSamples <= 1) config_.windowSizeSamples = 400;
+    if (config_.nMels <= 0) config_.nMels = 128;
+    if (config_.fMax <= 0.0f) {
+        config_.fMax = static_cast<float>(config_.sampleRate) / 2.0f;
+    }
+    fftCfg_ = kiss_fftr_alloc(config_.fftLength, 0, nullptr, nullptr);
+    buildWindow();
+    buildMelFilterbank();
+    allocateBuffers();
+}
+
+MelSpectrogramProcessor::~MelSpectrogramProcessor() {
+    if (fftCfg_) {
+        free(fftCfg_);
+    }
+}
+
+void MelSpectrogramProcessor::allocateBuffers() {
+    const int numBins = config_.fftLength / 2 + 1;
+    fftInput_.resize(config_.fftLength, 0.0f);
+    fftOutput_.resize(numBins);
+    powerSpectrum_.resize(numBins);
+}
+
+float MelSpectrogramProcessor::hzToMel(float hz) {
+    return 2595.0f * std::log10(1.0f + hz / 700.0f);
+}
+
+float MelSpectrogramProcessor::melToHz(float mel) {
+    return 700.0f * (std::pow(10.0f, mel / 2595.0f) - 1.0f);
+}
+
+void MelSpectrogramProcessor::buildWindow() {
+    window_.resize(config_.windowSizeSamples);
+    const float N = static_cast<float>(config_.windowSizeSamples - 1);
+    for (int i = 0; i < config_.windowSizeSamples; ++i) {
+        if (config_.windowType == 1) {
+            // Hamming
+            window_[i] = 0.54f - 0.46f * std::cos(2.0f * static_cast<float>(M_PI) * i / N);
+        } else {
+            // Hann (default)
+            window_[i] = 0.5f * (1.0f - std::cos(2.0f * static_cast<float>(M_PI) * i / N));
+        }
+    }
+}
+
+void MelSpectrogramProcessor::buildMelFilterbank() {
+    const int numBins = config_.fftLength / 2 + 1;
+    const float melMin = hzToMel(config_.fMin);
+    const float melMax = hzToMel(config_.fMax);
+
+    // nMels + 2 points for triangular filters
+    std::vector<float> melPoints(config_.nMels + 2);
+    for (int i = 0; i < config_.nMels + 2; ++i) {
+        float mel = melMin + i * (melMax - melMin) / (config_.nMels + 1);
+        melPoints[i] = melToHz(mel);
+    }
+
+    const float binWidth = static_cast<float>(config_.sampleRate) / config_.fftLength;
+
+    // Build sparse filterbank — only store non-zero weights per mel band
+    melFilters_.resize(config_.nMels);
+    for (int melIdx = 0; melIdx < config_.nMels; ++melIdx) {
+        const float fLow = melPoints[melIdx];
+        const float fCenter = melPoints[melIdx + 1];
+        const float fHigh = melPoints[melIdx + 2];
+
+        // Find bin range that overlaps this filter
+        int binStart = std::max(0, static_cast<int>(std::ceil(fLow / binWidth)));
+        int binEnd = std::min(numBins - 1, static_cast<int>(std::floor(fHigh / binWidth)));
+
+        melFilters_[melIdx].startBin = binStart;
+        const int count = binEnd - binStart + 1;
+        melFilters_[melIdx].weights.resize(count > 0 ? count : 0);
+
+        for (int bin = binStart; bin <= binEnd; ++bin) {
+            float freq = static_cast<float>(bin) * binWidth;
+            float weight;
+            if (freq <= fCenter) {
+                float denom = fCenter - fLow;
+                weight = (denom > 0.0f) ? (freq - fLow) / denom : 0.0f;
+            } else {
+                float denom = fHigh - fCenter;
+                weight = (denom > 0.0f) ? (fHigh - freq) / denom : 0.0f;
+            }
+            melFilters_[melIdx].weights[bin - binStart] = std::max(0.0f, weight);
+        }
+    }
+}
+
+MelSpectrogramResult MelSpectrogramProcessor::compute(const float* samples, int numSamples) {
+    const int numBins = config_.fftLength / 2 + 1;
+    const int numFrames = (numSamples - config_.windowSizeSamples) / config_.hopLengthSamples + 1;
+
+    if (numFrames <= 0) {
+        return MelSpectrogramResult{{}, 0, config_.nMels};
+    }
+
+    // Use pre-allocated work buffers
+    float* fftIn = fftInput_.data();
+    kiss_fft_cpx* fftOut = fftOutput_.data();
+    float* power = powerSpectrum_.data();
+
+    // Zero the tail of fftInput once (only matters when windowSize < fftLength)
+    if (config_.windowSizeSamples < config_.fftLength) {
+        std::memset(fftIn + config_.windowSizeSamples, 0,
+                    (config_.fftLength - config_.windowSizeSamples) * sizeof(float));
+    }
+
+    // Flat contiguous result buffer
+    MelSpectrogramResult result;
+    result.timeSteps = numFrames;
+    result.nMels = config_.nMels;
+    result.data.resize(numFrames * config_.nMels);
+
+    for (int frameIdx = 0; frameIdx < numFrames; ++frameIdx) {
+        const int start = frameIdx * config_.hopLengthSamples;
+
+        // Apply window to frame
+        const int frameLen = std::min(config_.windowSizeSamples, numSamples - start);
+        for (int i = 0; i < frameLen; ++i) {
+            fftIn[i] = samples[start + i] * window_[i];
+        }
+
+        // Compute real FFT
+        kiss_fftr(fftCfg_, fftIn, fftOut);
+
+        // Compute power spectrum (real^2 + imag^2)
+        for (int i = 0; i < numBins; ++i) {
+            power[i] = fftOut[i].r * fftOut[i].r + fftOut[i].i * fftOut[i].i;
+        }
+
+        // Apply sparse mel filterbank
+        float* melRow = result.data.data() + frameIdx * config_.nMels;
+        for (int melIdx = 0; melIdx < config_.nMels; ++melIdx) {
+            const MelFilter& filter = melFilters_[melIdx];
+            const int count = static_cast<int>(filter.weights.size());
+            float sum = 0.0f;
+            const float* w = filter.weights.data();
+            const float* p = power + filter.startBin;
+            for (int k = 0; k < count; ++k) {
+                sum += p[k] * w[k];
+            }
+            melRow[melIdx] = sum;
+        }
+    }
+
+    // Post-processing: log scaling
+    if (config_.logScale) {
+        const int total = numFrames * config_.nMels;
+        float* d = result.data.data();
+        for (int i = 0; i < total; ++i) {
+            d[i] = std::log(std::max(1e-10f, d[i]));
+        }
+    }
+
+    // Post-processing: normalize
+    if (config_.normalize) {
+        const int total = numFrames * config_.nMels;
+        float* d = result.data.data();
+        float minVal = std::numeric_limits<float>::max();
+        float maxVal = std::numeric_limits<float>::lowest();
+        for (int i = 0; i < total; ++i) {
+            minVal = std::min(minVal, d[i]);
+            maxVal = std::max(maxVal, d[i]);
+        }
+        float range = maxVal - minVal;
+        if (range > 0.0f) {
+            float invRange = 1.0f / range;
+            for (int i = 0; i < total; ++i) {
+                d[i] = (d[i] - minVal) * invRange;
+            }
+        }
+    }
+
+    return result;
+}
+
+void MelSpectrogramProcessor::computeFrame(const float* frame, int frameSize, float* melOutput) {
+    const int numBins = config_.fftLength / 2 + 1;
+
+    // Use pre-allocated buffers
+    float* fftIn = fftInput_.data();
+    kiss_fft_cpx* fftOut = fftOutput_.data();
+    float* power = powerSpectrum_.data();
+
+    // Zero and apply window
+    std::memset(fftIn, 0, config_.fftLength * sizeof(float));
+    int len = std::min(frameSize, config_.windowSizeSamples);
+    for (int i = 0; i < len; ++i) {
+        fftIn[i] = frame[i] * window_[i];
+    }
+
+    kiss_fftr(fftCfg_, fftIn, fftOut);
+
+    // Power spectrum -> sparse mel filterbank
+    for (int i = 0; i < numBins; ++i) {
+        power[i] = fftOut[i].r * fftOut[i].r + fftOut[i].i * fftOut[i].i;
+    }
+
+    for (int melIdx = 0; melIdx < config_.nMels; ++melIdx) {
+        const MelFilter& filter = melFilters_[melIdx];
+        const int count = static_cast<int>(filter.weights.size());
+        float sum = 0.0f;
+        const float* w = filter.weights.data();
+        const float* p = power + filter.startBin;
+        for (int k = 0; k < count; ++k) {
+            sum += p[k] * w[k];
+        }
+        melOutput[melIdx] = sum;
+    }
+}

package/cpp/MelSpectrogram.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include "kiss_fft/kiss_fft.h"
+#include "kiss_fft/kiss_fftr.h"
+
+struct MelSpectrogramConfig {
+    int sampleRate;
+    int fftLength = 2048;
+    int windowSizeSamples;
+    int hopLengthSamples;
+    int nMels = 128;
+    float fMin = 0.0f;
+    float fMax = 0.0f;  // 0 = use sampleRate/2
+    int windowType = 0; // 0=hann, 1=hamming
+    bool logScale = true;
+    bool normalize = false;
+
+    bool operator==(const MelSpectrogramConfig& other) const {
+        return sampleRate == other.sampleRate &&
+               fftLength == other.fftLength &&
+               windowSizeSamples == other.windowSizeSamples &&
+               hopLengthSamples == other.hopLengthSamples &&
+               nMels == other.nMels &&
+               fMin == other.fMin &&
+               fMax == other.fMax &&
+               windowType == other.windowType &&
+               logScale == other.logScale &&
+               normalize == other.normalize;
+    }
+};
+
+struct MelSpectrogramResult {
+    std::vector<float> data;  // Flat array: [timeSteps * nMels], row-major
+    int timeSteps;
+    int nMels;
+
+    // Access element at [frame][mel]
+    float& at(int frame, int mel) { return data[frame * nMels + mel]; }
+    float at(int frame, int mel) const { return data[frame * nMels + mel]; }
+};
+
+class MelSpectrogramProcessor {
+public:
+    MelSpectrogramProcessor(const MelSpectrogramConfig& config);
+    ~MelSpectrogramProcessor();
+
+    // Non-copyable (owns FFT plan)
+    MelSpectrogramProcessor(const MelSpectrogramProcessor&) = delete;
+    MelSpectrogramProcessor& operator=(const MelSpectrogramProcessor&) = delete;
+
+    MelSpectrogramResult compute(const float* samples, int numSamples);
+    void computeFrame(const float* frame, int frameSize, float* melOutput);
+
+    const MelSpectrogramConfig& config() const { return config_; }
+
+private:
+    MelSpectrogramConfig config_;
+
+    // Sparse mel filterbank: per mel band, store [startBin, weights[]]
+    struct MelFilter {
+        int startBin;
+        std::vector<float> weights;  // only non-zero weights
+    };
+    std::vector<MelFilter> melFilters_;
+
+    std::vector<float> window_;
+    kiss_fftr_cfg fftCfg_;
+
+    // Pre-allocated work buffers (avoid per-frame allocation)
+    std::vector<float> fftInput_;
+    std::vector<kiss_fft_cpx> fftOutput_;
+    std::vector<float> powerSpectrum_;
+
+    void buildMelFilterbank();
+    void buildWindow();
+    void allocateBuffers();
+
+    static float hzToMel(float hz);
+    static float melToHz(float mel);
+};

package/cpp/MelSpectrogramBridge.cpp

@@ -0,0 +1,112 @@
+#include "MelSpectrogramBridge.h"
+#include "MelSpectrogram.h"
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <memory>
+#include <mutex>
+
+// Cache the processor so repeated calls with the same config skip
+// FFT plan creation, window computation, and filterbank generation.
+static std::unique_ptr<MelSpectrogramProcessor> cachedProcessor;
+static std::mutex cachedMutex;
+
+extern "C" {
+
+CMelSpectrogramResult* mel_spectrogram_compute(
+    const float* samples, int numSamples, int sampleRate,
+    int fftLength, int windowSizeSamples, int hopLengthSamples,
+    int nMels, float fMin, float fMax,
+    int windowType, int logScale, int normalize)
+{
+    MelSpectrogramConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.windowSizeSamples = windowSizeSamples;
+    config.hopLengthSamples = hopLengthSamples;
+    config.nMels = nMels;
+    config.fMin = fMin;
+    config.fMax = fMax;
+    config.windowType = windowType;
+    config.logScale = (logScale != 0);
+    config.normalize = (normalize != 0);
+
+    // Reuse processor if config matches
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<MelSpectrogramProcessor>(config);
+    }
+
+    MelSpectrogramResult result = cachedProcessor->compute(samples, numSamples);
+
+    if (result.timeSteps <= 0) {
+        return nullptr;
+    }
+
+    // Allocate C result — data is already flat, just transfer ownership
+    CMelSpectrogramResult* cResult = (CMelSpectrogramResult*)malloc(sizeof(CMelSpectrogramResult));
+    if (!cResult) return nullptr;
+    cResult->timeSteps = result.timeSteps;
+    cResult->nMels = result.nMels;
+    const size_t dataSize = result.timeSteps * result.nMels * sizeof(float);
+    cResult->data = (float*)malloc(dataSize);
+    if (!cResult->data) { free(cResult); return nullptr; }
+    std::memcpy(cResult->data, result.data.data(), dataSize);
+
+    return cResult;
+}
+
+void mel_spectrogram_free(CMelSpectrogramResult* result) {
+    if (result) {
+        if (result->data) {
+            free(result->data);
+        }
+        free(result);
+    }
+}
+
+void mel_spectrogram_init(int sampleRate, int fftLength, int windowSizeSamples,
+    int hopLengthSamples, int nMels, float fMin, float fMax, int windowType)
+{
+    MelSpectrogramConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.windowSizeSamples = windowSizeSamples;
+    config.hopLengthSamples = hopLengthSamples;
+    config.nMels = nMels;
+    config.fMin = fMin;
+    config.fMax = fMax;
+    config.windowType = windowType;
+    config.logScale = false;  // log applied manually per-frame below
+    config.normalize = false;
+
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<MelSpectrogramProcessor>(config);
+    }
+}
+
+int mel_spectrogram_compute_frame(const float* frame, int frameSize, float* melOutput) {
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !frame || !melOutput) {
+        return 0;
+    }
+    cachedProcessor->computeFrame(frame, frameSize, melOutput);
+    // Apply log scaling (matches compute() logScale behavior)
+    const int nMels = cachedProcessor->config().nMels;
+    for (int i = 0; i < nMels; ++i) {
+        melOutput[i] = std::log(std::max(1e-10f, melOutput[i]));
+    }
+    return 1;
+}
+
+int mel_spectrogram_get_n_mels(void) {
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor) {
+        return 0;
+    }
+    return cachedProcessor->config().nMels;
+}
+
+} // extern "C"

package/cpp/MelSpectrogramBridge.h

@@ -0,0 +1,33 @@
+#ifndef MEL_SPECTROGRAM_BRIDGE_H
+#define MEL_SPECTROGRAM_BRIDGE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    float* data;       // Flat array: timeSteps * nMels
+    int timeSteps;
+    int nMels;
+} CMelSpectrogramResult;
+
+CMelSpectrogramResult* mel_spectrogram_compute(
+    const float* samples, int numSamples, int sampleRate,
+    int fftLength, int windowSizeSamples, int hopLengthSamples,
+    int nMels, float fMin, float fMax,
+    int windowType, int logScale, int normalize);
+
+void mel_spectrogram_free(CMelSpectrogramResult* result);
+
+// Single-frame API for live/per-segment mel computation
+void mel_spectrogram_init(int sampleRate, int fftLength, int windowSizeSamples,
+    int hopLengthSamples, int nMels, float fMin, float fMax, int windowType);
+// Note: always applies log scaling (log(max(1e-10, val))) regardless of config.logScale
+int mel_spectrogram_compute_frame(const float* frame, int frameSize, float* melOutput);
+int mel_spectrogram_get_n_mels(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MEL_SPECTROGRAM_BRIDGE_H

package/cpp/kiss_fft/COPYING

@@ -0,0 +1,11 @@
+Copyright (c) 2003-2010 Mark Borgerding . All rights reserved.
+
+KISS FFT is provided under:
+
+  SPDX-License-Identifier: BSD-3-Clause
+
+Being under the terms of the BSD 3-clause "New" or "Revised" License,
+according with:
+
+  LICENSES/BSD-3-Clause
+