hexianglong/snapclient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reduce RAM footprint of dsp processor and add a simple EQ (bass, treble) to dsp processor

Browse Source 
dsp processor now will process smaller chunks of audio at a time and loop over the audio data array
which results in a much smaller RAM usage but probably longer execution times
of IIR filters.

Signed-off-by: Karl Osterseher <karli_o@gmx.at>
This commit is contained in:
Karl Osterseher
2023-01-05 20:30:57 +01:00
Unverified
parent 280367e3a3
commit d2a21f99ac
5 changed files with 292 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
components/dsp_processor/Kconfig.projbuild
View File

@@ -22,6 +22,9 @@ menu "ESP32 DSP processor config"
config SNAPCLIENT_DSP_FLOW_BIAMP
bool "Bi-Amp flow"
config SNAPCLIENT_DSP_FLOW_BASS_TREBLE_EQ
bool "Bass Treble EQ"
endchoice
config USE_BIQUAD_ASM

480
components/dsp_processor/dsp_processor.c
View File

@@ -28,191 +28,271 @@
static const char *TAG = "dspProc";
static float *sbuffer0 = NULL;
static float *sbufout0 = NULL;
static float *sbuftmp0 = NULL;
static uint32_t currentSamplerate = 0;
static uint32_t currentChunkInFrames = 0;
static ptype_t bq[8];
static ptype_t bq[12];
static double dynamic_vol = 1.0;
#define DSP_PROCESSOR_LEN 16
int dsp_processor(char *audio, size_t chunk_size, dspFlows_t dspFlow) {
int16_t len = chunk_size / 4;
int16_t valint;
uint16_t i;
volatile uint32_t *audio_tmp =
(uint32_t *)audio; // volatile needed to ensure 32 bit access
float *sbuffer0 = NULL;
float *sbufout0 = NULL;
if ((sbuffer0 == NULL) || (sbufout0 == NULL) || (sbuftmp0 == NULL)) {
ESP_LOGE(TAG, "No Memory allocated for dsp_processor %p %p %p", sbuffer0,
sbufout0, sbuftmp0);
// only process data if it is valid
if (audio_tmp) {
sbuffer0 = (float *)heap_caps_malloc(sizeof(float) * DSP_PROCESSOR_LEN,
MALLOC_CAP_8BIT);
if (sbuffer0 == NULL) {
ESP_LOGE(TAG, "No Memory allocated for dsp_processor sbuffer0");
return -1;
return -1;
}
sbufout0 = (float *)heap_caps_malloc(sizeof(float) * DSP_PROCESSOR_LEN,
MALLOC_CAP_8BIT);
if (sbufout0 == NULL) {
ESP_LOGE(TAG, "No Memory allocated for dsp_processor sbufout0");
free(sbuffer0);
return -1;
}
switch (dspFlow) {
case dspfEQBassTreble: {
for (int k = 0; k < len; k += DSP_PROCESSOR_LEN) {
volatile uint32_t *tmp = (uint32_t *)(&audio_tmp[k]);
// channel 0
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)(tmp[i] & 0xFFFF))) / 32768;
}
// BASS
BIQUAD(sbuffer0, sbufout0, DSP_PROCESSOR_LEN, bq[8].coeffs, bq[8].w);
// TREBLE
BIQUAD(sbufout0, sbuffer0, DSP_PROCESSOR_LEN, bq[9].coeffs, bq[9].w);
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
valint = (int16_t)(sbuffer0[i] * 32768);
tmp[i] = (tmp[i] & 0xFFFF0000) + (uint32_t)valint;
}
// channel 1
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)((tmp[i] & 0xFFFF0000) >> 16))) /
32768;
}
// BASS
BIQUAD(sbuffer0, sbufout0, DSP_PROCESSOR_LEN, bq[10].coeffs,
bq[10].w);
// TREBLE
BIQUAD(sbufout0, sbuffer0, DSP_PROCESSOR_LEN, bq[11].coeffs,
bq[11].w);
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
valint = (int16_t)(sbuffer0[i] * 32768);
tmp[i] = (tmp[i] & 0xFFFF) + ((uint32_t)valint << 16);
}
}
break;
}
case dspfStereo: {
for (int k = 0; k < len; k += DSP_PROCESSOR_LEN) {
volatile uint32_t *tmp = (uint32_t *)(&audio_tmp[k]);
// set volume
if (dynamic_vol != 1.0) {
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
tmp[i] =
((uint32_t)(dynamic_vol *
((float)((int16_t)((tmp[i] & 0xFFFF0000) >> 16))))
<< 16) +
(uint32_t)(dynamic_vol *
((float)((int16_t)(tmp[i] & 0xFFFF))));
}
}
}
break;
}
case dspfBassBoost: { // CH0 low shelf 6dB @ 400Hz
for (int k = 0; k < len; k += DSP_PROCESSOR_LEN) {
volatile uint32_t *tmp = (uint32_t *)(&audio_tmp[k]);
// channel 0
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)(tmp[i] & 0xFFFF))) / 32768;
}
BIQUAD(sbuffer0, sbufout0, DSP_PROCESSOR_LEN, bq[6].coeffs, bq[6].w);
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
valint = (int16_t)(sbufout0[i] * 32768);
tmp[i] = (tmp[i] & 0xFFFF0000) + (uint32_t)valint;
}
// channel 1
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)((tmp[i] & 0xFFFF0000) >> 16))) /
32768;
}
BIQUAD(sbuffer0, sbufout0, DSP_PROCESSOR_LEN, bq[7].coeffs, bq[7].w);
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
valint = (int16_t)(sbufout0[i] * 32768);
tmp[i] = (tmp[i] & 0xFFFF) + ((uint32_t)valint << 16);
}
}
break;
}
case dspfBiamp: {
for (int k = 0; k < len; k += DSP_PROCESSOR_LEN) {
volatile uint32_t *tmp = (uint32_t *)(&audio_tmp[k]);
// Process audio ch0 LOW PASS FILTER
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)(tmp[i] & 0xFFFF))) / 32768;
}
BIQUAD(sbuffer0, sbufout0, DSP_PROCESSOR_LEN, bq[0].coeffs, bq[0].w);
BIQUAD(sbufout0, sbuffer0, DSP_PROCESSOR_LEN, bq[1].coeffs, bq[1].w);
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
valint = (int16_t)(sbuffer0[i] * 32768);
tmp[i] = (tmp[i] & 0xFFFF0000) + (uint32_t)valint;
}
// Process audio ch1 HIGH PASS FILTER
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)((tmp[i] & 0xFFFF0000) >> 16))) /
32768;
}
BIQUAD(sbuffer0, sbufout0, DSP_PROCESSOR_LEN, bq[2].coeffs, bq[2].w);
BIQUAD(sbufout0, sbuffer0, DSP_PROCESSOR_LEN, bq[3].coeffs, bq[3].w);
for (i = 0; i < DSP_PROCESSOR_LEN; i++) {
valint = (int16_t)(sbuffer0[i] * 32768);
tmp[i] = (tmp[i] & 0xFFFF) + ((uint32_t)valint << 16);
}
}
break;
}
case dspf2DOT1: { // Process audio L + R LOW PASS FILTER
/*
BIQUAD(sbuffer2, sbuftmp0, len, bq[0].coeffs, bq[0].w);
BIQUAD(sbuftmp0, sbufout2, len, bq[1].coeffs, bq[1].w);
// Process audio L HIGH PASS FILTER
BIQUAD(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
BIQUAD(sbuftmp0, sbufout0, len, bq[3].coeffs, bq[3].w);
// Process audio R HIGH PASS FILTER
BIQUAD(sbuffer1, sbuftmp0, len, bq[4].coeffs, bq[4].w);
BIQUAD(sbuftmp0, sbufout1, len, bq[5].coeffs, bq[5].w);
int16_t valint[5];
for (uint16_t i = 0; i < len; i++) {
valint[0] =
(muteCH[0] == 1) ? (int16_t)0 : (int16_t)(sbufout0[i] *
32768); valint[1] = (muteCH[1] == 1) ? (int16_t)0 :
(int16_t)(sbufout1[i] * 32768); valint[2] = (muteCH[2] == 1) ?
(int16_t)0 : (int16_t)(sbufout2[i] * 32768); dsp_audio[i * 4 + 0] =
(valint[2] & 0xff); dsp_audio[i * 4 + 1] = ((valint[2] & 0xff00) >>
8); dsp_audio[i * 4 + 2] = 0; dsp_audio[i * 4 + 3] = 0;
dsp_audio1[i * 4 + 0] = (valint[0] & 0xff);
dsp_audio1[i * 4 + 1] = ((valint[0] & 0xff00) >> 8);
dsp_audio1[i * 4 + 2] = (valint[1] & 0xff);
dsp_audio1[i * 4 + 3] = ((valint[1] & 0xff00) >> 8);
}
// TODO: this copy could be avoided if dsp_audio buffers are
// allocated dynamically and pointers are exchanged after
// audio was freed
memcpy(audio, dsp_audio, chunk_size);
ESP_LOGW(TAG, "Don't know what to do with dsp_audio1");
*/
ESP_LOGW(TAG, "dspf2DOT1, not implemented yet, using stereo instead");
} break;
case dspfFunkyHonda: { // Process audio L + R LOW PASS FILTER
/*
BIQUAD(sbuffer2, sbuftmp0, len, bq[0].coeffs, bq[0].w);
BIQUAD(sbuftmp0, sbufout2, len, bq[1].coeffs, bq[1].w);
// Process audio L HIGH PASS FILTER
BIQUAD(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
BIQUAD(sbuftmp0, sbufout0, len, bq[3].coeffs, bq[3].w);
// Process audio R HIGH PASS FILTER
BIQUAD(sbuffer1, sbuftmp0, len, bq[4].coeffs, bq[4].w);
BIQUAD(sbuftmp0, sbufout1, len, bq[5].coeffs, bq[5].w);
uint16_t scale = 16384; // 32768
int16_t valint[5];
for (uint16_t i = 0; i < len; i++) {
valint[0] =
(muteCH[0] == 1) ? (int16_t)0 : (int16_t)(sbufout0[i] * scale);
valint[1] =
(muteCH[1] == 1) ? (int16_t)0 : (int16_t)(sbufout1[i] * scale);
valint[2] =
(muteCH[2] == 1) ? (int16_t)0 : (int16_t)(sbufout2[i] * scale);
valint[3] = valint[0] + valint[2];
valint[4] = -valint[2];
valint[5] = -valint[1] - valint[2];
dsp_audio[i * 4 + 0] = (valint[3] & 0xff);
dsp_audio[i * 4 + 1] = ((valint[3] & 0xff00) >> 8);
dsp_audio[i * 4 + 2] = (valint[2] & 0xff);
dsp_audio[i * 4 + 3] = ((valint[2] & 0xff00) >> 8);
dsp_audio1[i * 4 + 0] = (valint[4] & 0xff);
dsp_audio1[i * 4 + 1] = ((valint[4] & 0xff00) >> 8);
dsp_audio1[i * 4 + 2] = (valint[5] & 0xff);
dsp_audio1[i * 4 + 3] = ((valint[5] & 0xff00) >> 8);
}
// TODO: this copy could be avoided if dsp_audio buffers are
// allocated dynamically and pointers are exchanged after
// audio was freed
memcpy(audio, dsp_audio, chunk_size);
ESP_LOGW(TAG, "Don't know what to do with dsp_audio1");
*/
ESP_LOGW(TAG,
"dspfFunkyHonda, not implemented yet, using stereo instead");
} break;
default: { } break; }
free(sbuffer0);
sbuffer0 = NULL;
free(sbufout0);
sbufout0 = NULL;
}
switch (dspFlow) {
case dspfStereo: {
// set volume
if (dynamic_vol != 1.0) {
for (i = 0; i < len; i++) {
audio_tmp[i] =
((uint32_t)(
dynamic_vol *
((float)((int16_t)((audio_tmp[i] & 0xFFFF0000) >> 16))))
<< 16) +
(uint32_t)(dynamic_vol *
((float)((int16_t)(audio_tmp[i] & 0xFFFF))));
}
}
} break;
case dspfBassBoost: { // CH0 low shelf 6dB @ 400Hz
// channel 0
for (i = 0; i < len; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)(audio_tmp[i] & 0xFFFF))) / 32768;
}
BIQUAD(sbuffer0, sbufout0, len, bq[6].coeffs, bq[6].w);
for (i = 0; i < len; i++) {
valint = (int16_t)(sbufout0[i] * 32768);
audio_tmp[i] = (audio_tmp[i] & 0xFFFF0000) + (uint32_t)valint;
}
// channel 1
for (i = 0; i < len; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)((audio_tmp[i] & 0xFFFF0000) >> 16))) /
32768;
}
BIQUAD(sbuffer0, sbufout0, len, bq[7].coeffs, bq[7].w);
for (i = 0; i < len; i++) {
valint = (int16_t)(sbufout0[i] * 32768);
audio_tmp[i] = (audio_tmp[i] & 0xFFFF) + ((uint32_t)valint << 16);
}
} break;
case dspfBiamp: {
// Process audio ch0 LOW PASS FILTER
for (i = 0; i < len; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)(audio_tmp[i] & 0xFFFF))) / 32768;
}
BIQUAD(sbuffer0, sbuftmp0, len, bq[0].coeffs, bq[0].w);
BIQUAD(sbuftmp0, sbufout0, len, bq[1].coeffs, bq[1].w);
for (i = 0; i < len; i++) {
valint = (int16_t)(sbufout0[i] * 32768);
audio_tmp[i] = (audio_tmp[i] & 0xFFFF0000) + (uint32_t)valint;
}
// Process audio ch1 HIGH PASS FILTER
for (i = 0; i < len; i++) {
sbuffer0[i] = dynamic_vol * 0.5 *
((float)((int16_t)((audio_tmp[i] & 0xFFFF0000) >> 16))) /
32768;
}
BIQUAD(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
BIQUAD(sbuftmp0, sbufout0, len, bq[3].coeffs, bq[3].w);
for (i = 0; i < len; i++) {
valint = (int16_t)(sbufout0[i] * 32768);
audio_tmp[i] = (audio_tmp[i] & 0xFFFF) + ((uint32_t)valint << 16);
}
} break;
case dspf2DOT1: { // Process audio L + R LOW PASS FILTER
/*
BIQUAD(sbuffer2, sbuftmp0, len, bq[0].coeffs, bq[0].w);
BIQUAD(sbuftmp0, sbufout2, len, bq[1].coeffs, bq[1].w);
// Process audio L HIGH PASS FILTER
BIQUAD(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
BIQUAD(sbuftmp0, sbufout0, len, bq[3].coeffs, bq[3].w);
// Process audio R HIGH PASS FILTER
BIQUAD(sbuffer1, sbuftmp0, len, bq[4].coeffs, bq[4].w);
BIQUAD(sbuftmp0, sbufout1, len, bq[5].coeffs, bq[5].w);
int16_t valint[5];
for (uint16_t i = 0; i < len; i++) {
valint[0] =
(muteCH[0] == 1) ? (int16_t)0 : (int16_t)(sbufout0[i] *
32768); valint[1] = (muteCH[1] == 1) ? (int16_t)0 :
(int16_t)(sbufout1[i] * 32768); valint[2] = (muteCH[2] == 1) ?
(int16_t)0 : (int16_t)(sbufout2[i] * 32768); dsp_audio[i * 4 + 0] =
(valint[2] & 0xff); dsp_audio[i * 4 + 1] = ((valint[2] & 0xff00) >>
8); dsp_audio[i * 4 + 2] = 0; dsp_audio[i * 4 + 3] = 0;
dsp_audio1[i * 4 + 0] = (valint[0] & 0xff);
dsp_audio1[i * 4 + 1] = ((valint[0] & 0xff00) >> 8);
dsp_audio1[i * 4 + 2] = (valint[1] & 0xff);
dsp_audio1[i * 4 + 3] = ((valint[1] & 0xff00) >> 8);
}
// TODO: this copy could be avoided if dsp_audio buffers are
// allocated dynamically and pointers are exchanged after
// audio was freed
memcpy(audio, dsp_audio, chunk_size);
ESP_LOGW(TAG, "Don't know what to do with dsp_audio1");
*/
ESP_LOGW(TAG, "dspf2DOT1, not implemented yet, using stereo instead");
} break;
case dspfFunkyHonda: { // Process audio L + R LOW PASS FILTER
/*
BIQUAD(sbuffer2, sbuftmp0, len, bq[0].coeffs, bq[0].w);
BIQUAD(sbuftmp0, sbufout2, len, bq[1].coeffs, bq[1].w);
// Process audio L HIGH PASS FILTER
BIQUAD(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
BIQUAD(sbuftmp0, sbufout0, len, bq[3].coeffs, bq[3].w);
// Process audio R HIGH PASS FILTER
BIQUAD(sbuffer1, sbuftmp0, len, bq[4].coeffs, bq[4].w);
BIQUAD(sbuftmp0, sbufout1, len, bq[5].coeffs, bq[5].w);
uint16_t scale = 16384; // 32768
int16_t valint[5];
for (uint16_t i = 0; i < len; i++) {
valint[0] =
(muteCH[0] == 1) ? (int16_t)0 : (int16_t)(sbufout0[i] * scale);
valint[1] =
(muteCH[1] == 1) ? (int16_t)0 : (int16_t)(sbufout1[i] * scale);
valint[2] =
(muteCH[2] == 1) ? (int16_t)0 : (int16_t)(sbufout2[i] * scale);
valint[3] = valint[0] + valint[2];
valint[4] = -valint[2];
valint[5] = -valint[1] - valint[2];
dsp_audio[i * 4 + 0] = (valint[3] & 0xff);
dsp_audio[i * 4 + 1] = ((valint[3] & 0xff00) >> 8);
dsp_audio[i * 4 + 2] = (valint[2] & 0xff);
dsp_audio[i * 4 + 3] = ((valint[2] & 0xff00) >> 8);
dsp_audio1[i * 4 + 0] = (valint[4] & 0xff);
dsp_audio1[i * 4 + 1] = ((valint[4] & 0xff00) >> 8);
dsp_audio1[i * 4 + 2] = (valint[5] & 0xff);
dsp_audio1[i * 4 + 3] = ((valint[5] & 0xff00) >> 8);
}
// TODO: this copy could be avoided if dsp_audio buffers are
// allocated dynamically and pointers are exchanged after
// audio was freed
memcpy(audio, dsp_audio, chunk_size);
ESP_LOGW(TAG, "Don't know what to do with dsp_audio1");
*/
ESP_LOGW(TAG,
"dspfFunkyHonda, not implemented yet, using stereo instead");
} break;
default: { } break; }
return 0;
}
@@ -232,7 +312,6 @@ int dsp_processor(char *audio, size_t chunk_size, dspFlows_t dspFlow) {
// Interface for cross over frequency and level
void dsp_setup_flow(double freq, uint32_t samplerate, uint32_t chunkInFrames) {
float f = freq / samplerate / 2.0;
uint16_t len = chunkInFrames;
if (((currentSamplerate == samplerate) &&
(currentChunkInFrames == chunkInFrames)) ||
@@ -252,18 +331,43 @@ void dsp_setup_flow(double freq, uint32_t samplerate, uint32_t chunkInFrames) {
bq[6] = (ptype_t){LOWSHELF, f, 6, 0.707, NULL, NULL, {0, 0, 0, 0, 0}, {0, 0}};
bq[7] = (ptype_t){LOWSHELF, f, 6, 0.707, NULL, NULL, {0, 0, 0, 0, 0}, {0, 0}};
for (uint8_t n = 0; n <= 7; n++) {
// TODO: make this (frequency and gain) dynamically adjustable
// test simple EQ control of low and high frequencies (bass, treble)
float bass_fc = 300.0 / samplerate;
float bass_gain = 6.0;
float treble_fc = 4000.0 / samplerate;
float treble_gain = 6.0;
// filters for CH 0
bq[8] = (ptype_t){LOWSHELF, bass_fc, bass_gain, 0.707,
NULL, NULL, {0, 0, 0, 0, 0}, {0, 0}};
bq[9] = (ptype_t){HIGHSHELF, treble_fc, treble_gain, 0.707,
NULL, NULL, {0, 0, 0, 0, 0}, {0, 0}};
// filters for CH 1
bq[10] = (ptype_t){LOWSHELF, bass_fc, bass_gain, 0.707,
NULL, NULL, {0, 0, 0, 0, 0}, {0, 0}};
bq[11] = (ptype_t){HIGHSHELF, treble_fc, treble_gain, 0.707,
NULL, NULL, {0, 0, 0, 0, 0}, {0, 0}};
for (int n = 0; n < sizeof(bq) / sizeof(bq[0]); n++) {
switch (bq[n].filtertype) {
case HIGHSHELF:
dsps_biquad_gen_highShelf_f32(bq[n].coeffs, bq[n].freq, bq[n].gain,
bq[n].q);
break;
case LOWSHELF:
dsps_biquad_gen_lowShelf_f32(bq[n].coeffs, bq[n].freq, bq[n].gain,
bq[n].q);
break;
case LPF:
dsps_biquad_gen_lpf_f32(bq[n].coeffs, bq[n].freq, bq[n].q);
break;
case HPF:
dsps_biquad_gen_hpf_f32(bq[n].coeffs, bq[n].freq, bq[n].q);
break;
default:
break;
}
@@ -272,40 +376,6 @@ void dsp_setup_flow(double freq, uint32_t samplerate, uint32_t chunkInFrames) {
// }
// printf("\n");
}
if (sbuffer0 != NULL) {
free(sbuffer0);
sbuffer0 = NULL;
}
if (sbufout0 != NULL) {
free(sbufout0);
sbufout0 = NULL;
}
if (sbuftmp0 != NULL) {
free(sbuftmp0);
sbuftmp0 = NULL;
}
sbuffer0 = (float *)heap_caps_malloc(sizeof(float) * len, MALLOC_CAP_8BIT);
sbufout0 = (float *)heap_caps_malloc(sizeof(float) * len, MALLOC_CAP_8BIT);
sbuftmp0 = (float *)heap_caps_malloc(sizeof(float) * len, MALLOC_CAP_8BIT);
if ((sbuffer0 == NULL) || (sbufout0 == NULL) || (sbuftmp0 == NULL)) {
ESP_LOGE(TAG,
"Failed to allocate initial memory for dsp_processor %p %p %p",
sbuffer0, sbufout0, sbuftmp0);
if (sbuffer0) {
free(sbuffer0);
}
if (sbufout0) {
free(sbufout0);
}
if (sbuftmp0) {
free(sbuftmp0);
}
} else {
ESP_LOGI(TAG, "GOT memory for dsp_processor %p %p", sbuffer0, sbufout0);
}
}
void dsp_set_xoverfreq(uint8_t freqh, uint8_t freql, uint32_t samplerate) {

3
components/dsp_processor/include/dsp_processor.h
View File

@@ -6,7 +6,8 @@ typedef enum dspFlows {
dspfBiamp,
dspf2DOT1,
dspfFunkyHonda,
dspfBassBoost
dspfBassBoost,
dspfEQBassTreble,
} dspFlows_t;
enum filtertypes {

5
main/main.c
View File

@@ -120,7 +120,7 @@ SemaphoreHandle_t timeSyncSemaphoreHandle = NULL;
#if CONFIG_USE_DSP_PROCESSOR
#if CONFIG_SNAPCLIENT_DSP_FLOW_STEREO
dspFlows_t dspFlow = dspfStereo; // dspfBiamp; // dspfStereo; // dspfBassBoost;
dspFlows_t dspFlow = dspfStereo;
#endif
#if CONFIG_SNAPCLIENT_DSP_FLOW_BASSBOOST
dspFlows_t dspFlow = dspfBassBoost;
@@ -128,6 +128,9 @@ dspFlows_t dspFlow = dspfBassBoost;
#if CONFIG_SNAPCLIENT_DSP_FLOW_BIAMP
dspFlows_t dspFlow = dspfBiamp;
#endif
#if CONFIG_SNAPCLIENT_DSP_FLOW_BASS_TREBLE_EQ
dspFlows_t dspFlow = dspfEQBassTreble;
#endif
#endif
typedef struct flacData_s {

10
sdkconfig.old
View File

@@ -143,7 +143,13 @@ CONFIG_ESP_LYRAT_V4_3_BOARD=y
#
# ESP32 DSP processor config
#
# CONFIG_USE_DSP_PROCESSOR is not set
CONFIG_USE_DSP_PROCESSOR=y
# CONFIG_SNAPCLIENT_DSP_FLOW_STEREO is not set
# CONFIG_SNAPCLIENT_DSP_FLOW_BASSBOOST is not set
# CONFIG_SNAPCLIENT_DSP_FLOW_BIAMP is not set
CONFIG_SNAPCLIENT_DSP_FLOW_BASS_TREBLE_EQ=y
CONFIG_USE_BIQUAD_ASM=y
# CONFIG_SNAPCLIENT_USE_SOFT_VOL is not set
# end of ESP32 DSP processor config
#
@@ -544,7 +550,7 @@ CONFIG_WIFI_LOG_DEFAULT_LEVEL_INFO=y
# CONFIG_WIFI_LOG_DEFAULT_LEVEL_DEBUG is not set
# CONFIG_WIFI_LOG_DEFAULT_LEVEL_VERBOSE is not set
# CONFIG_ESP32_WIFI_IRAM_OPT is not set
CONFIG_ESP32_WIFI_RX_IRAM_OPT=y
# CONFIG_ESP32_WIFI_RX_IRAM_OPT is not set
CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE=y
# CONFIG_ESP_WIFI_SLP_IRAM_OPT is not set
# CONFIG_ESP_WIFI_STA_DISCONNECTED_PM_ENABLE is not set