Files
2026-10-10 16:03:44 +02:00

233 lines
8.6 KiB
C++

#include "boomcast_audio.h"
#include "boomcast_audio_session.h"
#include "boomcast_config.h"
#include "boomcast_state.h"
#include "audio_bsp.h"
#include <math.h>
#include "esp_heap_caps.h"
#include <sys/time.h>
extern "C" {
#include "src/esp_codec_dev/include/esp_codec_dev.h"
extern esp_codec_dev_handle_t record;
extern esp_codec_dev_handle_t playback;
#include "src/codec_board/codec_board.h"
#include "src/codec_board/codec_init.h"
}
BoomAudio boomAudio;
bool BoomAudio::begin(BoomQueue* queue) {
queue_ = queue;
sensitivity_ = boomState.sensitivity();
ring_ = (int16_t*)heap_caps_malloc(PRE_EVENT_SAMPLES * sizeof(int16_t), MALLOC_CAP_SPIRAM);
capture_ = (int16_t*)heap_caps_malloc(CAPTURE_SAMPLES * sizeof(int16_t), MALLOC_CAP_SPIRAM);
if (!ring_ || !capture_) {
fault_.store(true);
restartRequired_.store(true);
free(ring_); free(capture_); ring_ = capture_ = nullptr;
Serial.println("[Audio] PSRAM allocation failed");
return false;
}
memset(ring_, 0, PRE_EVENT_SAMPLES * sizeof(int16_t));
memset(capture_, 0, CAPTURE_SAMPLES * sizeof(int16_t));
// Use the same board setup without the example's abort-on-error wrapper.
set_codec_board_type("S3_ePaper_1_54");
codec_init_cfg_t cfg{};
cfg.in_mode = cfg.out_mode = CODEC_I2S_MODE_STD;
if (init_codec(&cfg) != 0) { fault_.store(true); restartRequired_.store(true); return false; }
record = get_record_handle(); playback = get_playback_handle();
if (!record || !playback) { fault_.store(true); restartRequired_.store(true); return false; }
if (xTaskCreatePinnedToCore(taskThunk, "boom_audio", 8192, this, 5, &task_, 0) != pdPASS) {
fault_.store(true); restartRequired_.store(true); return false;
}
Serial.println("[Audio] detector task started");
return true;
}
void BoomAudio::resetBuffers() {
ringFilled_ = ringWrite_ = captureWrite_ = 0;
detector_.reset();
int8_t empty[BOOMCAST_WAVEFORM_POINTS]{};
boomState.setWaveform(empty, BOOMCAST_WAVEFORM_POINTS);
}
void BoomAudio::closeCodec() {
// Both handles share I2S. Close both to stop RX and TX DMA; keep allocated
// handles/buffers for reuse (deinit_codec also destroys the shared RTC I2C bus).
esp_codec_dev_close(record);
esp_codec_dev_close(playback);
active_.store(false);
resetBuffers();
}
bool BoomAudio::openCodec() {
esp_codec_dev_sample_info_t fs{};
fs.sample_rate = AUDIO_SAMPLE_RATE; fs.channel = 2; fs.bits_per_sample = 16;
bool ok = esp_codec_dev_open(playback, &fs) == ESP_CODEC_DEV_OK &&
esp_codec_dev_open(record, &fs) == ESP_CODEC_DEV_OK &&
esp_codec_dev_set_in_gain(record, BOOMCAST_CODEC_INPUT_GAIN_DB) == ESP_CODEC_DEV_OK;
if (!ok) closeCodec();
resetBuffers();
fault_.store(!ok);
return ok;
}
void BoomAudio::setSensitivity(uint8_t value) {
sensitivity_ = constrain(value, 1, 100);
}
void BoomAudio::taskThunk(void* arg) {
static_cast<BoomAudio*>(arg)->taskLoop();
}
void BoomAudio::taskLoop() {
uint8_t* raw = (uint8_t*)heap_caps_malloc(AUDIO_RAW_BLOCK_BYTES, MALLOC_CAP_SPIRAM);
int16_t* mono = (int16_t*)heap_caps_malloc(AUDIO_FRAMES_PER_BLOCK * sizeof(int16_t), MALLOC_CAP_SPIRAM);
if (!raw || !mono) {
fault_.store(true);
restartRequired_.store(true);
free(raw); free(mono);
Serial.println("[Audio] block allocation failed");
vTaskDelete(nullptr);
return;
}
BoomAudioSession session(AUDIO_SAMPLE_RATE);
while (true) {
auto action = session.next(requested_.load(), capturing_);
if (action == BoomAudioSession::Action::Suspend) {
if (session.isOpen()) { closeCodec(); session.closed(); }
suspended_.store(true);
delay(200);
continue;
}
suspended_.store(false);
if (action == BoomAudioSession::Action::Open) {
if (!openCodec()) { delay(1000); continue; }
session.opened();
// Drain a second of fresh DMA input before feeding baseline/pre-trigger
// buffers. Detector reset then adds its usual 3-second trigger cooldown.
}
memset(raw, 0, AUDIO_RAW_BLOCK_BYTES);
const int readResult = esp_codec_dev_read(record, raw, AUDIO_RAW_BLOCK_BYTES);
if (readResult != ESP_CODEC_DEV_OK) {
++failedReads_;
active_.store(false);
fault_.store(true);
if (session.failedRead()) { closeCodec(); session.closed(); }
droppedSamples_ += AUDIO_FRAMES_PER_BLOCK;
// A failed read invalidates timing continuity. Discard an active clip.
if (capturing_) {
++recordingErrors_;
capturing_ = false;
captureWrite_ = 0;
boomState.setCapturing(false);
}
ringFilled_ = 0;
ringWrite_ = 0;
detector_.reset();
boomState.setAudioDiagnostics(failedReads_, recordingErrors_);
if (failedReads_ % 100 == 1) Serial.printf("[Audio] read errors=%lu dropped=%lu recording errors=%lu\n",
(unsigned long)failedReads_, (unsigned long)droppedSamples_, (unsigned long)recordingErrors_);
delay(10);
continue;
}
fault_.store(false);
if (!session.usableRead(AUDIO_FRAMES_PER_BLOCK)) continue;
active_.store(true);
const int16_t* stereo = reinterpret_cast<const int16_t*>(raw);
for (size_t i = 0; i < AUDIO_FRAMES_PER_BLOCK; ++i) {
mono[i] = stereo[i * 2 + AUDIO_MIC_SLOT];
}
processMonoBlock(mono, AUDIO_FRAMES_PER_BLOCK);
}
}
void BoomAudio::updateWaveform(const int16_t* mono, size_t frames) {
int8_t points[BOOMCAST_WAVEFORM_POINTS] = {0};
for (size_t p = 0; p < BOOMCAST_WAVEFORM_POINTS; ++p) {
size_t start = (p * frames) / BOOMCAST_WAVEFORM_POINTS;
size_t end = ((p + 1) * frames) / BOOMCAST_WAVEFORM_POINTS;
if (end <= start) end = min(start + 1, frames);
int32_t peak = 0;
int sign = 1;
for (size_t i = start; i < end; ++i) {
int32_t v = mono[i];
if (abs(v) > abs(peak)) { peak = v; sign = v < 0 ? -1 : 1; }
}
int scaled = constrain((abs(peak) * 100) / 32768, 0, 100);
points[p] = (int8_t)(scaled * sign);
}
boomState.setWaveform(points, BOOMCAST_WAVEFORM_POINTS);
}
void BoomAudio::processMonoBlock(const int16_t* mono, size_t frames) {
updateWaveform(mono, frames);
for (size_t i = 0; i < frames; ++i) {
const int16_t sample = mono[i];
// The slider changes the effective input level; the worklet thresholds stay fixed.
float normalised = (float(sample) / 32768.0f) * AUDIO_MIC_NORMALISED_GAIN
* (float(sensitivity_) / AUDIO_SENSITIVITY_REFERENCE);
normalised = constrain(normalised, -1.0f, 1.0f);
if (!capturing_) pushRing(&sample, 1);
const BoomDetector::Result result = detector_.process(normalised);
if (result == BoomDetector::Result::Trigger) beginCapture();
else if (capturing_ && result != BoomDetector::Result::TailDone) appendCapture(sample);
if (result == BoomDetector::Result::TailDone) {
appendCapture(sample);
finishCapture();
if (!requested_.load()) return;
}
}
}
void BoomAudio::pushRing(const int16_t* mono, size_t frames) {
for (size_t i = 0; i < frames; ++i) {
ring_[ringWrite_] = mono[i];
ringWrite_ = (ringWrite_ + 1) % PRE_EVENT_SAMPLES;
if (ringFilled_ < PRE_EVENT_SAMPLES) ++ringFilled_;
}
}
void BoomAudio::beginCapture() {
captureWrite_ = 0;
captureTarget_ = min(CAPTURE_SAMPLES, ringFilled_ + size_t(AUDIO_SAMPLE_RATE * POST_EVENT_MS / 1000));
struct timeval now; gettimeofday(&now, nullptr);
triggeredMs_ = now.tv_sec > 1577836800 ? uint64_t(now.tv_sec) * 1000 + now.tv_usec / 1000 : 0;
captureStartedMs_ = triggeredMs_ ? triggeredMs_ - (ringFilled_ * 1000 / AUDIO_SAMPLE_RATE) : 0;
capturing_ = true;
boomState.setCapturing(true);
// Copy the rolling pre-trigger buffer in chronological order.
size_t count = ringFilled_;
size_t start = (ringWrite_ + PRE_EVENT_SAMPLES - count) % PRE_EVENT_SAMPLES;
for (size_t i = 0; i < count && captureWrite_ < captureTarget_; ++i) {
capture_[captureWrite_++] = ring_[(start + i) % PRE_EVENT_SAMPLES];
}
}
void BoomAudio::appendCapture(int16_t sample) {
if (captureWrite_ < captureTarget_) capture_[captureWrite_++] = sample;
}
void BoomAudio::finishCapture() {
String filename;
bool saved = queue_ && queue_->saveWav(capture_, captureWrite_, "audio_spike", &filename, captureStartedMs_, triggeredMs_);
if (saved) {
boomState.incrementTodayEvents();
Serial.printf("[Audio] captured %s\n", filename.c_str());
} else {
++recordingErrors_;
boomState.setAudioDiagnostics(failedReads_, recordingErrors_);
Serial.printf("[Audio] queue error; recording errors=%lu\n", (unsigned long)recordingErrors_);
}
// Browser reset clears its rolling audio and starts a fresh 3 s cooldown.
ringFilled_ = 0;
ringWrite_ = 0;
detector_.reset();
captureWrite_ = 0;
capturing_ = false;
boomState.setCapturing(false);
}