ESP32-S3录一段WAV：把真实I2S采集变成可检查的文件

python3 tools/audio_tool.py inspect /path/to/A01_000.wav
/tmp/audioio-check /path/to/A01_000.wav

// ---- esp32-i2s-mic-wav.ino ----
// A01: real microphone only. No synthetic PCM path exists in this firmware.
#include <Arduino.h>
#include <SPI.h>
#include <SD.h>
#include <driver/i2s_std.h>
#include <esp_timer.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
#include "audio_core.h"
using namespace audioio;
constexpr int Bclk=5, Ws=4, Din=6, Button=7, Sck=12, Miso=13, Mosi=11, Cs=10;
static i2s_chan_handle_t rx=nullptr;
static volatile uint32_t overflows=0;
static bool mounted=false;
static Press recordPress;
static uint32_t raw[512]; // 256 stereo frames, two32bit slots per frame.
static uint8_t pcm[512];
static bool IRAM_ATTR overflow(i2s_chan_handle_t,i2s_event_data_t*,void*){
 __atomic_fetch_add(&overflows,1u,__ATOMIC_RELAXED);return false;
}
static uint32_t lost(){return __atomic_load_n(&overflows,__ATOMIC_RELAXED);}
static bool startRX(){
 i2s_chan_config_t c=I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO,I2S_ROLE_MASTER);
 c.dma_desc_num=12;c.dma_frame_num=256;
 if(i2s_new_channel(&c,nullptr,&rx)!=ESP_OK)return false;
 i2s_std_config_t s={};s.clk_cfg=I2S_STD_CLK_DEFAULT_CONFIG(Rate);
 s.slot_cfg=I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_32BIT,I2S_SLOT_MODE_STEREO);
 s.gpio_cfg.mclk=I2S_GPIO_UNUSED;s.gpio_cfg.bclk=gpio_num_t(Bclk);s.gpio_cfg.ws=gpio_num_t(Ws);s.gpio_cfg.dout=I2S_GPIO_UNUSED;s.gpio_cfg.din=gpio_num_t(Din);
 if(i2s_channel_init_std_mode(rx,&s)!=ESP_OK)return false;
 i2s_event_callbacks_t cb={};cb.on_recv_q_ovf=overflow;
 if(i2s_channel_register_event_callback(rx,&cb,nullptr)!=ESP_OK)return false;
 __atomic_store_n(&overflows,0u,__ATOMIC_RELAXED);
 return i2s_channel_enable(rx)==ESP_OK;
}
static void stopRX(){
 if(!rx)return;
 // disable can fail if init never reached RUNNING; delete still releases a READY channel.
 i2s_channel_disable(rx);i2s_del_channel(rx);rx=nullptr;
 pinMode(Bclk,OUTPUT);digitalWrite(Bclk,LOW);pinMode(Ws,OUTPUT);digitalWrite(Ws,LOW);
}
static bool readFrames(size_t frames){
 size_t got=0,want=frames*8;
 esp_err_t e=i2s_channel_read(rx,raw,want,&got,500);
 if(e!=ESP_OK||got!=want||lost()){
  Serial.printf("RX_ABORT err=%s got=%u want=%u overflows=%lu\n",esp_err_to_name(e),unsigned(got),unsigned(want),(unsigned long)lost());return false;
 }
 return true;
}
static bool absent(const char* name){struct stat s;if(stat(name,&s)==0)return false;return errno==ENOENT;}
static FILE* newFile(char* part,char* good){
 for(unsigned n=0;n<1000;n++){
  snprintf(part,64,"/sd/A01_%03u.part",n);snprintf(good,64,"/sd/A01_%03u.wav",n);
  if(!absent(good)||!absent(part))continue;
  int fd=open(part,O_CREAT|O_EXCL|O_RDWR,0600);if(fd<0)return nullptr;
  FILE* f=fdopen(fd,"w+b");if(!f){close(fd);return nullptr;}return f;
 }
 return nullptr;
}
static void recordWav(){
 char part[64],good[64];FILE* f=newFile(part,good);
 if(!f){Serial.printf("CREATE_ABORT errno=%d; existing files retained\n",errno);return;}
 uint8_t h[44];header(h,Rate,1,0);bool ok=fwrite(h,1,44,f)==44;
 uint32_t frames=0;CaptureDSP dsp;
 if(ok)ok=startRX();
 // Discard 8000 *received* stereo frames (250ms atnominal32k), not a delay leaving old DMA data queued.
 for(uint32_t n=0;ok&&n<Rate/4;){size_t k=min(size_t(256),size_t(Rate/4-n));ok=readFrames(k);n+=uint32_t(k);}
 while(ok&&frames<CaptureFrames){
  size_t k=min(size_t(256),size_t(CaptureFrames-frames));ok=readFrames(k);if(!ok)break;
  for(size_t n=0;n<k;n++)put16(pcm+2*n,uint16_t(dsp.sample(raw[2*n],256,true)));
  ok=fwrite(pcm,1,k*2,f)==k*2;if(ok)frames+=uint32_t(k);
 }
 // Conservative: any overflow before the completed capture is rejected, never silently compact a gap.
 if(lost())ok=false;stopRX();
 if(ok){header(h,Rate,1,frames*2);ok=fseek(f,0,SEEK_SET)==0&&fwrite(h,1,44,f)==44;}
 if(ok)ok=fflush(f)==0;
 if(ok)ok=fsync(fileno(f))==0;
 int closeResult=fclose(f);if(closeResult!=0)ok=false;
 if(ok)ok=rename(part,good)==0;
 Serial.printf("%s path=%s frames=%lu data_bytes=%lu peak24=%ld clips=%lu overflows=%lu optical_acoustic=UNTESTED\n",ok?"WAV_COMMITTED":"PART_RETAINED",ok?good:part,(unsigned long)frames,(unsigned long)(frames*2),(long)dsp.peak24,(unsigned long)dsp.clipped,(unsigned long)lost());
 // FAT sync/rename cannot promise power-fail atomicity. Inspect the copied file before listening.
}
void setup(){
 Serial.begin(115200);pinMode(Button,INPUT); // External10k to3V3; button toGND.
 SPI.begin(Sck,Miso,Mosi,Cs);mounted=SD.begin(Cs,SPI,4000000,"/sd",5,false);
 Serial.printf("A01 Arduino3.3.12 IDF%s SD=%s; release button, then press for real10s capture\n",esp_get_idf_version(),mounted?"READY":"FAILED");
}
void loop(){
 bool press=recordPress.update(digitalRead(Button)==LOW,uint64_t(esp_timer_get_time())/1000);
 if(press&&mounted)recordWav();delay(2);
}

// ---- audio_core.h ----
#pragma once
// Original MIT code. Same header is compiled on ESP32 and in the desktop fixtures.
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
namespace audioio {
constexpr uint32_t Rate=32000, CaptureFrames=Rate*10, MaxFile=8*1024*1024;
inline uint16_t le16(const uint8_t* p){return uint16_t(p[0])|(uint16_t(p[1])<<8);}
inline uint32_t le32(const uint8_t* p){return uint32_t(p[0])|(uint32_t(p[1])<<8)|(uint32_t(p[2])<<16)|(uint32_t(p[3])<<24);}
inline void put16(uint8_t* p,uint16_t n){p[0]=uint8_t(n);p[1]=uint8_t(n>>8);}
inline void put32(uint8_t* p,uint32_t n){for(unsigned i=0;i<4;i++)p[i]=uint8_t(n>>(8*i));}
inline bool rateOK(uint32_t n){return n==16000||n==32000||n==48000;}
inline void header(uint8_t* h,uint32_t rate,uint16_t channels,uint32_t bytes){
 memset(h,0,44);memcpy(h,"RIFF",4);put32(h+4,36+bytes);memcpy(h+8,"WAVEfmt ",8);put32(h+16,16);
 put16(h+20,1);put16(h+22,channels);put32(h+24,rate);put32(h+28,rate*channels*2);put16(h+32,channels*2);put16(h+34,16);memcpy(h+36,"data",4);put32(h+40,bytes);
}
struct Wav {uint32_t rate=0,offset=0,bytes=0,frames=0;uint16_t channels=0;};
// Bounded, little-endian RIFF/WAVE PCM16 subset. Unknown chunks are skipped with padding.
inline const char* parse(FILE* f,Wav& w){
 w=Wav{};if(!f||fseek(f,0,SEEK_END))return "SEEK";long end=ftell(f);if(end<44||uint64_t(end)>MaxFile)return "FILE_SIZE";
 if(fseek(f,0,SEEK_SET))return "SEEK";uint8_t h[12];if(fread(h,1,12,f)!=12)return "READ";
 if(memcmp(h,"RIFF",4)||memcmp(h+8,"WAVE",4))return "RIFF_WAVE";
 if(uint64_t(le32(h+4))+8!=uint64_t(end))return "RIFF_SIZE";
 bool fmt=false,data=false;uint32_t pos=12;
 while(pos<uint32_t(end)){
  if(uint32_t(end)-pos<8||fseek(f,long(pos),SEEK_SET))return "CHUNK_HEADER";
  uint8_t c[8];if(fread(c,1,8,f)!=8)return "READ";uint32_t n=le32(c+4);uint64_t next=uint64_t(pos)+8+n+(n&1u);
  if(next>uint64_t(end))return "CHUNK_BOUNDS";
  if(!memcmp(c,"fmt ",4)){
   if(fmt||data||n!=16)return "FMT_SUBSET";uint8_t v[16];if(fread(v,1,16,f)!=16)return "READ";
   uint16_t ch=le16(v+2),align=le16(v+12);uint32_t rate=le32(v+4);
   if(le16(v)!=1||le16(v+14)!=16||(ch!=1&&ch!=2)||!rateOK(rate)||align!=ch*2||le32(v+8)!=rate*align)return "PCM_SUBSET";
   w.rate=rate;w.channels=ch;fmt=true;
  }else if(!memcmp(c,"data",4)){
   if(!fmt||data||!n||n%(w.channels*2))return "DATA_SUBSET";
   w.offset=pos+8;w.bytes=n;w.frames=n/(w.channels*2);data=true;
   if(w.frames>15*w.rate)return "DURATION_LIMIT";
  }
  pos=uint32_t(next);
 }
 if(!fmt||!data)return "MISSING_CHUNK";if(fseek(f,long(w.offset),SEEK_SET))return "SEEK";return nullptr;
}
// A 24-bit signed microphone word occupies bits31..8 of the captured left 32-bit slot.
inline int32_t mic24(uint32_t slot){uint32_t n=slot>>8;return n&0x800000u?int32_t(n)-16777216:int32_t(n);}
struct CaptureDSP {
 int64_t dcQ16=0;uint32_t clipped=0;int32_t peak24=0;
 // DC EMA alpha=1/1024 at32kHz (~5Hz corner); gainQ8=256 means unity.
 int16_t sample(uint32_t slot,uint16_t gainQ8=256,bool removeDC=true){
  int32_t x=mic24(slot);int32_t a=x<0?-x:x;if(a>peak24)peak24=a;
  if(removeDC){dcQ16+=(int64_t(x)*65536-dcQ16)/1024;x-=int32_t(dcQ16/65536);}
  int64_t y=int64_t(x)*gainQ8/65536;
  if(y>32767){y=32767;clipped++;}if(y< -32768){y=-32768;clipped++;}return int16_t(y);
 }
};
// Fixed -24.08dB attenuation, then hard limit. This is not acoustic-volume calibration.
inline int16_t output(int16_t sample){int32_t n=int32_t(sample)/16;if(n>2048)n=2048;if(n< -2048)n=-2048;return int16_t(n);}
inline int16_t route(int16_t left,int16_t right,unsigned mode){return mode==0?left:mode==1?right:int16_t((int32_t(left)+right)/2);}
struct Press {
 bool raw=false,stable=false,released=false,initialized=false;uint64_t at=0;
 bool update(bool down,uint64_t now){
  if(!initialized){initialized=true;raw=stable=down;at=now;return false;}
  if(down!=raw){raw=down;at=now;}
  if(now-at<50)return false;
  if(!raw)released=true;
  if(raw==stable)return false;stable=raw;
  if(stable&&released){released=false;return true;}return false;
 }
};
}

python3 tools/audio_tool.py salvage /copy/A01_000.part /copy/recovered-copy.wav
python3 tools/audio_tool.py inspect /copy/recovered-copy.wav
/tmp/audioio-check /copy/recovered-copy.wav

arduino-cli version
arduino-cli core list
FQBN='esp32:esp32:esp32s3:FlashSize=8M,PSRAM=opi,FlashMode=qio,PartitionScheme=default_8MB,CDCOnBoot=default,USBMode=hwcdc'
arduino-cli compile --fqbn "$FQBN" --build-path build --warnings all .
arduino-cli upload --fqbn "$FQBN" --input-dir build --port PORT .
arduino-cli monitor --port PORT --config baudrate=115200

clang++ -std=c++17 -Wall -Wextra -Werror -fsanitize=address,undefined -fno-omit-frame-pointer tests/host.cpp -o /tmp/audioio-check
/tmp/audioio-check
python3 tools/audio_tool.py self-test --checker /tmp/audioio-check
python3 tools/audio_tool.py tone SYNTH.WAV --rate 32000
python3 tools/audio_tool.py inspect SYNTH.WAV
python3 tools/waveform.py SYNTH.WAV synthetic-first100ms.svg
/tmp/audioio-check SYNTH.WAV

git clone https://github.com/arduino/ctags.git .ctags-src
git -C .ctags-src checkout abc8fca7499f44c725122881cd380a88c37abe0e
cd .ctags-src
./configure CC=clang CFLAGS='-O2 -arch arm64' --prefix="$PWD/../.ctags-native"
make -j2 CFLAGS='-O2 -arch arm64 -include dirent.h'
make install
cd ..
.ctags-native/bin/ctags --version
arduino-cli compile --fqbn "$FQBN" --build-path build --verbose --build-property "runtime.tools.ctags.path=$PWD/.ctags-native/bin" --build-property "runtime.tools.ctags-5.8-arduino11.path=$PWD/.ctags-native/bin" .