firmware/code/CMakeLists.txt

@@ -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)

firmware/code/bqf.c

@@ -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;

firmware/code/bqf.h

@@ -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
+// In reality we do not have enough CPU resource to run 8 filtering
-// might grow beyond the current 512 byte size.
+// stages without some optimisation.
-#define MAX_FILTER_STAGES 20
+#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

firmware/code/bqf.inl

@@ -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;
-}

firmware/code/configuration_manager.c

@@ -52,29 +52,13 @@ 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  },
+        .f1 = { PEAKING,    {0},    38,   -19,  0.9 },
-        .f2  = { PEAKING,    {0},    60,    -6.7,  0.5  },
+        .f2 = { LOWSHELF,   {0},    2900,   2,  0.7 },
-        .f3  = { LOWSHELF,   {0},    105,    2.0,  0.71 },
+        .f3 = { PEAKING,    {0},    430,    3,  3.5 },
-        .f4  = { PEAKING,    {0},    280,   -3.5,  1.1  },
+        .f4 = { HIGHSHELF,  {0},    8400,   2,  0.7 },
-        .f5  = { PEAKING,    {0},    350,   -1.6,  6.0  },
+        .f5 = { PEAKING,    {0},    4800,   3,    5 }
-        .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 }
     },
-    .preprocessing = { 
+    .preprocessing = { .header = { PREPROCESSING_CONFIGURATION, sizeof(default_config.preprocessing) }, -0.2f, false, {0} }
-        .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} 
-    }
 };
 
 // Grab the last 4k page of flash for our configuration strutures.
@@ -87,7 +71,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 +80,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 +126,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 +179,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 +305,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.preamp = fix3_28_from_dbl(1.0 + preprocessing_config->preamp);
-                preprocessing.postEQGain = fix3_28_from_flt(1.0f + preprocessing_config->postEQGain);
                 preprocessing.reverse_stereo = preprocessing_config->reverse_stereo;
                 break;
             }
@@ -364,20 +340,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 +359,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 +391,7 @@ bool process_cmd(tlv_header* cmd) {
             }
             break;
         case SAVE_CONFIGURATION: {
-            if (cmd->length == 4) {
+            if (cmd->length == 4 && save_configuration()) {
-                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();
-                }
                 result->type = OK;
                 result->length = 4;
                 return true;

firmware/code/configuration_manager.h

@@ -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

firmware/code/configuration_types.h

@@ -17,8 +17,8 @@
 #include <stdint.h>
 
 #define FLASH_MAGIC 0x2E8AFEDD
-#define CONFIG_VERSION 4
+#define CONFIG_VERSION 2
-#define MINIMUM_CONFIG_VERSION 4
+#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;
+    double f0;
-    float Q;
+    double Q;
 } filter2;
 
 typedef struct __attribute__((__packed__)) _filter3 {
     uint8_t type;
     uint8_t reserved[3];
-    float f0;
+    double f0;
-    float db_gain;
+    double db_gain;
-    float Q;
+    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.
+    double preamp;
-    float preamp;
-    /// @brief Gain applied to the output of the EQ chain. Used to set output volume.
-    float postEQGain;
     uint8_t reverse_stereo;
     uint8_t reserved[3];
 } preprocessing_configuration_tlv;
@@ -140,16 +134,6 @@ typedef struct __attribute__((__packed__)) _default_configuration {
         filter3 f3;
         filter3 f4;
         filter3 f5;
-        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;

firmware/code/fix16.c

@@ -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
+       our fixed point number. 28-16 = 12, so we shift the incoming value by
-       incoming value by that much to covert it to the desired Q3.28 format and
+       that much to covert it to the desired Q3.28 format and do the normalization
-       do the normalization all in one go.
+       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) {
+        if (~upper)
-            return 0xff800000;
+        {
+            return SHRT_MIN;
         }
     } else {
-        if (upper) {
+        if (upper)
-            return 0x00efffff;
+        {
+            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. */
+       by shifting it back by the same amount we shifted it in the first place. */
-    return (a >> 6);
+    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) {
+fix3_28_t fix16_mul(fix3_28_t inArg0, fix3_28_t inArg1) {
-    int32_t A = (inArg0 >> 14), C = (inArg1 >> 14);
+    const int64_t product = (int64_t)inArg0 * inArg1;
-    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);
 
-#if HANDLE_CARRY
+    /* Since we're expecting 2 Q3.28 numbers, the multiplication result should be a Q7.56 number.
-	// Handle carry from lower bits to upper part of result.
+       To bring this number back to the right order of magnitude, we need to shift
-    uint32_t BD = B*D;
+       it to the right by 28. */
-	uint32_t ad_cb_temp = AD_CB << 14;
+    fix3_28_t result = product >> 28;
-	uint32_t product_lo = BD + ad_cb_temp;
 
-	if (product_lo < BD)
+    // Handle rounding where we are choppping off low order bits
-		product_hi++;
+    // Disabled for now, too much load. We get crackling when adjusting
-#endif
+    // the volume.
-
+    #if 0
-    return product_hi;
+    if (product & 0x4000) {
+        if (result >= 0) {
+            result++;
         }
+        else {
+            result--;
+        }
+    }
+    #endif
+    return result;
+}
+#endif

firmware/code/fix16.h

@@ -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);
+#endif
-
+
-static inline int32_t norm_fix3_28_to_s16sample(fix3_28_t);
+
-
+fix3_28_t norm_fix3_28_from_s16sample(int16_t);
-static inline fix3_28_t fix3_28_from_flt(float);
+
-
+int16_t norm_fix3_28_to_s16sample(fix3_28_t);
-static inline fix3_28_t fix3_28_from_dbl(double);
+
-
+fix3_28_t fix3_28_from_dbl(double);
-static inline fix3_28_t fix16_mul(fix3_28_t, fix3_28_t);
+
-
+fix3_28_t fix16_mul(fix3_28_t, fix3_28_t);
-#include "fix16.inl"
+
 #endif

firmware/code/run.c

@@ -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,23 +135,22 @@ 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();
@@ -184,7 +169,7 @@ static void __no_inline_not_in_flash_func(_as_audio_packet)(struct usb_endpoint
     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;
 
@@ -197,23 +182,20 @@ 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);
+            }
         }
 
         // Signal to core 0 that the data has all been transformed
@@ -265,7 +247,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 +273,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 +291,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 +751,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;

firmware/code/run.h

@@ -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
 
 /*****************************************************************************

firmware/tools/CMakeLists.txt

@@ -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
 )

firmware/tools/README.md

@@ -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.

firmware/tools/filter_test.c

@@ -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);
+            out[i] = (int16_t) fix16_to_s16sample(x_f16);
-        //printf("%08x\n", out[i]);
+        }
     }
 
     // Write out the processed audio.
-    for (int i=0; i<samples; i++) {
+    fwrite(out, samples, sizeof(int16_t), output);
-        fwrite(&out[i], 3, sizeof(int8_t), output);
-    }
     fclose(output);
 
     free(in);