Preview: Snapclient component with reduced dependencies

components/dsp_processor/Kconfig.projbuild

@@ -14,14 +14,6 @@ menu "ESP32 DSP processor config"
         help
             mix stereo audio (left and right channel) to mono and play it on the left AND the right channel
 
-    config USE_BIQUAD_ASM
-        bool "Use optimized asm version of Biquad_f32"
-        default y if IDF_TARGET_ESP32
-        default n
-        depends on USE_DSP_PROCESSOR
-        help
-            Asm version 2 x speed on ESP32 - not working on ESP32-S2
-
     config SNAPCLIENT_USE_SOFT_VOL
         bool "Use software volume"
         default false

components/dsp_processor/dsp_processor.c

@@ -34,12 +34,6 @@ typedef struct dsp_all_params_s {
   } flow_params[DSP_FLOW_COUNT];
 } dsp_all_params_t;
 
-#ifdef CONFIG_USE_BIQUAD_ASM
-#define BIQUAD dsps_biquad_f32_ae32
-#else
-#define BIQUAD dsps_biquad_f32
-#endif
-
 static const char *TAG = "dsp_proc";
 
 #define DSP_PROCESSOR_LEN 16
@@ -521,9 +515,9 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
           }
 
           // BASS
-          BIQUAD(sbuffer0, sbufout0, max, filter[0].coeffs, filter[0].w);
+          dsps_biquad_f32(sbuffer0, sbufout0, max, filter[0].coeffs, filter[0].w);
           // TREBLE
-          BIQUAD(sbufout0, sbuffer0, max, filter[1].coeffs, filter[1].w);
+          dsps_biquad_f32(sbufout0, sbuffer0, max, filter[1].coeffs, filter[1].w);
 
           for (i = 0; i < max; i++) {
             valint = float_to_int16_clamped(sbuffer0[i]);
@@ -539,9 +533,9 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
           }
 
           // BASS
-          BIQUAD(sbuffer0, sbufout0, max, filter[2].coeffs, filter[2].w);
+          dsps_biquad_f32(sbuffer0, sbufout0, max, filter[2].coeffs, filter[2].w);
           // TREBLE
-          BIQUAD(sbufout0, sbuffer0, max, filter[3].coeffs, filter[3].w);
+          dsps_biquad_f32(sbufout0, sbuffer0, max, filter[3].coeffs, filter[3].w);
 
           for (i = 0; i < max; i++) {
             valint = float_to_int16_clamped(sbuffer0[i]);
@@ -597,7 +591,7 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
                 dynamic_vol * 
                 ((float)((int16_t)(tmp[i] & 0xFFFF))) / INT16_MAX;
           }
-          BIQUAD(sbuffer0, sbufout0, max, filter[0].coeffs, filter[0].w);
+          dsps_biquad_f32(sbuffer0, sbufout0, max, filter[0].coeffs, filter[0].w);
 
           for (i = 0; i < max; i++) {
             valint = float_to_int16_clamped(sbufout0[i]);
@@ -610,7 +604,7 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
                           ((float)((int16_t)((tmp[i] & 0xFFFF0000) >> 16))) /
                           INT16_MAX;
           }
-          BIQUAD(sbuffer0, sbufout0, max, filter[1].coeffs, filter[1].w);
+          dsps_biquad_f32(sbuffer0, sbufout0, max, filter[1].coeffs, filter[1].w);
 
           for (i = 0; i < max; i++) {
             valint = float_to_int16_clamped(sbufout0[i]);
@@ -636,8 +630,8 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
             sbuffer0[i] =
                 dynamic_vol * ((float)((int16_t)(tmp[i] & 0xFFFF))) / INT16_MAX;
           }
-          BIQUAD(sbuffer0, sbufout0, max, filter[0].coeffs, filter[0].w);
-          BIQUAD(sbufout0, sbuffer0, max, filter[1].coeffs, filter[1].w);
+          dsps_biquad_f32(sbuffer0, sbufout0, max, filter[0].coeffs, filter[0].w);
+          dsps_biquad_f32(sbufout0, sbuffer0, max, filter[1].coeffs, filter[1].w);
 
           for (i = 0; i < max; i++) {
             valint = float_to_int16_clamped(sbuffer0[i]);
@@ -650,8 +644,8 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
                           ((float)((int16_t)((tmp[i] & 0xFFFF0000) >> 16))) /
                           INT16_MAX;
           }
-          BIQUAD(sbuffer0, sbufout0, max, filter[2].coeffs, filter[2].w);
-          BIQUAD(sbufout0, sbuffer0, max, filter[3].coeffs, filter[3].w);
+          dsps_biquad_f32(sbuffer0, sbufout0, max, filter[2].coeffs, filter[2].w);
+          dsps_biquad_f32(sbufout0, sbuffer0, max, filter[3].coeffs, filter[3].w);
 
           for (i = 0; i < max; i++) {
             valint = float_to_int16_clamped(sbuffer0[i]);
@@ -664,16 +658,16 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
 
       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);
+           dsps_biquad_f32(sbuffer2, sbuftmp0, len, bq[0].coeffs, bq[0].w);
+           dsps_biquad_f32(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);
+           dsps_biquad_f32(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
+           dsps_biquad_f32(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);
+           dsps_biquad_f32(sbuffer1, sbuftmp0, len, bq[4].coeffs, bq[4].w);
+           dsps_biquad_f32(sbuftmp0, sbufout1, len, bq[5].coeffs, bq[5].w);
 
            int16_t valint[5];
            for (uint16_t i = 0; i < len; i++) {
@@ -703,16 +697,16 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) {
 
       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);
+          dsps_biquad_f32(sbuffer2, sbuftmp0, len, bq[0].coeffs, bq[0].w);
+          dsps_biquad_f32(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);
+          dsps_biquad_f32(sbuffer0, sbuftmp0, len, bq[2].coeffs, bq[2].w);
+          dsps_biquad_f32(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);
+          dsps_biquad_f32(sbuffer1, sbuftmp0, len, bq[4].coeffs, bq[4].w);
+          dsps_biquad_f32(sbuftmp0, sbufout1, len, bq[5].coeffs, bq[5].w);
 
           uint16_t scale = 16384;  // INT16_MAX
           int16_t valint[5];

components/lightsnapcast/include/player.h

@@ -62,15 +62,20 @@ typedef struct snapcastSetting_s {
   i2s_data_bit_width_t bits;
 
   bool muted;
-  uint32_t volume;
 
   char *pcmBuf;
   uint32_t pcmBufSize;
 } snapcastSetting_t;
 
-int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_);
+typedef enum { IDLE = 0, PLAYING, PAUSED } player_state_e;
+int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_, void (*set_mute_cb)(bool));
 int deinit_player(void);
 int start_player(snapcastSetting_t *setting);
+void pause_player(bool pause);
+
+void call_state_cb(void);
+void add_player_state_cb(void (*cb)(void));
+player_state_e get_player_state(void);
 
 int32_t allocate_pcm_chunk_memory(pcm_chunk_message_t **pcmChunk, size_t bytes);
 int32_t insert_pcm_chunk(pcm_chunk_message_t *pcmChunk);

components/lightsnapcast/include/snapcast_protocol_parser.h

@@ -1,16 +1,15 @@
 #ifndef __SNAPCAST_PROTOCOL_PARSER_H__
 #define __SNAPCAST_PROTOCOL_PARSER_H__
 
+#include "player.h"  // needed for coded_type_t
 #include "snapcast.h"
-#include "player.h" // needed for coded_type_t
-
 
 typedef struct decoderData_s {
   uint32_t type;  // should be SNAPCAST_MESSAGE_CODEC_HEADER
                   // or SNAPCAST_MESSAGE_WIRE_CHUNK
-  uint8_t *inData;
+  uint8_t* inData;
   tv_t timestamp;
-  uint8_t *outData;
+  uint8_t* outData;
   uint32_t bytes;
 } decoderData_t;
 
@@ -22,27 +21,21 @@ typedef struct {
 } snapcast_protocol_parser_t;
 
 typedef enum {
-  PARSER_COMPLETE = 0,
-  PARSER_INCOMPLETE,
-  PARSER_CRITICAL_ERROR,
-  PARSER_CONNECTION_ERROR,
+  PARSER_OK = 0,
+  PARSER_RESTART_CONNECTION,
 } parser_return_state_t;
 
 parser_return_state_t parse_base_message(snapcast_protocol_parser_t* parser,
                                          base_message_t* base_message_rx);
 
-parser_return_state_t parse_wire_chunk_message(snapcast_protocol_parser_t* parser,
-                                               base_message_t* base_message_rx,
-                                               bool received_codec_header,
-                                               codec_type_t codec,
-                                               pcm_chunk_message_t** pcmData,
-                                               wire_chunk_message_t* wire_chnk,
-                                               decoderData_t* decoderChunk);
+parser_return_state_t parse_wire_chunk_message(
+    snapcast_protocol_parser_t* parser, base_message_t* base_message_rx,
+    codec_type_t codec, pcm_chunk_message_t** pcmData,
+    wire_chunk_message_t* wire_chnk, decoderData_t* decoderChunk);
 
 parser_return_state_t parse_codec_header_message(
-    snapcast_protocol_parser_t* parser,
-    bool* received_codec_header, codec_type_t* codec,
-    char** codecPayload, uint32_t* codecPayloadLen);
+    snapcast_protocol_parser_t* parser, bool* received_codec_header,
+    codec_type_t* codec, char** codecPayload, uint32_t* codecPayloadLen);
 
 parser_return_state_t parse_sever_settings_message(
     snapcast_protocol_parser_t* parser, base_message_t* base_message_rx,
@@ -52,7 +45,7 @@ parser_return_state_t parse_time_message(snapcast_protocol_parser_t* parser,
                                          base_message_t* base_message_rx,
                                          time_message_t* time_message_rx);
 
-parser_return_state_t parse_unknown_message(snapcast_protocol_parser_t* parser,
-                                            base_message_t* base_message_rx);
+parser_return_state_t parser_skip_typed_message(
+    snapcast_protocol_parser_t* parser, base_message_t* base_message_rx);
 
 #endif  // __SNAPCAST_PROTOCOL_PARSER_H__