MirrorMirror
/
headphones
mirror of https://github.com/ploopyco/headphones.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: MirrorMirror:master
Branches Tags
MirrorMirror:master
MirrorMirror:oratoryEQ
MirrorMirror:ploopyco/george-norton-headphones-toolbox
MirrorMirror:PM16
MirrorMirror:PM15
MirrorMirror:PM14
MirrorMirror:PM13
MirrorMirror:PM12
MirrorMirror:PM11
MirrorMirror:PM10
..
compare: MirrorMirror:PM13
Branches Tags
MirrorMirror:master
MirrorMirror:oratoryEQ
MirrorMirror:ploopyco/george-norton-headphones-toolbox
MirrorMirror:PM16
MirrorMirror:PM15
MirrorMirror:PM14
MirrorMirror:PM13
MirrorMirror:PM12
MirrorMirror:PM11
MirrorMirror:PM10

No commits in common. "master" and "PM13" have entirely different histories.
master ... PM13

17 changed files with 202 additions and 265 deletions
Show Stats Expand all files Collapse all files

4
firmware/code/CMakeLists.txt
View File

@ -14,6 +14,7 @@ add_executable(ploopy_headphones
run.c
ringbuf.c
i2s.c
fix16.c
bqf.c
configuration_manager.c
)
@ -62,9 +63,6 @@ target_compile_definitions(ploopy_headphones PRIVATE
GIT_HASH="${GIT_HASH}"
PICO_XOSC_STARTUP_DELAY_MULTIPLIER=64
# Performance, avoid calls to ____wrap___aeabi_lmul_veneer when doing 64bit multiplies
PICO_INT64_OPS_IN_RAM=1
)
pico_enable_stdio_usb(ploopy_headphones 0)

15
firmware/code/bqf.c
View File

@ -467,6 +467,21 @@ void bqf_highshelf_config(double fs, double f0, double dBgain, double Q,
coefficients->a2 = fix3_28_from_dbl(a2);
}
fix3_28_t bqf_transform(fix3_28_t x, bqf_coeff_t *coefficients, bqf_mem_t *memory) {
fix3_28_t y = fix16_mul(coefficients->b0, x) -
fix16_mul(coefficients->a1, memory->y_1) +
fix16_mul(coefficients->b1, memory->x_1) -
fix16_mul(coefficients->a2, memory->y_2) +
fix16_mul(coefficients->b2, memory->x_2);
memory->x_2 = memory->x_1;
memory->x_1 = x;
memory->y_2 = memory->y_1;
memory->y_1 = y;
return y;
}
void bqf_memreset(bqf_mem_t *memory) {
memory->x_1 = fix16_zero;
memory->x_2 = fix16_zero;

9
firmware/code/bqf.h
View File

@ -41,9 +41,9 @@ typedef struct _bqf_mem_t {
fix3_28_t y_2;
} bqf_mem_t;
// More filters should be possible, but the config structure
// might grow beyond the current 512 byte size.
#define MAX_FILTER_STAGES 20
// In reality we do not have enough CPU resource to run 8 filtering
// stages without some optimisation.
#define MAX_FILTER_STAGES 8
extern int filter_stages;
extern bqf_coeff_t bqf_filters_left[MAX_FILTER_STAGES];
@ -65,8 +65,7 @@ void bqf_peaking_config(double, double, double, double, bqf_coeff_t *);
void bqf_lowshelf_config(double, double, double, double, bqf_coeff_t *);
void bqf_highshelf_config(double, double, double, double, bqf_coeff_t *);
static inline fix3_28_t bqf_transform(fix3_28_t, bqf_coeff_t *, bqf_mem_t *);
fix3_28_t bqf_transform(fix3_28_t, bqf_coeff_t *, bqf_mem_t *);
void bqf_memreset(bqf_mem_t *);
#include "bqf.inl"
#endif

36
firmware/code/bqf.inl
View File

@ -1,36 +0,0 @@
/**
* Copyright 2022 Colin Lam, Ploopy Corporation
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* SPECIAL THANKS TO:
* Robert Bristow-Johnson, a.k.a. RBJ
* for his exceptional work on biquad formulae as applied to digital
* audio filtering, summarised in his pamphlet, "Audio EQ Cookbook".
*/
static inline fix3_28_t bqf_transform(fix3_28_t x, bqf_coeff_t *coefficients, bqf_mem_t *memory) {
fix3_28_t y = fix16_mul(coefficients->b0, x) -
fix16_mul(coefficients->a1, memory->y_1) +
fix16_mul(coefficients->b1, memory->x_1) -
fix16_mul(coefficients->a2, memory->y_2) +
fix16_mul(coefficients->b2, memory->x_2);
memory->x_2 = memory->x_1;
memory->x_1 = x;
memory->y_2 = memory->y_1;
memory->y_1 = y;
return y;
}

83
firmware/code/configuration_manager.c
View File

@ -52,29 +52,16 @@ static const default_configuration default_config = {
.set_configuration = { SET_CONFIGURATION, sizeof(default_config) },
.filters = {
.filter = { FILTER_CONFIGURATION, sizeof(default_config.filters) },
.f1 = { PEAKING, {0}, 38.5, -21.0, 1.4 },
.f2 = { PEAKING, {0}, 60, -6.7, 0.5 },
.f3 = { LOWSHELF, {0}, 105, 2.0, 0.71 },
.f4 = { PEAKING, {0}, 280, -3.5, 1.1 },
.f5 = { PEAKING, {0}, 350, -1.6, 6.0 },
.f6 = { PEAKING, {0}, 425, 7.8, 1.3 },
.f7 = { PEAKING, {0}, 500, -2.0, 7.0 },
.f8 = { PEAKING, {0}, 690, -5.5, 3.0 },
.f9 = { PEAKING, {0}, 1000, -2.2, 5.0 },
.f10 = { PEAKING, {0}, 1530, -4.0, 2.5 },
.f11 = { PEAKING, {0}, 2250, 6.0, 2.0 },
.f12 = { PEAKING, {0}, 3430, -12.2, 2.0 },
.f13 = { PEAKING, {0}, 4800, 4.0, 2.0 },
.f14 = { PEAKING, {0}, 6200, -15.0, 3.0 },
.f15 = { HIGHSHELF, {0}, 12000, -3.0, 0.71 }
.f1 = { PEAKING, {0}, 40, -20, 1.4 },
.f2 = { LOWSHELF, {0}, 105, 2.5, 0.7 },
.f3 = { PEAKING, {0}, 450, 7, 1.8 },
.f4 = { PEAKING, {0}, 2100, 8, 3.0 },
.f5 = { PEAKING, {0}, 3500, -7.5, 2.9 },
.f6 = { PEAKING, {0}, 5200, 5.5, 3.0 },
.f7 = { PEAKING, {0}, 6400, -19, 4.0 },
.f8 = { PEAKING, {0}, 9000, 3.0, 2.0 }
},
.preprocessing = {
.header = { PREPROCESSING_CONFIGURATION, sizeof(default_config.preprocessing) },
-0.376265f, // pre-EQ gain of -4.1dB
0.4125f, // post-EQ gain, set to ~3dB (1.4x, less the 1 that is added when config is applied)
true,
{0}
}
.preprocessing = { .header = { PREPROCESSING_CONFIGURATION, sizeof(default_config.preprocessing) }, -0.16f, true, {0} }
};
// Grab the last 4k page of flash for our configuration strutures.
@ -87,7 +74,7 @@ const uint8_t *user_configuration = (const uint8_t *) (XIP_BASE + USER_CONFIGURA
* should handle merging configurations where, for example, only a new
* filter_configuration_tlv was received.
*/
#define CFG_BUFFER_SIZE 512
#define CFG_BUFFER_SIZE 256
static uint8_t working_configuration[2][CFG_BUFFER_SIZE];
static uint8_t inactive_working_configuration = 0;
static uint8_t result_buffer[CFG_BUFFER_SIZE] = { U16_TO_U8S_LE(NOK), U16_TO_U8S_LE(0) };
@ -96,13 +83,6 @@ static bool reload_config = false;
static uint16_t write_offset = 0;
static uint16_t read_offset = 0;
typedef enum {
NormalOperation,
SaveRequested,
Saving
} State;
static State saveState = NormalOperation;
bool validate_filter_configuration(filter_configuration_tlv *filters)
{
if (filters->header.type != FILTER_CONFIGURATION) {
@ -149,7 +129,7 @@ bool validate_filter_configuration(filter_configuration_tlv *filters)
printf("Error! Not enough data left for filter6 (%d)\n", remaining);
return false;
}
if (args->a0 == 0.0f) {
if (args->a0 == 0.0) {
printf("Error! The a0 co-efficient of an IIR filter must not be 0.\n");
return false;
}
@ -202,7 +182,7 @@ void apply_filter_configuration(filter_configuration_tlv *filters) {
uint32_t checksum = 0;
for (int i = 0; i < sizeof(filter6) / 4; i++) checksum ^= ((uint32_t*) args)[i];
if (checksum != bqf_filter_checksum[filter_stages]) {
bqf_filters_left[filter_stages].a0 = fix16_one;
bqf_filters_left[filter_stages].a0 = fix3_28_from_dbl(1.0);
bqf_filters_left[filter_stages].a1 = fix3_28_from_dbl(args->a1/args->a0);
bqf_filters_left[filter_stages].a2 = fix3_28_from_dbl(args->a2/args->a0);
bqf_filters_left[filter_stages].b0 = fix3_28_from_dbl(args->b0/args->a0);
@ -328,8 +308,7 @@ bool apply_configuration(tlv_header *config) {
#ifndef TEST_TARGET
case PREPROCESSING_CONFIGURATION: {
preprocessing_configuration_tlv* preprocessing_config = (preprocessing_configuration_tlv*) tlv;
preprocessing.preamp = fix3_28_from_flt(1.0f + preprocessing_config->preamp);
preprocessing.postEQGain = fix3_28_from_flt(1.0f + preprocessing_config->postEQGain);
preprocessing.preamp = fix3_28_from_dbl(1.0 + preprocessing_config->preamp);
preprocessing.reverse_stereo = preprocessing_config->reverse_stereo;
break;
}
@ -364,20 +343,16 @@ void load_config() {
}
#ifndef TEST_TARGET
bool __no_inline_not_in_flash_func(save_config)() {
bool __no_inline_not_in_flash_func(save_configuration)() {
const uint8_t active_configuration = inactive_working_configuration ? 0 : 1;
tlv_header* config = (tlv_header*) working_configuration[active_configuration];
switch (saveState) {
case SaveRequested:
if (validate_configuration(config)) {
/* Turn the DAC off so we don't make a huge noise when disrupting
real time audio operation. */
power_down_dac();
const size_t config_length = config->length - ((size_t)config->value - (size_t)config);
// Write data to flash
uint8_t flash_buffer[CFG_BUFFER_SIZE];
uint8_t flash_buffer[FLASH_PAGE_SIZE];
flash_header_tlv* flash_header = (flash_header_tlv*) flash_buffer;
flash_header->header.type = FLASH_HEADER;
flash_header->header.length = sizeof(flash_header_tlv) + config_length;
@ -387,26 +362,13 @@ bool __no_inline_not_in_flash_func(save_config)() {
uint32_t ints = save_and_disable_interrupts();
flash_range_erase(USER_CONFIGURATION_OFFSET, FLASH_SECTOR_SIZE);
flash_range_program(USER_CONFIGURATION_OFFSET, flash_buffer, CFG_BUFFER_SIZE);
flash_range_program(USER_CONFIGURATION_OFFSET, flash_buffer, FLASH_PAGE_SIZE);
restore_interrupts(ints);
saveState = Saving;
// Return true, so the caller skips processing audio
power_up_dac();
return true;
}
// Validation failed, give up.
saveState = NormalOperation;
break;
case Saving:
/* Turn the DAC off so we don't make a huge noise when disrupting
real time audio operation. */
power_up_dac();
saveState = NormalOperation;
return false;
default:
break;
}
return false;
}
@ -432,14 +394,7 @@ bool process_cmd(tlv_header* cmd) {
}
break;
case SAVE_CONFIGURATION: {
if (cmd->length == 4) {
saveState = SaveRequested;
if (audio_state.interface == 0) {
// The OS will configure the alternate "zero" interface when the device is not in use
// in this sate we can write to flash now. Otherwise, defer the save until we get the next
// usb packet.
save_config();
}
if (cmd->length == 4 && save_configuration()) {
result->type = OK;
result->length = 4;
return true;

1
firmware/code/configuration_manager.h
View File

@ -52,7 +52,6 @@ void config_in_packet(struct usb_endpoint *ep);
void config_out_packet(struct usb_endpoint *ep);
void configuration_ep_on_cancel(struct usb_endpoint *ep);
extern void load_config();
extern bool save_config();
extern void apply_config_changes();
#endif // CONFIGURATION_MANAGER_H

29
firmware/code/configuration_types.h
View File

@ -17,8 +17,8 @@
#include <stdint.h>
#define FLASH_MAGIC 0x2E8AFEDD
#define CONFIG_VERSION 4
#define MINIMUM_CONFIG_VERSION 4
#define CONFIG_VERSION 2
#define MINIMUM_CONFIG_VERSION 1
enum structure_types {
// Commands/Responses, these are container TLVs. The Value will be a set of TLV structures.
@ -53,20 +53,18 @@ typedef struct __attribute__((__packed__)) _tlv_header {
typedef struct __attribute__((__packed__)) _filter2 {
uint8_t type;
uint8_t reserved[3];
float f0;
float Q;
double f0;
double Q;
} filter2;
typedef struct __attribute__((__packed__)) _filter3 {
uint8_t type;
uint8_t reserved[3];
float f0;
float db_gain;
float Q;
double f0;
double db_gain;
double Q;
} filter3;
// WARNING: We wont be able to support more than 8 of these filters
// due to the config structure size.
typedef struct __attribute__((__packed__)) _filter6 {
uint8_t type;
uint8_t reserved[3];
@ -98,13 +96,9 @@ typedef struct __attribute__((__packed__)) _flash_header_tlv {
const uint8_t tlvs[0];
} flash_header_tlv;
/// @brief Holds values relating to processing surrounding the EQ calculation.
typedef struct __attribute__((__packed__)) _preprocessing_configuration_tlv {
tlv_header header;
/// @brief Gain applied to input signal before EQ chain. Use to avoid clipping due to overflow in the biquad filters of the EQ.
float preamp;
/// @brief Gain applied to the output of the EQ chain. Used to set output volume.
float postEQGain;
double preamp;
uint8_t reverse_stereo;
uint8_t reserved[3];
} preprocessing_configuration_tlv;
@ -143,13 +137,6 @@ typedef struct __attribute__((__packed__)) _default_configuration {
filter3 f6;
filter3 f7;
filter3 f8;
filter3 f9;
filter3 f10;
filter3 f11;
filter3 f12;
filter3 f13;
filter3 f14;
filter3 f15;
} filters;
preprocessing_configuration_tlv preprocessing;
} default_configuration;

108
firmware/code/fix16.inl → firmware/code/fix16.c
View File

@ -25,25 +25,61 @@
#include <limits.h>
#include "fix16.h"
#ifdef USE_DOUBLE
fix16_t fix16_from_s16sample(int16_t a) {
return a;
}
int16_t fix16_to_s16sample(fix16_t a) {
// Handle rounding up front, adding one can cause an overflow/underflow
if (a < 0) {
a -= 0.5;
} else {
a += 0.5;
}
// Saturate the value if an overflow has occurred
if (a < SHRT_MIN) {
return SHRT_MIN;
}
if (a < SHRT_MAX) {
return SHRT_MAX;
}
return a;
}
fix16_t fix16_from_dbl(double a) {
return a;
}
double fix16_to_dbl(fix16_t a) {
return a;
}
fix16_t fix16_mul(fix16_t inArg0, fix16_t inArg1) {
return inArg0 * inArg1;
}
#else
/// @brief Produces a fixed point number from a 16-bit signed integer, normalized to ]-1,1[.
/// @param a Signed 16-bit integer.
/// @return A fixed point number in Q3.28 format, with input normalized to ]-1,1[.
static inline fix3_28_t norm_fix3_28_from_s16sample(int16_t a) {
fix3_28_t norm_fix3_28_from_s16sample(int16_t a) {
/* So, we're using a Q3.28 fixed point system here, and we want the incoming
audio signal to be represented as a number between -1 and 1. To do this,
we need the 16-bit value to map to the 28-bit right-of-decimal field in
our fixed point number. 28-16 = 12 + the sign bit = 13, so we shift the
incoming value by that much to covert it to the desired Q3.28 format and
do the normalization all in one go.
our fixed point number. 28-16 = 12, so we shift the incoming value by
that much to covert it to the desired Q3.28 format and do the normalization
all in one go.
*/
return (fix3_28_t)a << 13;
return (fix3_28_t)a << 12;
}
/// @brief Convert fixed point samples into signed integer. Used to convert
/// calculated sample to one that the DAC can understand.
/// @param a
/// @return Signed 16-bit integer.
static inline int32_t norm_fix3_28_to_s16sample(fix3_28_t a) {
int16_t norm_fix3_28_to_s16sample(fix3_28_t a) {
// Handle rounding up front, adding one can cause an overflow/underflow
// It's not clear exactly how this works, so we'll disable it for now.
@ -56,29 +92,26 @@ static inline int32_t norm_fix3_28_to_s16sample(fix3_28_t a) {
*/
// Saturate the value if an overflow has occurred
uint32_t upper = (a >> 29);
uint32_t upper = (a >> 30);
if (a < 0) {
if (~upper) {
return 0xff800000;
if (~upper)
{
return SHRT_MIN;
}
} else {
if (upper) {
return 0x00efffff;
if (upper)
{
return SHRT_MAX;
}
}
/* When we converted the USB audio sample to a fixed point number, we applied
a normalization, or a gain of 1/65536. To convert it back, we can undo that
by shifting it but we output 24bts, so the shift is reduced. */
return (a >> 6);
by shifting it back by the same amount we shifted it in the first place. */
return (a >> 12);
}
static inline fix3_28_t fix3_28_from_flt(float a) {
float temp = a * fix16_one;
temp += ((temp >= 0) ? 0.5f : -0.5f);
return (fix3_28_t)temp;
}
static inline fix3_28_t fix3_28_from_dbl(double a) {
fix3_28_t fix3_28_from_dbl(double a) {
double temp = a * fix16_one;
temp += (double)((temp >= 0) ? 0.5f : -0.5f);
return (fix3_28_t)temp;
@ -88,22 +121,27 @@ static inline fix3_28_t fix3_28_from_dbl(double a) {
/// @param inArg0 Q3.28 format fixed point number.
/// @param inArg1 Q3.28 format fixed point number.
/// @return A Q3.28 fixed point number that represents the truncated result of inArg0 x inArg1.
static inline fix3_28_t fix16_mul(fix3_28_t inArg0, fix3_28_t inArg1) {
int32_t A = (inArg0 >> 14), C = (inArg1 >> 14);
uint32_t B = (inArg0 & 0x3FFF), D = (inArg1 & 0x3FFF);
int32_t AC = A*C;
int32_t AD_CB = A*D + C*B;
int32_t product_hi = AC + (AD_CB >> 14);
fix3_28_t fix16_mul(fix3_28_t inArg0, fix3_28_t inArg1) {
const int64_t product = (int64_t)inArg0 * inArg1;
#if HANDLE_CARRY
// Handle carry from lower bits to upper part of result.
uint32_t BD = B*D;
uint32_t ad_cb_temp = AD_CB << 14;
uint32_t product_lo = BD + ad_cb_temp;
/* Since we're expecting 2 Q3.28 numbers, the multiplication result should be a Q7.56 number.
To bring this number back to the right order of magnitude, we need to shift
it to the right by 28. */
fix3_28_t result = product >> 28;
if (product_lo < BD)
product_hi++;
#endif
return product_hi;
// Handle rounding where we are choppping off low order bits
// Disabled for now, too much load. We get crackling when adjusting
// the volume.
#if 0
if (product & 0x4000) {
if (result >= 0) {
result++;
}
else {
result--;
}
}
#endif
return result;
}
#endif

29
firmware/code/fix16.h
View File

@ -25,6 +25,13 @@
#include <stdbool.h>
#include <inttypes.h>
// During development, it can be useful to run with real double values for reference.
//#define USE_DOUBLE
#ifdef USE_DOUBLE
typedef double fix16_t;
static const fix16_t fix16_zero = 0;
static const fix16_t fix16_one = 1;
#else
/// @brief Fixed point math type, in format Q3.28. One sign bit, 3 bits for left-of-decimal
///and 28 for right-of-decimal. This arrangment works because we normalize the incoming USB
@ -39,15 +46,15 @@ static const fix3_28_t fix16_one = 0x10000000;
/// @brief Represents zero in fixed point world.
static const fix3_28_t fix16_zero = 0x00000000;
static inline fix3_28_t norm_fix3_28_from_s16sample(int16_t);
static inline int32_t norm_fix3_28_to_s16sample(fix3_28_t);
static inline fix3_28_t fix3_28_from_flt(float);
static inline fix3_28_t fix3_28_from_dbl(double);
static inline fix3_28_t fix16_mul(fix3_28_t, fix3_28_t);
#include "fix16.inl"
#endif
fix3_28_t norm_fix3_28_from_s16sample(int16_t);
int16_t norm_fix3_28_to_s16sample(fix3_28_t);
fix3_28_t fix3_28_from_dbl(double);
fix3_28_t fix16_mul(fix3_28_t, fix3_28_t);
#endif

76
firmware/code/run.c
View File

@ -52,12 +52,10 @@ static uint8_t *userbuf;
audio_state_config audio_state = {
.freq = 48000,
.de_emphasis_frequency = 0x1, // 48khz
.interface = 0
};
preprocessing_config preprocessing = {
.preamp = fix16_one,
.postEQGain = fix16_one,
.reverse_stereo = false
};
@ -120,24 +118,12 @@ static void update_volume()
// PCM data into I2S data that gets shipped out to the PCM3060. It really
// belongs with the other USB-related code due to its utter indecipherability,
// but it's placed here to emphasize its importance.
static void __no_inline_not_in_flash_func(_as_audio_packet)(struct usb_endpoint *ep) {
static void _as_audio_packet(struct usb_endpoint *ep) {
struct usb_buffer *usb_buffer = usb_current_out_packet_buffer(ep);
int16_t *in = (int16_t *) usb_buffer->data;
int32_t *out = (int32_t *) userbuf;
int samples = usb_buffer->data_len / 2;
// Make sure core 1 is ready for us.
multicore_fifo_pop_blocking();
if (save_config()) {
// Skip processing while we are writing to flash
multicore_fifo_push_blocking(CORE0_ABORTED);
// keep on truckin'
usb_grow_transfer(ep->current_transfer, 1);
usb_packet_done(ep);
return;
}
if (preprocessing.reverse_stereo) {
for (int i = 0; i < samples; i+=2) {
out[i] = in[i+1];
@ -149,44 +135,36 @@ static void __no_inline_not_in_flash_func(_as_audio_packet)(struct usb_endpoint
out[i] = in[i];
}
// Make sure core 1 is ready for us.
multicore_fifo_pop_blocking();
multicore_fifo_push_blocking(CORE0_READY);
multicore_fifo_push_blocking(samples);
for (int j = 0; j < filter_stages; j++) {
// Left channel filter
for (int i = 0; i < samples; i += 2) {
fix3_28_t x_f16 = fix16_mul(norm_fix3_28_from_s16sample((int16_t) out[i]), preprocessing.preamp);
for (int j = 0; j < filter_stages; j++) {
x_f16 = bqf_transform(x_f16, &bqf_filters_left[j],
&bqf_filters_mem_left[j]);
}
/* Apply post-EQ gain. */
x_f16 = fix16_mul( x_f16, preprocessing.postEQGain);
out[i] = (int32_t) norm_fix3_28_to_s16sample(x_f16);
}
}
// Block until core 1 has finished transforming the data
uint32_t ready = multicore_fifo_pop_blocking();
multicore_fifo_push_blocking(CORE0_READY);
// Update the volume if required. We do this from core1 as
// core0 is more heavily loaded, doing this from core0 can
// lead to audio crackling.
update_volume();
// Update filters if required
apply_config_changes();
// keep on truckin'
usb_grow_transfer(ep->current_transfer, 1);
usb_packet_done(ep);
}
void __no_inline_not_in_flash_func(core1_entry)() {
void core1_entry() {
uint8_t *userbuf = (uint8_t *) multicore_fifo_pop_blocking();
int32_t *out = (int32_t *) userbuf;
int limit_counter = 100;
// Signal that the thread has started
multicore_fifo_push_blocking(CORE1_READY);
@ -197,23 +175,33 @@ void __no_inline_not_in_flash_func(core1_entry)() {
// Block until the userbuf is filled with data
uint32_t ready = multicore_fifo_pop_blocking();
if (ready == CORE0_ABORTED) continue;
while (ready != CORE0_READY)
ready = multicore_fifo_pop_blocking();
const uint32_t samples = multicore_fifo_pop_blocking();
/* Right channel EQ. */
for (int i = 1; i < samples; i += 2) {
/* Apply EQ pre-filter gain to avoid clipping. */
fix3_28_t x_f16 = fix16_mul(norm_fix3_28_from_s16sample((int16_t) out[i]), preprocessing.preamp);
/* Apply the biquad filters one by one. */
for (int j = 0; j < filter_stages; j++) {
for (int i = 1; i < samples; i += 2) {
fix3_28_t x_f16 = fix16_mul(norm_fix3_28_from_s16sample((int16_t) out[i]), preprocessing.preamp);
x_f16 = bqf_transform(x_f16, &bqf_filters_right[j],
&bqf_filters_mem_right[j]);
}
/* Apply post-EQ gain. */
x_f16 = fix16_mul( x_f16, preprocessing.postEQGain);
out[i] = (int32_t) norm_fix3_28_to_s16sample(x_f16);
out[i] = (int16_t) norm_fix3_28_to_s16sample(x_f16);
}
}
// Update the volume and filter configs if required. We do this from
// core1 as core0 is more heavily loaded, doing this from core0 can
// lead to audio crackling.
// Use of a counter reduces the amount of crackling when changing
// volume.
if (limit_counter != 0)
limit_counter--;
else {
limit_counter = 100;
update_volume();
apply_config_changes();
}
// Signal to core 0 that the data has all been transformed
@ -265,7 +253,7 @@ void setup() {
// The PCM3060 supports standard mode (100kbps) or fast mode (400kbps)
// we run in fast mode so we dont block the core for too long while
// updating the volume.
i2c_init(i2c0, 400000);
i2c_init(i2c0, 100000);
gpio_set_function(PCM3060_SDA_PIN, GPIO_FUNC_I2C);
gpio_set_function(PCM3060_SCL_PIN, GPIO_FUNC_I2C);
gpio_pull_up(PCM3060_SDA_PIN);
@ -291,9 +279,9 @@ void setup() {
// Same here, pal. Hands off.
sleep_ms(100);
// Set data format to 24 bit right justified, MSB first
// Set data format to 16 bit right justified, MSB first
buf[0] = 67; // register addr
buf[1] = 0x02; // data
buf[1] = 0x03; // data
i2c_write_blocking(i2c0, PCM_I2C_ADDR, buf, 2, false);
i2s_write_obj.sck_pin = PCM3060_DAC_SCK_PIN;
@ -309,7 +297,6 @@ void setup() {
* IF YOU DO, YOU COULD BLOW UP YOUR HARDWARE! *
* YOU WERE WARNED!!!!!!!!!!!!!!!! *
****************************************************************************/
// TODO: roundf will be much faster than round, but it might mess with timings
void configure_neg_switch_pwm() {
gpio_set_function(NEG_SWITCH_PWM_PIN, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(NEG_SWITCH_PWM_PIN);
@ -770,7 +757,6 @@ static const struct usb_transfer_type _audio_cmd_transfer_type = {
static bool as_set_alternate(struct usb_interface *interface, uint alt) {
assert(interface == &as_op_interface);
audio_state.interface = alt;
switch (alt) {
case 0: power_down_dac(); return true;
case 1: power_up_dac(); return true;

4
firmware/code/run.h
View File

@ -76,7 +76,6 @@ typedef struct _audio_state_config {
int16_t _target_pcm3060_registers;
};
int16_t pcm3060_registers;
int8_t interface;
} audio_state_config;
extern audio_state_config audio_state;
@ -111,8 +110,6 @@ typedef struct _audio_device_config {
typedef struct _preprocessing_config {
fix3_28_t preamp;
/// @brief Apply this gain after applying EQ, to set output volume without causing overflow in the EQ calculations.
fix3_28_t postEQGain;
int reverse_stereo;
} preprocessing_config;
@ -150,7 +147,6 @@ static char *descriptor_strings[] = {
#define SAMPLING_FREQ (CODEC_FREQ / 192)
#define CORE0_READY 19813219
#define CORE0_ABORTED 91231891
#define CORE1_READY 72965426
/*****************************************************************************

1
firmware/tools/CMakeLists.txt
View File

@ -6,6 +6,7 @@ set(CMAKE_CXX_STANDARD 17)
add_executable(filter_test
filter_test.c
../code/fix16.c
../code/bqf.c
../code/configuration_manager.c
)

2
firmware/tools/README.md
View File

@ -17,7 +17,7 @@ Run `filter_test` to process the PCM samples. The `filter_test` program takes tw
You can listen to the PCM files using ffplay (which is usually included with ffmpeg):
```
ffplay -f s24le -ar 48000 -ac 2 output.pcm
ffplay -f s16le -ar 48000 -ac 2 output.pcm
```
If there are no obvious problems, go ahead and flash your firmware.

26
firmware/tools/filter_test.c
View File

@ -32,7 +32,7 @@ int main(int argc, char* argv[])
// we dont need to store the whole input and output files in memory.
int samples = input_size / 2;
int16_t *in = (int16_t *) calloc(samples, sizeof(int16_t));
int32_t *out = (int32_t *) calloc(samples, sizeof(int32_t));
int16_t *out = (int16_t *) calloc(samples, sizeof(int16_t));
fread(in, samples, sizeof(int16_t), input);
fclose(input);
@ -54,39 +54,31 @@ int main(int argc, char* argv[])
out[i] = in[i];
}
const fix3_28_t preamp = fix3_28_from_flt(0.92f);
for (int j = 0; j < filter_stages; j++)
{
for (int i = 0; i < samples; i ++)
{
// Left channel filter
fix3_28_t x_f16 = fix16_mul(norm_fix3_28_from_s16sample((int16_t) out[i]), preamp);
fix16_t x_f16 = fix16_from_s16sample((int16_t) out[i]);
for (int j = 0; j < filter_stages; j++)
{
x_f16 = bqf_transform(x_f16, &bqf_filters_left[j],
&bqf_filters_mem_left[j]);
}
out[i] = (int32_t) norm_fix3_28_to_s16sample(x_f16);
out[i] = (int32_t) fix16_to_s16sample(x_f16);
// Right channel filter
i++;
x_f16 = fix16_mul(norm_fix3_28_from_s16sample((int16_t) out[i]), preamp);
x_f16 = fix16_from_s16sample((int16_t) out[i]);
for (int j = 0; j < filter_stages; j++)
{
x_f16 = bqf_transform(x_f16, &bqf_filters_right[j],
&bqf_filters_mem_right[j]);
}
out[i] = (int32_t) norm_fix3_28_to_s16sample(x_f16);
//printf("%08x\n", out[i]);
out[i] = (int16_t) fix16_to_s16sample(x_f16);
}
}
// Write out the processed audio.
for (int i=0; i<samples; i++) {
fwrite(&out[i], 3, sizeof(int8_t), output);
}
fwrite(out, samples, sizeof(int16_t), output);
fclose(output);
free(in);