fix vorbis & opus never ending - release

.github/workflows/Platform_build.yml

@@ -13,7 +13,6 @@ on:
         description: 'Force a Release build. When not forced, the system will check for release word in the last commit message to trigger a release'
         required: true
         type: boolean
-
 jobs:
   bootstrap:
     name: Global setup
@@ -228,5 +227,7 @@ jobs:
   update_web_installer:
     name: Update Web Installer After Release
     needs: [ bootstrap, build ]
-    if:  ${{( always() && !cancelled() ) && needs.bootstrap.outputs.release_flag == 1 && needs.bootstrap.outputs.mock == 0 }}
+    if: ${{ always() && !cancelled() && needs.bootstrap.outputs.release_flag == 1 && needs.bootstrap.outputs.mock == 0 }}
     uses: ./.github/workflows/web_deploy.yml
+    secrets:
+      WEB_INSTALLER: ${{ secrets.WEB_INSTALLER }}

.github/workflows/web_deploy.yml

@@ -1,6 +1,9 @@
 name: Update Web Installer
 on:
   workflow_call:
+    secrets:
+      WEB_INSTALLER:
+        required: true       
   workflow_dispatch:
 jobs:
   update_web_installer:

README.md

@@ -1,22 +1,23 @@
-![Cross-Build](https://github.com/sle118/squeezelite-esp32/workflows/Cross-Build/badge.svg?branch=master-cmake)
-![ESP-IDF v4.3.1](https://github.com/sle118/squeezelite-esp32/actions/workflows/esp-idf-v4.3-build.yml/badge.svg?branch=master-v4.3)
+[![Platform Build](https://github.com/sle118/squeezelite-esp32/actions/workflows/Platform_build.yml/badge.svg)](https://github.com/sle118/squeezelite-esp32/actions/workflows/Platform_build.yml)
 # Squeezelite-esp32
-## What is this
+
+## What is this?
 Squeezelite-esp32 is an audio software suite made to run on espressif's ESP32 wifi (b/g/n) and bluetooth chipset. It offers the following capabilities
 
 - Stream your local music and connect to all major on-line music providers (Spotify, Deezer, Tidal, Qobuz) using [Logitech Media Server - a.k.a LMS](https://forums.slimdevices.com/) and enjoy multi-room audio synchronization. LMS can be extended by numerous plugins and can be controlled using a Web browser or dedicated applications (iPhone, Android). It can also send audio to UPnP, Sonos, ChromeCast and AirPlay speakers/devices.
-- Stream directly from a Bluetooth device (iPhone, Android)
-- Stream directly from an AirPlay controller (iPhone, iTunes ...) and enjoy synchronization multiroom as well (although it's AirPlay 1 only)
-- Stream direcly from Spotify using SpotifyConnect (thanks to [cspot](https://github.com/feelfreelinux/cspot)
+- Stream from a **Bluetooth** device (iPhone, Android)
+- Stream from an **AirPlay** controller (iPhone, iTunes ...) and enjoy synchronization multiroom as well (although it's AirPlay 1 only)
+- Stream direcly from **Spotify** using SpotifyConnect (thanks to [cspot](https://github.com/feelfreelinux/cspot)
 
 Depending on the hardware connected to the ESP32, you can send audio to a local DAC, to SPDIF or to a Bluetooth speaker. The bare minimum required hardware is a WROVER module with 4MB of Flash and 4MB of PSRAM (https://www.espressif.com/en/products/modules/esp32). With that module standalone, just apply power and you can stream to a Bluetooth speaker. You can also send audio to most I2S DAC as well as to SPDIF receivers using just a cable or an optical transducer.
 
 But squeezelite-esp32 is highly extensible and you can add
 
-- Buttons and Rotary Encoder and map/combine them to various functions (play, pause, volume, next ...)
-- IR receiver (no pullup resistor or capacitor needed, just the 38kHz receiver)
-- Monochrome, GrayScale or Color displays using SPI or I2C (supported drivers are SH1106, SSD1306, SSD1322, SSD1326/7, SSD1351, ST7735, ST7789 and ILI9341).
-- Ethernet using a Microchip LAN8720 with RMII interface or Davicom DM9051 over SPI.
+- [Buttons](#buttons) and [Rotary Encoder](#rotary-encoder) and map/combine them to various functions (play, pause, volume, next ...)
+- [GPIO expander](#gpio-expanders) (buttons, led and rotary)
+- [IR receiver](#infrared) (no pullup resistor or capacitor needed, just the 38kHz receiver)
+- [Monochrome, GrayScale or Color displays](#display) using SPI or I2C (supported drivers are SH1106, SSD1306, SSD1322, SSD1326/7, SSD1351, ST7735, ST7789 and ILI9341).
+- [Ethernet](#ethernet-required-unpublished-version-43) using a Microchip LAN8720 with RMII interface or Davicom DM9051/W5500 over SPI.
 
 Other features include
 
@@ -51,29 +52,44 @@ The esp32 must run at 240 MHz, with Quad-SPI I/O at 80 MHz and a clock of 40 Mhz
 In 16 bits mode, although 192 kHz is reported as max rate, it's highly recommended to limit reported sampling rate to 96k (-Z 96000). Note that some high-speed 24/96k on-line streams might stutter because of TCP/IP stack performances. It is usually due to the fact that the server sends small packets of data and the esp32 cannot receive encoded audio fast enough, regardless of task priority settings (I've tried to tweak that a fair bit). The best option in that case is to let LMS proxy the stream as it will provide larger chunks and a "smoother" stream that can then be handled.
 
 Note as well that some codecs consume more CPU than others or have not been optimized as much. I've done my best to tweak these, but that level of optimization includes writing some assembly which is painful. One very demanding codec is AAC when files are encoded with SBR. It allows reconstruction of upper part of spectrum and thus higher sampling rate, but the codec spec is such that this is optional, you can decode simply lower band and accept lower sampling rate - See the AAC_DISABLE_SBR option below.
+
 ## Supported Hardware
 Any esp32-based hardware with at least 4MB of flash and 4MB of PSRAM will be capable of running squeezelite-esp32 and there are various boards that include such chip. A few are mentionned below, but any should work. You can find various help & instructions [here](https://forums.slimdevices.com/showthread.php?112697-ANNOUNCE-Squeezelite-ESP32-(dedicated-thread))
 
 **For the sake of clarity, WROOM modules DO NOT work as they don't include PSRAM. Some designs might add it externally, but it's (very) unlikely.**
+
 ### Raw WROVER module
 Per above description, a [WROVER module](https://www.espressif.com/en/products/modules/esp32) is enough to run Squeezelite-esp32, but that requires a bit of tinkering to extend it to have analogue audio or hardware buttons (e.g.) 
 
 Please note that when sending to a Bluetooth speaker (source), only 44.1 kHz can be used, so you either let LMS do the resampling, but you must make sure it only sends 44.1kHz tracks or enable internal resampling (using -R) option. If you connect a DAC, choice of sample rates will depends on its capabilities. See below for more details.
 
 Most DAC will work out-of-the-box with simply an I2S connection, but some require specific commands to be sent using I2C. See DAC option below to understand how to send these dedicated commands. There is build-in support for TAS575x, TAS5780, TAS5713 and AC101 DAC.
+
 ### SqueezeAMP
 This is the main hardware companion of Squeezelite-esp32 and has been developped together. Details on capabilities can be found [here](https://forums.slimdevices.com/showthread.php?110926-pre-ANNOUNCE-SqueezeAMP-and-SqueezeliteESP32) and [here](https://github.com/philippe44/SqueezeAMP).
 
-if you want to rebuild, use the `squeezelite-esp32-SqueezeAmp-sdkconfig.defaults` configuration file.
+If you want to rebuild, use the `squeezelite-esp32-SqueezeAmp-sdkconfig.defaults` configuration file.
 
 NB: You can use the pre-build binaries SqueezeAMP4MBFlash which has all the hardware I/O set properly. You can also use the generic binary I2S4MBFlash in which case the NVS parameters shall be set to get the exact same behavior
-- set_GPIO: 12=green,13=red,34=jack,2=spkfault
-- batt_config: channel=7,scale=20.24
-- dac_config: model=TAS57xx,bck=33,ws=25,do=32,sda=27,scl=26,mute=14:0
-- spdif_config: bck=33,ws=25,do=15
+- set_GPIO: `12=green,13=red,34=jack,2=spkfault`
+- bat_config: `channel=7,scale=20.24`
+- dac_config: `model=TAS57xx,bck=33,ws=25,do=32,sda=27,scl=26,mute=14:0`
+- spdif_config: `bck=33,ws=25,do=15`
+
+### MuseLuxe
+This portable battery-powered [speaker](https://raspiaudio.com/produit/esp-muse-luxe) is compatible with squeezelite-esp32 for which there is a dedicated build supplied with every update. If you want to rebuild, use the `squeezelite-esp32-Muse-sdkconfig.defaults` configuration file.
+
+NB: You can use the pre-build binaries Muse4MBFlash which has all the hardware I/O set properly. You can also use the generic binary I2S4MBFlash in which case the NVS parameters shall be set to get the exact same behavior
+- target: `muse`
+- bat_config: `channel=5,scale=7.48,atten=3,cells=1`
+- spi_config: `"mosi=15,miso=2,clk=14` *(this one is probably optional)*
+- dac_config: `model=I2S,bck=5,ws=25,do=26,di=35,i2c=16,sda=18,scl=23,mck`
+- dac_controlset: `{"init":[ {"reg":0,"val":128}, {"reg":0,"val":0}, {"reg":25,"val":4}, {"reg":1,"val":80}, {"reg":2,"val":0},	{"reg":8,"val":0}, {"reg":4,"val":192},	{"reg":0,"val":18}, {"reg":1,"val":0}, {"reg":23,"val":24}, {"reg":24,"val":2}, {"reg":38,"val":9}, {"reg":39,"val":144}, {"reg":42,"val":144}, {"reg":43,"val":128}, {"reg":45,"val":128}, {"reg":27,"val":0}, {"reg":26,"val":0}, {"reg":2,"val":240}, {"reg":2,"val":0},	{"reg":29,"val":28}, {"reg":4,"val":48}, {"reg":25,"val":0}, {"reg":46,"val":33}, {"reg":47,"val":33} ]}`
+- actrls_config: buttons
+- define a "buttons" variable with: `[{"gpio":32, "pull":true, "debounce":10, "normal":{"pressed":"ACTRLS_VOLDOWN"}}, {"gpio":19, "pull":true, "debounce":40, "normal":{"pressed":"ACTRLS_VOLUP"}}, {"gpio":12, "pull":true, "debounce":40, "long_press":1000, "normal":{"pressed":"ACTRLS_TOGGLE"},"longpress":{"pressed":"ACTRLS_POWER"}}]`
 
 ### ESP32-A1S
-Works with [ESP32-A1S](https://docs.ai-thinker.com/esp32-a1s) module that includes audio codec and headset output. You still need to use a demo board like [this](https://www.aliexpress.com/item/4001060963585.html) or an external amplifier if you want direct speaker connection. Note that there is a version with AC101 codec and another one with ES8388 (see below)
+Works with [ESP32-A1S](https://docs.ai-thinker.com/esp32-a1s) module that includes audio codec and headset output. You still need to use a demo board like [this](https://www.aliexpress.com/item/4001060963585.html) or an external amplifier if you want direct speaker connection. Note that there is a version with AC101 codec and another one with ES8388 with probably two variants - these boards are a mess (see below)
 
 The board shown above has the following IO set
 - amplifier: GPIO21
@@ -89,23 +105,30 @@ The board shown above has the following IO set
 (note that some GPIO need pullups)
 
 So a possible config would be
-- set_GPIO: 21=amp,22=green:0,39=jack:0
+- set_GPIO: `21=amp,22=green:0,39=jack:0`
 - a button mapping: 
-```
-[{"gpio":5,"normal":{"pressed":"ACTRLS_TOGGLE"}},{"gpio":18,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLUP"}, "shifted":{"pressed":"ACTRLS_NEXT"}}, {"gpio":23,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLDOWN"},"shifted":{"pressed":"ACTRLS_PREV"}}]
-```
-for AC101
-- dac_config: model=AC101,bck=27,ws=26,do=25,di=35,sda=33,scl=32
+	```json
+	[{"gpio":5,"normal":{"pressed":"ACTRLS_TOGGLE"}},{"gpio":18,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLUP"}, "shifted":{"pressed":"ACTRLS_NEXT"}}, {"gpio":23,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLDOWN"},"shifted":{"pressed":"ACTRLS_PREV"}}]
+	```
+for **AC101**
+- dac_config: `model=AC101,bck=27,ws=26,do=25,di=35,sda=33,scl=32`
  
-for ES8388
-- dac_config: model=ES8388,bck=5,ws=25,do=26,sda=18,scl=23,i2c=16
+for **ES8388** (it seems that there are variants with same version number - a total mess)
+- dac_config: `model=ES8388,bck=5,ws=25,do=26,sda=18,scl=23,i2c=16`
+or
+- dac_config: `model=ES8388,bck=27,ws=25,do=26,sda=33,scl=32,i2c=16`
+
 ### T-WATCH2020 by LilyGo
 This is a fun [smartwatch](http://www.lilygo.cn/prod_view.aspx?TypeId=50036&Id=1290&FId=t3:50036:3) based on ESP32. It has a 240x240 ST7789 screen and onboard audio. Not very useful to listen to anything but it works. This is an example of a device that requires an I2C set of commands for its dac (see below). There is a build-option if you decide to rebuild everything by yourself, otherwise the I2S default option works with the following parameters
 
-- dac_config: model=I2S,bck=26,ws=25,do=33,i2c=106,sda=21,scl=22
-- dac_controlset: { "init": [ {"reg":41, "val":128}, {"reg":18, "val":255} ], "poweron": [ {"reg":18, "val":64, "mode":"or"} ], "poweroff": [ {"reg":18, "val":191, "mode":"and"} ] }
-- spi_config: dc=27,data=19,clk=18
-- display_config: SPI,driver=ST7789,width=240,height=240,cs=5,back=12,speed=16000000,HFlip,VFlip
+- dac_config: `model=I2S,bck=26,ws=25,do=33,i2c=106,sda=21,scl=22`
+- dac_controlset:
+	```json
+	{ "init": [ {"reg":41, "val":128}, {"reg":18, "val":255} ], "poweron": [ {"reg":18, "val":64, "mode":"or"} ], "poweroff": [ {"reg":18, "val":191, "mode":"and"} ] }
+	```
+- spi_config: `dc=27,data=19,clk=18`
+- display_config: `SPI,driver=ST7789,width=240,height=240,cs=5,back=12,speed=16000000,HFlip,VFlip`
+
 ### ESP32-WROVER + I2S DAC
 Squeezelite-esp32 requires esp32 chipset and 4MB PSRAM. ESP32-WROVER meets these requirements. To get an audio output an I2S DAC can be used. Cheap PCM5102 I2S DACs work others may also work. PCM5012 DACs can be hooked up via:
 
@@ -131,18 +154,23 @@ And the super cool project https://github.com/rochuck/squeeze-amp-too
 ## Configuration
 To access NVS, in the webUI, go to credits and select "shows nvs editor". Go into the NVS editor tab to change NFS parameters. In syntax description below \<\> means a value while \[\] describe optional parameters. 
 
+As mentionned above, there are a few dedicated builds that are provided today: SqueezeAMP and Muse but if you build it yourself, you can also create a build for T-WATCH2020. The default build is a generic firmware named I2S which can be configured through NVS to produce *exactly* the same results than dedicated builds. The difference is that parameters must be entered and can accidently be erased. The GUI provides a great help to load "known config sets" as well. 
+
+By design choice, there is no code that is only embedded for a given version, all code is always there. The philosophy is to minimize as much as possible platform-specific code and use of specific `#ifdef` is prohibited, no matter what. So if you want to add your own platfrom, please look **very hard** at the `main\KConfig.projbuild` to see how you can, using parameters below, make your device purely a configuration-based solution. When there is really no other option, look at `targets\<target>` to add your own code. I will not accept PR for code that can avoid creating such dedicated code whenever possible. The NVS "target" will be used to call target-specific code then, but again this is purely runtime, not compile-time.
+
 ### I2C
 The NVS parameter "i2c_config" set the i2c's gpio used for generic purpose (e.g. display). Leave it blank to disable I2C usage. Note that on SqueezeAMP, port must be 1. Default speed is 400000 but some display can do up to 800000 or more. Syntax is
 ```
 sda=<gpio>,scl=<gpio>[,port=0|1][,speed=<speed>]
 ```
-<strong>Please note that you can not use the same GPIO or port as the DAC</strong>
+**Please note that you can not use the same GPIO or port as the DAC.**
+
 ### SPI
 The esp32 has 4 SPI sub-systems, one is unaccessible so numbering is 0..2 and SPI0 is reserved for Flash/PSRAM. The NVS parameter "spi_config" set the spi's gpio used for generic purpose (e.g. display). Leave it blank to disable SPI usage. The DC parameter is needed for displays. Syntax is
 ```
 data|mosi=<gpio>,clk=<gpio>[,dc=<gpio>][,host=1|2][,miso=<gpio>]
 ``` 
-Default "host" is 1. The "miso" parameter is only used when SPI bus is to be shared with other peripheral (e.g. ethernet, see below), otherwise it can be omitted. Note that "data" can also be named "mosi". 
+Default and only "host" is 1 as others are used already by flash and spiram. The optional "miso" (MasterInSlaveOut) parameter is only used when SPI bus is bi-directional and shared with other peripheral like ethernet, gpio expander. Note that "data" can also be named "mosi" (MasterOutSlaveIn). 
 ### DAC/I2S
 The NVS parameter "dac_config" set the gpio used for i2s communication with your DAC. You can define the defaults at compile time but nvs parameter takes precedence except for SqueezeAMP and A1S where these are forced at runtime. Syntax is
 ```
@@ -150,17 +178,20 @@ bck=<gpio>,ws=<gpio>,do=<gpio>[,mck][,mute=<gpio>[:0|1][,model=TAS57xx|TAS5713|A
 ```
 if "model" is not set or is not recognized, then default "I2S" is used. The option "mck" is used for some codecs that require a master clock (although they should not). Only GPIO0 can be used as MCLK and be aware that this cannot coexit with RMII Ethernet (see ethernet section below). I2C parameters are optional and only needed if your DAC requires an I2C control (See 'dac_controlset' below). Note that "i2c" parameters are decimal, hex notation is not allowed.
 
-So far, TAS57xx, TAS5713, AC101, WM8978 and ES8388 are recognized models where the proper init sequence/volume/power controls are sent. For other codecs that might require an I2C commands, please use the parameter "dac_controlset" that allows definition of simple commands to be sent over i2c for init, power on and off using a JSON syntax:
+So far, TAS57xx, TAS5713, AC101, WM8978 and ES8388 are recognized models where the proper init sequence/volume/power controls are sent. For other codecs that might require an I2C commands, please use the parameter "dac_controlset" that allows definition of simple commands to be sent over i2c for init, power, speakder and headset on and off using a JSON syntax:
+```json
+{ <command>: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
+  <command>: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
+  ... }
 ```
-{ init: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
-  poweron: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
-  poweroff: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ] }
-```
-This is standard JSON notation, so if you are not familiar with it, Google is your best friend. Be aware that the '...' means you can have as many entries as you want, it's not part of the syntax. Every section is optional, but it does not make sense to set i2c in the 'dac_config' parameter and not setting anything here. The parameter 'mode' allows to *or* the register with the value or to *and* it. Don't set 'mode' if you simply want to write. **Note that all values must be decimal**. You can use a validator like [this](https://jsonlint.com) to verify your syntax
+Where `<command>` is one of init, poweron, poweroff, speakeron, speakeroff, headseton, headsetoff
+
+This is standard JSON notation, so if you are not familiar with it, Google is your best friend. Be aware that the '...' means you can have as many entries as you want, it's not part of the syntax. Every section is optional, but it does not make sense to set i2c in the 'dac_config' parameter and not setting anything here. The parameter 'mode' allows to *or* the register with the value or to *and* it. Don't set 'mode' if you simply want to write. The 'val parameter can be an array [v1, v2,...] to write a serie of bytes in a single i2c burst (in that case 'mode' is ignored). **Note that all values must be decimal**. You can use a validator like [this](https://jsonlint.com) to verify your syntax
 
 NB: For specific builds (all except I2S), all this is ignored. For know codecs, the built-in sequences can be overwritten using dac_controlset
 
-<strong>Please note that you can not use the same GPIO or port as the I2C</strong>
+**Please note that you can not use the same GPIO or port as the I2C.**
+
 ### SPDIF
 The NVS parameter "spdif_config" sets the i2s's gpio needed for SPDIF. 
 
@@ -185,26 +216,26 @@ GPIO  ----210ohm-----------||---- coax S/PDIF signal out
                     |
 Ground -------------------------- coax signal ground
 ```
+
 ### Display
-The NVS parameter "display_config" sets the parameters for an optional display. Syntax is
+The NVS parameter "display_config" sets the parameters for an optional display. It can be I2C (see [here](#i2c) for shared bus) or SPI (see [here](#spi) for shared bus) Syntax is
 ```
 I2C,width=<pixels>,height=<pixels>[address=<i2c_address>][,reset=<gpio>][,HFlip][,VFlip][driver=SSD1306|SSD1326[:1|4]|SSD1327|SH1106]
-SPI,width=<pixels>,height=<pixels>,cs=<gpio>[,back=<gpio>][,reset=<gpio>][,speed=<speed>][,HFlip][,VFlip][driver=SSD1306|SSD1322|SSD1326[:1|4]|SSD1327|SH1106|SSD1675|ST7735|ST7789|ILI9341[:16|18][,rotate]][,mode=<mode>]
+SPI,width=<pixels>,height=<pixels>,cs=<gpio>[,back=<gpio>][,reset=<gpio>][,speed=<speed>][,HFlip][,VFlip][driver=SSD1306|SSD1322|SSD1326[:1|4]|SSD1327|SH1106|SSD1675|ST7735[:x=<offset>][:y=<offset>]|ST7789|ILI9341[:16|18][,rotate]]
 ```
 - back: a LED backlight used by some older devices (ST7735). It is PWM controlled for brightness
-- reset: some display have a reset pin that is should normally be pulled up if unused
+- reset: some display have a reset pin that is should normally be pulled up if unused. Most displays require reset and will not initialize well otherwise.
 - VFlip and HFlip are optional can be used to change display orientation
 - rotate: for non-square *drivers*, move to portrait mode. Note that *width* and *height* must be inverted then
 - Default speed is 8000000 (8MHz) but SPI can work up to 26MHz or even 40MHz
-- mode:  Default mode = 0.  Some display modules use different transaction line timings.  Check the module documentation if a non-standard mode is required.
-- SH1106 is 128x64 monochrome I2C/SPI [here]((https://www.waveshare.com/wiki/1.3inch_OLED_HAT))
+- SH1106 is 128x64 monochrome I2C/SPI [here](https://www.waveshare.com/wiki/1.3inch_OLED_HAT)
 - SSD1306 is 128x32 monochrome I2C/SPI [here](https://www.buydisplay.com/i2c-blue-0-91-inch-oled-display-module-128x32-arduino-raspberry-pi)
 - SSD1322 is 256x64 grayscale 16-levels SPI in multiple sizes [here](https://www.buydisplay.com/oled-display/oled-display-module?resolution=159) - it is very nice
 - SSD1326 is 256x32 monochrome or grayscale 16-levels SPI [here](https://www.aliexpress.com/item/32833603664.html?spm=a2g0o.productlist.0.0.2d19776cyQvsBi&algo_pvid=c7a3db92-e019-4095-8a28-dfdf0a087f98&algo_expid=c7a3db92-e019-4095-8a28-dfdf0a087f98-1&btsid=0ab6f81e15955375483301352e4208&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_)
 - SSD1327 is 128x128 16-level grayscale SPI [here](https://www.amazon.com/gp/product/B079N1LLG8/ref=ox_sc_act_title_1?smid=A1N6DLY3NQK2VM&psc=1) - artwork can be up to 96x96 with vertical vu-meter/spectrum
 - SSD1351 is 128x128 65k/262k color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/1.5inch-rgb-oled-module.htm)
 - SSD1675 is an e-ink paper and is experimental as e-ink is really not suitable for LMS du to its very low refresh rate
-- ST7735 is a 128x160 65k color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/1.8inch-lcd-module.htm). This needs a backlight control
+- ST7735 is a 128x160 65k color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/1.8inch-lcd-module.htm). This needs a backlight control. Some have X/Y offsets betwen the driver and the glass (green/black/red models) that can be added using "x" and "y" options (case sensitive!)
 - ST7789 is a 240x320 65k (262k not enabled) color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/2inch-lcd-module.htm). It also exist with 240x240 displays. See **rotate** for use in portrait mode
 - ILI9341 is another 240x320 65k (262k capable) color SPI. I've not used it much, the driver it has been provided by one external contributor to the project
 
@@ -212,13 +243,12 @@ You can tweak how the vu-meter and spectrum analyzer are displayed, as well as s
 
 The NVS parameter "metadata_config" sets how metadata is displayed for AirPlay and Bluetooth. Syntax is
 ```
-[format=<display_content>][,speed=<speed>][,pause=<pause>]
+[format=<display_content>][,speed=<speed>][,pause=<pause>][,artwork[:0|1]]
 ```
 - 'speed' is the scrolling speed in ms (default is 33ms)
-
 - 'pause' is the pause time between scrolls in ms (default is 3600ms)
-
-- 'format' can contain free text and any of the 3 keywords %artist%, %album%, %title%. Using that format string, the keywords are replaced by their value to build the string to be displayed. Note that the plain text following a keyword that happens to be empty during playback of a track will be removed. For example, if you have set format=%artist% - %title% and there is no artist in the metadata then only <title> will be displayed not " - <title>".
+- 'format' can contain free text and any of the 3 keywords `%artist%`, `%album%`, `%title%`. Using that format string, the keywords are replaced by their value to build the string to be displayed. Note that the plain text following a keyword that happens to be empty during playback of a track will be removed. For example, if you have set format=`%artist% - %title%` and there is no artist in the metadata then only `<title>` will be displayed not ` - <title>`.
+- 'artwork' enables coverart display, if available (does not work for Bluetooth). The optional parameter indicates if the artwork should be resized (1) to fit the available space. Note that the built-in resizer can only do 2,4 and 8 downsizing, so fit is not optimal. The artwork will be placed at the right of the display for landscape displays and underneath the two information lines for others (there is no user option to tweak that).
 
 ### Infrared
 You can use any IR receiver compatible with NEC protocol (38KHz). Vcc, GND and output are the only pins that need to be connected, no pullup, no filtering capacitor, it's a straight connection.
@@ -234,13 +264,13 @@ The parameter "set_GPIO" is used to assign GPIO to various functions.
 
 GPIO can be set to GND provide or Vcc at boot. This is convenient to power devices that consume less than 40mA from the side connector. Be careful because there is no conflict checks being made wrt which GPIO you're changing, so you might damage your board or create a conflict here. 
 
-The \<amp\> parameter can use used to assign a GPIO that will be set to active level (default 1) when playback starts. It will be reset when squeezelite becomes idle. The idle timeout is set on the squeezelite command line through -C \<timeout\>
+The `<amp>` parameter can use used to assign a GPIO that will be set to active level (default 1) when playback starts. It will be reset when squeezelite becomes idle. The idle timeout is set on the squeezelite command line through `-C <timeout>`
 
 If you have an audio jack that supports insertion (use :0 or :1 to set the level when inserted), you can specify which GPIO it's connected to. Using the parameter jack_mutes_amp allows to mute the amp when headset (e.g.) is inserted.
 
 You can set the Green and Red status led as well with their respective active state (:0 or :1)
 
-The \<ir\> parameter set the GPIO associated to an IR receiver. No need to add pullup or capacitor
+The `<ir>` parameter set the GPIO associated to an IR receiver. No need to add pullup or capacitor
 
 Syntax is:
 
@@ -249,12 +279,34 @@ Syntax is:
 ```
 You can define the defaults for jack, spkfault leds at compile time but nvs parameter takes precedence except for well-known configurations where these are forced at runtime.
 **Note that gpio 36 and 39 are input only and cannot use interrupt. When set to jack or speaker fault, a 100ms polling checks their value but that's expensive**
+ 
+### GPIO expanders
+It is possible to add GPIO expanders using I2C or SPI bus. They should mainly be used for buttons but they can support generic-purpose outputs as well. These additional GPIOs can be numbered starting from an arbitrary value (40 and above as esp32 has GPIO 0..39). Then these new "virtual" GPIOs from (e.g) 100 to 115 can be used in [button](#Buttons) configuration, [set_GPIO](#set-gpio) or other config settings.
+
+Each expander can support up to 32 GPIO. To use an expander for buttons, an interrupt must be provided, polling mode is not acceptable. An expander w/o interruption can still be configured, but only output will be usable. Note that the same interrupt can be shared accross expanders, as long as they are using open drain or open collectors (which they probably all do)
+
+The parameter "gpio_exp_config" is a semicolon (;) separated list with following syntax for each expander
+```
+model=<model>,addr=<addr>,[,port=system|dac][,base=<n>|100][,count=<n>|16][,intr=<gpio>][,cs=<gpio>][,speed=<Hz>]
+```	
+- model: pca9535, pca85xx, mcp23017 and mcp23s17 (SPI version)
+- addr: chip i2c/spi address (decimal)
+- port (I2C): use either "system" port (shared with display for example) or "dac" port (system is default)
+- cs (SPI): gpio used for Chip Select
+- speed (SPI): speed of the SPI bus for that device (in Hz)	
+- base: GPIO numbering offset to use everywhere else (default 40)
+- count: number of GPIO of expander (default 16 - might be obsolted if model if sufficient to decide)
+- intr: real GPIO to use as interrupt.
+	
+Note that PWM ("led_brightness" below) is not supported for expanded GPIOs and they cannot be used for high speed or precise timing signals like CS, D/C, Reset and Ready. Buttons, rotary encoder, amplifier control and power are supported. Depending on the actual chipset, pullup or pulldown might be supported so you might have to add external resistors (only MCP23x17 does pullup). The pca8575 is not a great chip, it generate a fair bit of spurious interrupts when used for GPIO out. When using a SPI expander, the bus must be configured using shared [SPI](#SPI) bus
+
 ### LED 
-See §**set_GPIO** for how to set the green and red LEDs. In addition, their brightness can be controlled using the "led_brigthness" parameter. The syntax is
+See [set_GPIO](#set-gpio) for how to set the green and red LEDs. In addition, their brightness can be controlled using the "led_brigthness" parameter. The syntax is
 ```
 [green=0..100][,red=0..100]
 ```
 NB: For well-known configuration, this is ignored
+
 ### Rotary Encoder
 One rotary encoder is supported, quadrature shift with press. Such encoders usually have 2 pins for encoders (A and B), and common C that must be set to ground and an optional SW pin for press. A, B and SW must be pulled up, so automatic pull-up is provided by ESP32, but you can add your own resistors. A bit of filtering on A and B (~470nF) helps for debouncing which is not made by software. 
 
@@ -280,14 +332,15 @@ The SW gpio is optional, you can re-affect it to a pure button if you prefer but
 See also the "IMPORTANT NOTE" on the "Buttons" section and remember that when 'lms_ctrls_raw' (see below) is activated, none of these knobonly,volume,longpress options apply, raw button codes (not actions) are simply sent to LMS
 
 **Note that gpio 36 and 39 are input only and cannot use interrupt, so they cannot be set to A or B. When using them for SW, a 100ms polling is used which is expensive**
+
 ### Buttons
 Buttons are described using a JSON string with the following syntax
-```
+```json
 [
-{"gpio":<num>,		
- "type":"BUTTON_LOW | BUTTON_HIGH",	
+{"gpio":<num>,
+ "type":"BUTTON_LOW | BUTTON_HIGH",
  "pull":[true|false],
- "long_press":<ms>, 
+ "long_press":<ms>,
  "debounce":<ms>,
  "shifter_gpio":<-1|num>,
  "normal": {"pressed":"<action>","released":"<action>"},
@@ -311,7 +364,7 @@ Where (all parameters are optionals except gpio)
  - "shifted": action to take when a button is pressed/released and shifted (see above/below)
  - "longshifted": action to take when a button is long-pressed/released and shifted (see above/below)
 
-Where \<action\> is either the name of another configuration to load (remap) or one amongst
+Where `<action>` is either the name of another configuration to load (remap) or one amongst
 
 ```
 ACTRLS_NONE, ACTRLS_POWER, ACTRLS_VOLUP, ACTRLS_VOLDOWN, ACTRLS_TOGGLE, ACTRLS_PLAY, 
@@ -324,7 +377,7 @@ KNOB_LEFT, KNOB_RIGHT, KNOB_PUSH,
 One you've created such a string, use it to fill a new NVS parameter with any name below 16(?) characters. You can have as many of these configs as you can. Then set the config parameter "actrls_config" with the name of your default config
 
 For example a config named "buttons" :
-```
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,"normal":{"pressed":"ACTRLS_VOLDOWN"},"longpress":{"pressed":"buttons_remap"}},
  {"gpio":5,"type":"BUTTON_LOW","pull":true,"shifter_gpio":4,"normal":{"pressed":"ACTRLS_VOLUP"}, "shifted":{"pressed":"ACTRLS_TOGGLE"}}]
 ``` 
@@ -333,7 +386,7 @@ Defines two buttons
 - second on GPIO 5, active low. When pressed it triggers a volume up command. If first button is pressed together with this button, then a play/pause toggle command is generated.
 
 While the config named "buttons_remap"
-```
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,"normal":{"pressed":"BCTRLS_DOWN"},"longpress":{"pressed":"buttons"}},
  {"gpio":5,"type":"BUTTON_LOW","pull":true,"shifter_gpio":4,"normal":{"pressed":"BCTRLS_UP"}}]
 ``` 
@@ -341,10 +394,14 @@ Defines two buttons
 - first on GPIO 4, active low. When pressed, it triggers a navigation down command. When pressed more than 1000ms, it changes the button configuration for the one described above
 - second on GPIO 5, active low. When pressed it triggers a navigation up command. That button, in that configuration, has no shift option
 
-Below is a difficult but functional 2-buttons interface for your decoding pleasure
+Below is a difficult but functional 2-buttons interface for your decoding pleasure:
 
-*buttons*
+`actrls_config`:
 ```
+buttons
+```
+`buttons`:
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,
  "normal":{"pressed":"ACTRLS_VOLDOWN"},
  "longpress":{"pressed":"buttons_remap"}},
@@ -354,8 +411,8 @@ Below is a difficult but functional 2-buttons interface for your decoding pleasu
  "longpress":{"pressed":"ACTRLS_NEXT"}}
 ]
 ```
-*buttons_remap*
-```
+`buttons_remap`:
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,
  "normal":{"pressed":"BCTRLS_DOWN"},
  "longpress":{"pressed":"buttons"}},
@@ -366,18 +423,20 @@ Below is a difficult but functional 2-buttons interface for your decoding pleasu
  "longshifted":{"pressed":"BCTRLS_LEFT"}}
 ]
 ```
-<strong>IMPORTANT NOTE</strong>: LMS also supports the possibility to send 'raw' button codes. It's a bit complicated, so bear with me. Buttons can either be processed by SqueezeESP32 and mapped to a "function" like play/pause or they can be just sent to LMS as plain (raw) code and the full logic of press/release/longpress is handled by LMS, you don't have any control on that.
+**IMPORTANT NOTE**: LMS also supports the possibility to send 'raw' button codes. It's a bit complicated, so bear with me. Buttons can either be processed by SqueezeESP32 and mapped to a "function" like play/pause or they can be just sent to LMS as plain (raw) code and the full logic of press/release/longpress is handled by LMS, you don't have any control on that.
 
-The benefit of the "raw" mode is that you can build a player which is as close as possible to a Boom (e.g.) but you can't use the remapping function nor longress or shift logics to do your own mapping when you have a limited set of buttons. In 'raw' mode, all you really need to define is the mapping between the gpio and the button. As far as LMS is concerned, any other option in these JSON payloads does not matter. Now, when you use BT or AirPlay, the full JSON construct described above fully applies, so the shift, longpress, remapping options still work. 
+The benefit of the "raw" mode is that you can build a player which is as close as possible to a Boom (e.g.) but you can't use the remapping function nor longress or shift logics to do your own mapping when you have a limited set of buttons. In 'raw' mode, all you really need to define is the mapping between the gpio and the button. As far as LMS is concerned, any other option in these JSON payloads does not matter. Now, when you use BT or AirPlay, the full JSON construct described above fully applies, so the shift, longpress, remapping options still work.
 
 **Be aware that when using non "raw" mode, the CLI (Command Line Interface) of LMS is used and *must* be available without password**
 
 There is no good or bad option, it's your choice. Use the NVS parameter "lms_ctrls_raw" to change that option
 	
 **Note that gpio 36 and 39 are input only and cannot use interrupt. When using them for a button, a 100ms polling is started which is expensive. Long press is also likely to not work very well**
-### Ethernet (coming soon)
-Wired ethernet is supported by esp32 with various options but squeezelite is only supporting a Microchip LAN8720 with a RMII interface like [this](https://www.aliexpress.com/item/32858432526.html) or Davicom DM9051 over SPI like [that](https://www.amazon.com/dp/B08JLFWX9Z).
-	
+### Ethernet 
+Wired ethernet is supported by esp32 with various options but squeezelite is only supporting a Microchip LAN8720 with a RMII interface like [this](https://www.aliexpress.com/item/32858432526.html) or SPI-ethernet bridges like Davicom DM9051 [that](https://www.amazon.com/dp/B08JLFWX9Z) or W5500 like [this](https://www.aliexpress.com/item/32312441357.html).
+
+**Note:** Touch buttons that can be find on some board like the LyraT V4.3 are not supported currently.
+
 #### RMII (LAN8720)	
 - RMII PHY wiring is fixed and can not be changed
 
@@ -389,6 +448,7 @@ Wired ethernet is supported by esp32 with various options but squeezelite is onl
 | GPIO25 | RX0         | EMAC_RXD0    |
 | GPIO26 | RX1         | EMAC_RXD1    |
 | GPIO27 | CRS_DV      | EMAC_RX_DRV  |
+| GPIO0  | REF_CLK     | 50MHz clock  |
 
 - SMI (Serial Management Interface) wiring is not fixed and you can change it either in the configuration or using "eth_config" parameter with the following syntax:
 ```
@@ -398,30 +458,31 @@ Connecting a reset pin for the LAN8720 is optional but recommended to avoid that
 - Clock
 	
 The APLL of the esp32 is required for the audio codec, so we **need** a LAN8720 that provides a 50MHz clock. That clock **must** be connected to GPIO0, there is no alternative. This means that if your DAC requires an MCLK, then you are out of luck. It is not possible to have both to work together. There might be some workaround using CLK_OUT2 and GPIO3, but I don't have time for this.
-#### SPI (DM9051)
-Ethernet over SPI is supported as well and requires less GPIOs but is obvsiously slower. Another benefit is that the SPI bus can be shared with the display, but it's also possible to have a dedicated SPI interface. The esp32 has 4 SPI sub-systems, one is unaccessible so numbering is 0..2 and SPI0 is reserved for Flash/PSRAM. The "eth_config" parameter syntax becomes:
+#### SPI (DM9051 or W5500)
+Ethernet over SPI is supported as well and requires less GPIOs but is obvsiously slower. SPI is the shared bus set with [spi_config](#spi). The "eth_config" parameter syntax becomes:
 ```
-model=dm9051,cs=<gpio>,speed=<clk_in_Hz>,intr=<gpio>[,host=<-1|1|2>][,rst=<gpio>][,mosi=<gpio>,miso=<gpio>,clk=<gpio>]
+model=dm9051|w5500,cs=<gpio>,speed=<clk_in_Hz>,intr=<gpio>[,rst=<gpio>]
 ```
 - To use the system SPI, shared with display (see spi_config) "host" must be set to -1. Any other value will reserve the SPI interface (careful of conflict with spi_config). The default "host" is 2 to avoid conflicting wiht default "spi_config" settings.
 - When not using system SPI, "mosi" for data out, "miso" for data in and "clk" **must** be set
 - The esp32 has a special I/O multiplexer for faster speed (up to 80 MHz) but that requires using specific GPIOs, which depends on SPI bus (See [here](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/spi_master.html) for more details)
 
-| Pin Name | SPI2 | SPI3 |
+| Pin Name | SPI1 | SPI2 |
 | -------- | ---- | ---- |		
-| CS0*     |  15  |  5   |
+| CS       |  15  |  5   |
 | SCLK	   |  14  |  18  |
 | MISO	   |  12  |  19  |
 | MOSI	   |  13  |  23  |
 	
-** THIS IS NOT AVAILABLE YET, SO MORE TO COME ON HOW TO USE WIRED ETHERNET***
 ### Battery / ADC
 The NVS parameter "bat_config" sets the ADC1 channel used to measure battery/DC voltage. The "atten" value attenuates the input voltage to the ADC input (the read value maintains a 0-1V rage) where: 0=no attenuation(0..800mV), 1=2.5dB attenuation(0..1.1V), 2=6dB attenuation(0..1.35V), 3=11dB attenuation(0..2.6V). Scale is a float ratio applied to every sample of the 12 bits ADC. A measure is taken every 10s and an average is made every 5 minutes (not a sliding window). Syntax is
 ```
 channel=0..7,scale=<scale>,cells=<2|3>[,atten=<0|1|2|3>]
 ```
 NB: Set parameter to empty to disable battery reading. For well-known configuration, this is ignored (except for SqueezeAMP where number of cells is required)
+
 # Configuration
+
 ## Setup WiFi
 - Boot the esp, look for a new wifi access point showing up and connect to it. Default build ssid and passwords are "squeezelite"/"squeezelite". 
 - Once connected, navigate to 192.168.4.1 
@@ -430,7 +491,6 @@ NB: Set parameter to empty to disable battery reading. For well-known configurat
 - Once connection is established, note down the address the device received; this is the address you will use to configure it going forward 
 
 ## Setup squeezelite command line (optional)
-
 At this point, the device should have disabled its built-in access point and should be connected to a known WiFi network.
 - navigate to the address that was noted in step #1
 - Using the list of predefined options, choose the mode in which you want squeezelite to start
@@ -443,7 +503,6 @@ At this point, the device should have disabled its built-in access point and sho
 - You can enable accessto  NVS parameters under 'credits'
 
 ## Monitor
-
 In addition of the esp-idf serial link monitor option, you can also enable a telnet server (see NVS parameters) where you'll have access to a ton of logs of what's happening inside the WROVER.
 
 ## Update Squeezelite
@@ -475,20 +534,23 @@ See squeezlite command line, but keys options are
 	- r "<minrate>-<maxrate>"
 	- C <sec> : set timeout to switch off amp gpio
 	- W : activate WAV and AIFF header parsing
+
 # Building everything yourself
+
 ## Setting up ESP-IDF
+
 ### Docker
 A simple alternative to building the project's binaries is to leverage the same docker image that is being used on the GitHub Actions to build our releases. The instructions below assume that you have cloned  the squeezelite-esp32 code that you want to build locally and that you have opened a command line/bash session in the folder that contains the code. 
 Pull the most recent docker image for the environment: 
 ```
-docker pull sle118/squeezelite-esp32-idfv4-master
+docker pull sle118/squeezelite-esp32-idfv43
 ```
 Then run the container interactively :
 ```
 for windows:
-docker run -v %cd%:/project -w /project -it sle118/squeezelite-esp32-idfv4-master
+docker run -v %cd%:/project -w /project -it sle118/squeezelite-esp32-idfv43
 for linux:
-docker run -it -v `pwd`:/workspace/squeezelite-esp32 sle118/squeezelite-esp32-idfv4-master
+docker run -it -v `pwd`:/workspace/squeezelite-esp32 sle118/squeezelite-esp32-idfv43
 ```
 The above command will mount this repo into the docker container and start a bash terminal. From there, simply run idf.py build to build, etc. Note that at the time of writing these lines, flashing is not possible for docker running under windows https://github.com/docker/for-win/issues/1018.
 
@@ -511,6 +573,7 @@ Use `idf.py monitor` to monitor the application (see esp-idf documentation)
 Note: You can use `idf.py build -DDEPTH=32` to build the 32 bits version and add the `-DVERSION=<your_version>` to add a custom version name (it will be 0.0-<your_version>). If you want to change the whole version string, see squeezelite.h. You can also disable the SBR extension of AAC codecs as it consumes a lot of CPU and might overload the esp32. Use `-DAAC_DISABLE_SBR=1` for that
 
 If you have already cloned the repository and you are getting compile errors on one of the submodules (e.g. telnet), run the following git command in the root of the repository location: `git submodule update --init --recursive`
+
 ### Rebuild codecs (highly recommended to NOT try that)
 - for codecs libraries, add -mlongcalls if you want to rebuild them, but you should not (use the provided ones in codecs/lib). if you really want to rebuild them, open an issue
 - libmad, libflac (no esp's version), libvorbis (tremor - not esp's version), alac work

components/platform_console/app_squeezelite/cmd_squeezelite.c

@@ -66,7 +66,7 @@ static void squeezelite_thread(void *arg){
         
     cmd_send_messaging("cfg-audio-tmpl",ret > 1 ?  MESSAGING_ERROR : MESSAGING_WARNING,"squeezelite exited with error code %d\n", ret);
 
-    if (ret == 1) {
+    if (ret <= 1) {
         int wait = 60;
         wait_for_commit();
         cmd_send_messaging("cfg-audio-tmpl",MESSAGING_ERROR,"Rebooting in %d sec\n", wait);

components/spotify/Shim.cpp

@@ -16,7 +16,10 @@
 #include <stdarg.h>
 #include <ApResolve.h>
 
+#include "BellTask.h"
 #include "MDNSService.h"
+#include "TrackPlayer.h"
+#include "CSpotContext.h"
 #include "SpircHandler.h"
 #include "LoginBlob.h"
 #include "CentralAudioBuffer.h"
@@ -39,12 +42,13 @@ class chunkManager : public bell::Task {
 public:
     std::atomic<bool> isRunning = true;
     std::atomic<bool> isPaused = true;
-    chunkManager(std::shared_ptr<bell::CentralAudioBuffer> centralAudioBuffer, std::function<void()> trackHandler,
-                 std::function<void(const uint8_t*, size_t)> dataHandler);
+    chunkManager(std::function<void()> trackHandler, std::function<void(const uint8_t*, size_t)> dataHandler);
+    size_t writePCM(uint8_t* data, size_t bytes, std::string_view trackId, size_t sequence);
+	void flush();
     void teardown();
 
 private:
-    std::shared_ptr<bell::CentralAudioBuffer> centralAudioBuffer;
+    std::unique_ptr<bell::CentralAudioBuffer> centralAudioBuffer;
     std::function<void()> trackHandler;
     std::function<void(const uint8_t*, size_t)> dataHandler;
     std::mutex runningMutex;
@@ -52,20 +56,27 @@ private:
     void runTask() override;
 };
 
-chunkManager::chunkManager(std::shared_ptr<bell::CentralAudioBuffer> centralAudioBuffer,
-                            std::function<void()> trackHandler, std::function<void(const uint8_t*, size_t)> dataHandler)
+chunkManager::chunkManager(std::function<void()> trackHandler, std::function<void(const uint8_t*, size_t)> dataHandler)
     : bell::Task("chunker", 4 * 1024, 0, 0) {
-    this->centralAudioBuffer = centralAudioBuffer;
+    this->centralAudioBuffer = std::make_unique<bell::CentralAudioBuffer>(32);
     this->trackHandler = trackHandler;
     this->dataHandler = dataHandler;
     startTask();
 }
 
+size_t chunkManager::writePCM(uint8_t* data, size_t bytes, std::string_view trackId, size_t sequence) {
+	return centralAudioBuffer->writePCM(data, bytes, sequence);
+}	
+
 void chunkManager::teardown() {
     isRunning = false;
     std::scoped_lock lock(runningMutex);
 }
 
+void chunkManager::flush() {
+    centralAudioBuffer->clearBuffer();
+}
+
 void chunkManager::runTask() {
     std::scoped_lock lock(runningMutex);
     size_t lastHash = 0;
@@ -103,7 +114,6 @@ class cspotPlayer : public bell::Task {
 private:
     std::string name;
     bell::WrappedSemaphore clientConnected;
-    std::shared_ptr<bell::CentralAudioBuffer> centralAudioBuffer;
 
     int startOffset, volume = 0, bitrate = 160;
     httpd_handle_t serverHandle;
@@ -223,7 +233,7 @@ esp_err_t cspotPlayer::handlePOST(httpd_req_t *request) {
 void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event) {
     switch (event->eventType) {
     case cspot::SpircHandler::EventType::PLAYBACK_START: {
-        centralAudioBuffer->clearBuffer();
+        chunker->flush();
 
         // we are not playing anymore
         trackStatus = TRACK_INIT;
@@ -254,17 +264,17 @@ void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event
     case cspot::SpircHandler::EventType::PREV:
     case cspot::SpircHandler::EventType::FLUSH: {
         // FLUSH is sent when there is no next, just clean everything
-        centralAudioBuffer->clearBuffer();
+        chunker->flush();
         cmdHandler(CSPOT_FLUSH);
         break;
     }
     case cspot::SpircHandler::EventType::DISC:
-        centralAudioBuffer->clearBuffer();
+        chunker->flush();
         cmdHandler(CSPOT_DISC);
         chunker->teardown();
         break;
     case cspot::SpircHandler::EventType::SEEK: {
-        centralAudioBuffer->clearBuffer();
+        chunker->flush();
         cmdHandler(CSPOT_SEEK, std::get<int>(event->data));
         break;
     }
@@ -369,7 +379,6 @@ void cspotPlayer::runTask() {
 
         CSPOT_LOG(info, "Spotify client connected for %s", name.c_str());
 
-        centralAudioBuffer = std::make_shared<bell::CentralAudioBuffer>(32);
         auto ctx = cspot::Context::createFromBlob(blob);
 
         if (bitrate == 320) ctx->config.audioFormat = AudioFormat_OGG_VORBIS_320;
@@ -382,11 +391,20 @@ void cspotPlayer::runTask() {
         // Auth successful
         if (token.size() > 0) {
             spirc = std::make_unique<cspot::SpircHandler>(ctx);
+			
+            // Create a player, pass the track handler
+            chunker = std::make_unique<chunkManager>(
+				[this](void) {
+                    return trackHandler();
+                },
+                [this](const uint8_t* data, size_t bytes) {
+                    return dataHandler(data, bytes);
+            });
 
             // set call back to calculate a hash on trackId
             spirc->getTrackPlayer()->setDataCallback(
                 [this](uint8_t* data, size_t bytes, std::string_view trackId, size_t sequence) {
-                    return centralAudioBuffer->writePCM(data, bytes, sequence);
+                    return chunker->writePCM(data, bytes, trackId, sequence);
             });
 
             // set event (PLAY, VOLUME...) handler
@@ -398,15 +416,6 @@ void cspotPlayer::runTask() {
             // Start handling mercury messages
             ctx->session->startTask();
 
-            // Create a player, pass the tack handler
-            chunker = std::make_unique<chunkManager>(centralAudioBuffer,
-                [this](void) {
-                    return trackHandler();
-                },
-                [this](const uint8_t* data, size_t bytes) {
-                    return dataHandler(data, bytes);
-            });
-
             // set volume at connection
             cmdHandler(CSPOT_VOLUME, volume);
 
@@ -444,7 +453,6 @@ void cspotPlayer::runTask() {
         }
 
         // we want to release memory ASAP and for sure
-        centralAudioBuffer.reset();
         ctx.reset();
         token.clear();
         

components/spotify/cspot/bell/main/audio-dsp/include/CentralAudioBuffer.h

@@ -71,6 +71,7 @@ class CentralAudioBuffer {
   void clearBuffer() {
     std::scoped_lock lock(this->dataAccessMutex);
     //size_t exceptSize = currentSampleRate + (sizeof(AudioChunk) - (currentSampleRate % sizeof(AudioChunk)));
+    hasChunk = false;
     audioBuffer->emptyBuffer();
   }
 

components/spotify/cspot/include/AccessKeyFetcher.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <functional>
-#include <memory>
-
-#include "CSpotContext.h"
-#include "Utils.h"
+#include <functional>  // for function
+#include <memory>      // for shared_ptr
+#include <string>      // for string
 
 namespace cspot {
+struct Context;
+
 class AccessKeyFetcher {
  public:
   AccessKeyFetcher(std::shared_ptr<cspot::Context> ctx);

components/spotify/cspot/include/ApResolve.h

@@ -1,13 +1,9 @@
 #pragma once
 
-#include <memory>
-#include <string>
-
-#include "HTTPClient.h"
+#include <string>  // for string
 #ifdef BELL_ONLY_CJSON
 #include "cJSON.h"
 #else
-#include "nlohmann/json.hpp"
 #endif
 
 namespace cspot {

components/spotify/cspot/include/AuthChallenges.h

@@ -1,20 +1,14 @@
 #pragma once
 
 
-#include <algorithm>
-#include <climits>
-#include <functional>
-#include <memory>
-#include <random>
-#include <vector>
+#include <cstdint>                       // for uint8_t
+#include <memory>                        // for unique_ptr
+#include <string>                        // for string
+#include <vector>                        // for vector
 
-#include "Crypto.h"
-#include "Logger.h"
-#include "NanoPBHelper.h"
-#include "Utils.h"
-
-#include "protobuf/authentication.pb.h"
-#include "protobuf/keyexchange.pb.h"
+#include "Crypto.h"                      // for Crypto
+#include "protobuf/authentication.pb.h"  // for ClientResponseEncrypted
+#include "protobuf/keyexchange.pb.h"     // for APResponseMessage, ClientHello
 
 namespace cspot {
 class AuthChallenges {

components/spotify/cspot/include/CDNTrackStream.h

@@ -1,16 +1,20 @@
 #pragma once
 
-#include <cstddef>
-#include <memory>
-#include "Crypto.h"
-#include "WrappedSemaphore.h"
+#include <cstddef>       // for size_t
+#include <cstdint>       // for uint8_t
+#include <memory>        // for shared_ptr, unique_ptr
+#include <string>        // for string
+#include <vector>        // for vector
 
-#include "Logger.h"
-#include "Utils.h"
-#include "CSpotContext.h"
-#include "AccessKeyFetcher.h"
+#include "Crypto.h"      // for Crypto
+#include "HTTPClient.h"  // for HTTPClient
+
+namespace bell {
+class WrappedSemaphore;
+}  // namespace bell
 
 namespace cspot {
+class AccessKeyFetcher;
 
 class CDNTrackStream {
 

components/spotify/cspot/include/CSpotContext.h

@@ -5,6 +5,7 @@
 #include "MercurySession.h"
 #include "TimeProvider.h"
 #include "protobuf/metadata.pb.h"
+#include "LoginBlob.h"
 
 namespace cspot {
 struct Context {

components/spotify/cspot/include/LoginBlob.h

@@ -1,17 +1,12 @@
 #pragma once
 
-#include <iostream>
-#include <map>
-#include <memory>
-#ifndef BELL_ONLY_CJSON
-#include <nlohmann/json.hpp>
-#endif
-#include <vector>
+#include <cstdint>   // for uint8_t, uint32_t
+#include <map>       // for map
+#include <memory>    // for unique_ptr
+#include <string>    // for string
+#include <vector>    // for vector
 
-#include "ConstantParameters.h"
-#include "Crypto.h"
-
-#include "protobuf/authentication.pb.h"
+#include "Crypto.h"  // for CryptoMbedTLS, Crypto
 
 namespace cspot {
 class LoginBlob {

components/spotify/cspot/include/MercurySession.h

@@ -1,22 +1,23 @@
 #pragma once
 
-#include <atomic>
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include "BellTask.h"
-#include "Logger.h"
-#include "NanoPBHelper.h"
-#include "Packet.h"
-#include "Queue.h"
-#include "Session.h"
-#include "TimeProvider.h"
-#include "Utils.h"
-#include "protobuf/mercury.pb.h"
+#include <atomic>                 // for atomic
+#include <cstdint>                // for uint8_t, uint64_t, uint32_t
+#include <functional>             // for function
+#include <memory>                 // for shared_ptr
+#include <mutex>                  // for mutex
+#include <string>                 // for string
+#include <unordered_map>          // for unordered_map
+#include <vector>                 // for vector
+
+#include "BellTask.h"             // for Task
+#include "Packet.h"               // for Packet
+#include "Queue.h"                // for Queue
+#include "Session.h"              // for Session
+#include "protobuf/mercury.pb.h"  // for Header
 
 namespace cspot { 
+class TimeProvider;
+
 class MercurySession : public bell::Task, public cspot::Session {
  public:
   MercurySession(std::shared_ptr<cspot::TimeProvider> timeProvider);

components/spotify/cspot/include/PlainConnection.h

@@ -3,19 +3,15 @@
 #ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
+
 #include "win32shim.h"
 #else
-#include <netdb.h>
-#include <unistd.h>
-#include "sys/socket.h"
-#include <netinet/in.h>
+#include <unistd.h>    // for size_t
 #endif
-#include <cstdint>
-#include <functional>
-#include <string>
-#include <vector>
-#include "Packet.h"
-#include "Utils.h"
+#include <cstdint>     // for uint8_t
+#include <functional>  // for function
+#include <string>      // for string
+#include <vector>      // for vector
 
 typedef std::function<bool()> timeoutCallback;
 

components/spotify/cspot/include/PlaybackState.h

@@ -1,18 +1,14 @@
 #pragma once
 
-#include <NanoPBHelper.h>
-#include <memory>
-#include <string>
-#include <vector>
-#include "CSpotContext.h"
-#include "ConstantParameters.h"
-#include "CspotAssert.h"
-#include "TimeProvider.h"
-#include "Utils.h"
+#include <stdint.h>             // for uint8_t, uint32_t
+#include <memory>               // for shared_ptr
+#include <string>               // for string
+#include <vector>               // for vector
 
-#include "protobuf/spirc.pb.h"
+#include "protobuf/spirc.pb.h"  // for Frame, TrackRef, CapabilityType, Mess...
 
 namespace cspot {
+struct Context;
 
 class PlaybackState {
  private:

components/spotify/cspot/include/Session.h

@@ -1,20 +1,16 @@
 #pragma once
 
-#include <algorithm>
-#include <functional>
-#include <memory>
-#include <vector>
+#include <stdint.h>  // for uint8_t
+#include <memory>    // for shared_ptr, unique_ptr
+#include <string>    // for string
+#include <vector>    // for vector
 
-#include "ApResolve.h"
-#include "AuthChallenges.h"
-#include "ConstantParameters.h"
-#include "Logger.h"
-#include "LoginBlob.h"
-#include "Packet.h"
-#include "PlainConnection.h"
-#include "ShannonConnection.h"
-#include "Utils.h"
-#include "protobuf/mercury.pb.h"
+namespace cspot {
+class AuthChallenges;
+class LoginBlob;
+class PlainConnection;
+class ShannonConnection;
+}  // namespace cspot
 
 #define LOGIN_REQUEST_COMMAND 0xAB
 #define AUTH_SUCCESSFUL_COMMAND 0xAC

components/spotify/cspot/include/Shannon.h

@@ -1,8 +1,9 @@
 #ifndef SHANNON_H
 #define SHANNON_H
 
-#include <cstdint>
-#include <vector>
+#include <cstdint>  // for uint32_t, uint8_t
+#include <vector>   // for vector
+
 class Shannon
 {
 public:

components/spotify/cspot/include/ShannonConnection.h

@@ -1,18 +1,18 @@
 #ifndef SHANNONCONNECTION_H
 #define SHANNONCONNECTION_H
 
-#include <sys/types.h>
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <vector>
+#include <cstdint>   // for uint8_t, uint32_t
+#include <memory>    // for shared_ptr, unique_ptr
+#include <mutex>     // for mutex
+#include <vector>    // for vector
 
-#include "Packet.h"
-#include "PlainConnection.h"
-#include "Shannon.h"
-#include <mutex>
-#include "Utils.h"
-#include "Logger.h"
+#include "Packet.h"  // for Packet
+
+class Shannon;
+namespace cspot {
+
+class PlainConnection;
+}  // namespace cspot
 
 #define MAC_SIZE 4
 namespace cspot {

components/spotify/cspot/include/SpircHandler.h

@@ -1,16 +1,20 @@
 #pragma once
 
-#include <memory>
-#include "BellTask.h"
+#include <stdint.h>             // for uint32_t, uint8_t
+#include <functional>           // for function
+#include <memory>               // for shared_ptr, unique_ptr
+#include <string>               // for string
+#include <variant>              // for variant
+#include <vector>               // for vector
 
-#include "CDNTrackStream.h"
-#include "CSpotContext.h"
-#include "PlaybackState.h"
-#include "TrackPlayer.h"
-#include "TrackProvider.h"
-#include "protobuf/spirc.pb.h"
+#include "CDNTrackStream.h"     // for CDNTrackStream, CDNTrackStream::Track...
+#include "PlaybackState.h"      // for PlaybackState
+#include "protobuf/spirc.pb.h"  // for MessageType
 
 namespace cspot {
+class TrackPlayer;
+struct Context;
+
 class SpircHandler {
  public:
   SpircHandler(std::shared_ptr<cspot::Context> ctx);

components/spotify/cspot/include/TimeProvider.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include <stdint.h>
-#include <vector>
-
-#include "Utils.h"
+#include <stdint.h>  // for uint8_t
+#include <vector>    // for vector
 
 namespace cspot {
 class TimeProvider {

components/spotify/cspot/include/TrackPlayer.h

@@ -1,22 +1,31 @@
 #pragma once
 
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <atomic>
-#include <BellUtils.h>
-#include <WrappedSemaphore.h>
-#include "CDNTrackStream.h"
-#include "CSpotContext.h"
-#include "TrackProvider.h"
-#include "TrackReference.h"
+#include <atomic>            // for atomic
+#include <cstdint>           // for uint8_t, int64_t
+#include <ctime>             // for size_t, time
+#include <functional>        // for function
+#include <memory>            // for shared_ptr, unique_ptr
+#include <mutex>             // for mutex
+#include <string_view>       // for string_view
+#include <vector>            // for vector
+
+#include "BellTask.h"        // for Task
+#include "CDNTrackStream.h"  // for CDNTrackStream, CDNTrackStream::TrackInfo
+
+namespace bell {
+class WrappedSemaphore;
+}  // namespace bell
 #ifdef BELL_VORBIS_FLOAT
 #include "vorbis/vorbisfile.h"
 #else
-#include "ivorbisfile.h"
+#include "ivorbisfile.h"     // for OggVorbis_File, ov_callbacks
 #endif
 
 namespace cspot {
+class TrackProvider;
+struct Context;
+struct TrackReference;
+
 class TrackPlayer : bell::Task {
  public:
   typedef std::function<void()> TrackLoadedCallback;

components/spotify/cspot/include/TrackProvider.h

@@ -1,15 +1,18 @@
 #pragma once
 
-#include <memory>
+#include <stdint.h>                // for uint8_t
+#include <memory>                  // for shared_ptr, unique_ptr, weak_ptr
+#include <vector>                  // for vector
 
-#include "AccessKeyFetcher.h"
-#include "CDNTrackStream.h"
-#include "CSpotContext.h"
-#include "TrackReference.h"
-#include "protobuf/metadata.pb.h"
-#include "protobuf/spirc.pb.h"
+#include "MercurySession.h"        // for MercurySession
+#include "TrackReference.h"        // for TrackReference
+#include "protobuf/metadata.pb.h"  // for Episode, Restriction, Track
 
 namespace cspot {
+class AccessKeyFetcher;
+class CDNTrackStream;
+struct Context;
+
 class TrackProvider {
  public:
   TrackProvider(std::shared_ptr<cspot::Context> ctx);
@@ -23,11 +26,13 @@ class TrackProvider {
   std::unique_ptr<cspot::CDNTrackStream> cdnStream;
 
   Track trackInfo;
+  Episode episodeInfo;
   std::weak_ptr<CDNTrackStream> currentTrackReference;
   TrackReference trackIdInfo;
 
   void queryMetadata();
   void onMetadataResponse(MercurySession::Response& res);
+  bool doRestrictionsApply(Restriction* restrictions, int count);
   void fetchFile(const std::vector<uint8_t>& fileId,
                  const std::vector<uint8_t>& trackId);
   bool canPlayTrack(int index);

components/spotify/cspot/include/TrackReference.h

@@ -28,12 +28,11 @@ struct TrackReference {
       // Episode GID is being fetched via base62 encoded URI
       auto uri = std::string(ref->uri);
       auto idString = uri.substr(uri.find_last_of(":") + 1, uri.size());
-
       trackRef.gid = {0};
 
       std::string_view alphabet(base62Alphabet);
-      for (int x = 0; x < uri.size(); x++) {
-        size_t d = alphabet.find(uri[x]);
+      for (int x = 0; x < idString.size(); x++) {
+        size_t d = alphabet.find(idString[x]);
         trackRef.gid = bigNumMultiply(trackRef.gid, 62);
         trackRef.gid = bigNumAdd(trackRef.gid, d);
       }

components/spotify/cspot/include/Utils.h

@@ -1,27 +1,20 @@
 #ifndef UTILS_H
 #define UTILS_H
-#include <vector>
+#include <cstdio>     // for snprintf, size_t
+#include <vector>     // for vector
 #ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
+
 #include "win32shim.h"
 #else
-#include <unistd.h>
-#include "sys/socket.h"
-#include <netdb.h>
-#include <netinet/in.h>
+
 #endif
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <chrono>
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <iomanip>
-#include <memory>
-#include <string>
-#include <stdexcept>
+#include <cstdint>    // for uint8_t, uint64_t
+#include <cstring>    // for memcpy
+#include <memory>     // for unique_ptr
+#include <stdexcept>  // for runtime_error
+#include <string>     // for string
 
 #define HMAC_SHA1_BLOCKSIZE 64
 

components/spotify/cspot/protobuf/metadata.options

@@ -12,7 +12,8 @@ Album.name type: FT_POINTER
 Episode.gid type: FT_POINTER
 Episode.name type: FT_POINTER
 ImageGroup.image type: FT_POINTER
-Episode.audio type: FT_POINTER
+Episode.file type: FT_POINTER
+Episode.restriction type: FT_POINTER
 Episode.covers type: FT_POINTER
 Restriction.countries_allowed type: FT_POINTER
 Restriction.countries_forbidden type: FT_POINTER

components/spotify/cspot/protobuf/metadata.proto

@@ -44,7 +44,8 @@ message Episode {
     optional bytes gid = 1;
     optional string name = 2;
     optional sint32 duration = 7;
-    repeated AudioFile audio = 12;
+    repeated AudioFile file = 12;
+    repeated Restriction restriction = 0x4B;
     optional ImageGroup covers = 0x44;
 }
 

components/spotify/cspot/src/AccessKeyFetcher.cpp

@@ -1,7 +1,24 @@
 #include "AccessKeyFetcher.h"
-#include <cstring>
-#include "Logger.h"
-#include "Utils.h"
+
+#include <cstring>           // for strrchr
+#include <initializer_list>  // for initializer_list
+#include <map>               // for operator!=, operator==
+#include <type_traits>       // for remove_extent_t
+#include <vector>            // for vector
+
+#include "BellLogger.h"           // for AbstractLogger
+#include "CSpotContext.h"         // for Context
+#include "Logger.h"               // for CSPOT_LOG
+#include "MercurySession.h"       // for MercurySession, MercurySession::Res...
+#include "Packet.h"               // for cspot
+#include "TimeProvider.h"         // for TimeProvider
+#include "Utils.h"                // for string_format
+#ifdef BELL_ONLY_CJSON
+#include "cJSON.h"
+#else
+#include "nlohmann/json.hpp"      // for basic_json<>::object_t, basic_json
+#include "nlohmann/json_fwd.hpp"  // for json
+#endif
 
 using namespace cspot;
 
@@ -38,18 +55,21 @@ void AccessKeyFetcher::getAccessKey(AccessKeyFetcher::Callback callback) {
   ctx->session->execute(
       MercurySession::RequestType::GET, url,
       [this, timeProvider, callback](MercurySession::Response& res) {
-        if (res.fail) return;
+        if (res.fail)
+          return;
         char* accessKeyJson = (char*)res.parts[0].data();
-        auto accessJSON = std::string(accessKeyJson, strrchr(accessKeyJson, '}') - accessKeyJson + 1);
+        auto accessJSON = std::string(
+            accessKeyJson, strrchr(accessKeyJson, '}') - accessKeyJson + 1);
 #ifdef BELL_ONLY_CJSON
         cJSON* jsonBody = cJSON_Parse(accessJSON.c_str());
-        this->accessKey = cJSON_GetObjectItem(jsonBody, "accessToken")->valuestring;
+        this->accessKey =
+            cJSON_GetObjectItem(jsonBody, "accessToken")->valuestring;
         int expiresIn = cJSON_GetObjectItem(jsonBody, "expiresIn")->valueint;
 #else
         auto jsonBody = nlohmann::json::parse(accessJSON);
         this->accessKey = jsonBody["accessToken"];
         int expiresIn = jsonBody["expiresIn"];
-#endif        
+#endif
         expiresIn = expiresIn / 2;  // Refresh token before it expires
 
         this->expiresAt =
@@ -57,8 +77,8 @@ void AccessKeyFetcher::getAccessKey(AccessKeyFetcher::Callback callback) {
 #ifdef BELL_ONLY_CJSON
         callback(cJSON_GetObjectItem(jsonBody, "accessToken")->valuestring);
         cJSON_Delete(jsonBody);
-#else            
+#else
         callback(jsonBody["accessToken"]);
-#endif    
+#endif
       });
 }

components/spotify/cspot/src/ApResolve.cpp

@@ -1,5 +1,19 @@
 #include "ApResolve.h"
 
+#include <initializer_list>       // for initializer_list
+#include <map>                    // for operator!=, operator==
+#include <memory>                 // for allocator, unique_ptr
+#include <string_view>            // for string_view
+#include <vector>                 // for vector
+
+#include "HTTPClient.h"           // for HTTPClient, HTTPClient::Response
+#ifdef BELL_ONLY_CJSON
+#include "cJSON.h"
+#else
+#include "nlohmann/json.hpp"      // for basic_json<>::object_t, basic_json
+#include "nlohmann/json_fwd.hpp"  // for json
+#endif
+
 using namespace cspot;
 
 ApResolve::ApResolve(std::string apOverride) 
@@ -18,7 +32,7 @@ std::string ApResolve::fetchFirstApAddress()
     std::string_view responseStr = request->body();
 
     // parse json with nlohmann
-#if BELL_ONLY_CJSON
+#ifdef BELL_ONLY_CJSON
    cJSON* json = cJSON_Parse(responseStr.data());
    auto ap_string = std::string(cJSON_GetArrayItem(cJSON_GetObjectItem(json, "ap_list"), 0)->valuestring);
    cJSON_Delete(json);

components/spotify/cspot/src/AuthChallenges.cpp

@@ -1,5 +1,13 @@
 #include "AuthChallenges.h"
 
+#include <algorithm>       // for copy
+#include <climits>         // for CHAR_BIT
+#include <random>          // for default_random_engine, independent_bits_en...
+
+#include "NanoPBHelper.h"  // for pbPutString, pbEncode, pbDecode
+#include "pb.h"            // for pb_byte_t
+#include "pb_decode.h"     // for pb_release
+
 using namespace cspot;
 using random_bytes_engine =
     std::independent_bits_engine<std::default_random_engine, CHAR_BIT, uint8_t>;

components/spotify/cspot/src/CDNTrackStream.cpp

@@ -1,5 +1,26 @@
 #include "CDNTrackStream.h"
 
+#include <string.h>          // for memcpy
+#include <functional>        // for __base
+#include <initializer_list>  // for initializer_list
+#include <map>               // for operator!=, operator==
+#include <string_view>       // for string_view
+#include <type_traits>       // for remove_extent_t
+
+#include "AccessKeyFetcher.h"     // for AccessKeyFetcher
+#include "BellLogger.h"           // for AbstractLogger
+#include "Logger.h"               // for CSPOT_LOG
+#include "Packet.h"               // for cspot
+#include "SocketStream.h"         // for SocketStream
+#include "Utils.h"                // for bigNumAdd, bytesToHexString, string...
+#include "WrappedSemaphore.h"     // for WrappedSemaphore
+#ifdef BELL_ONLY_CJSON
+#include "cJSON.h"
+#else
+#include "nlohmann/json.hpp"      // for basic_json<>::object_t, basic_json
+#include "nlohmann/json_fwd.hpp"  // for json
+#endif
+
 using namespace cspot;
 
 CDNTrackStream::CDNTrackStream(
@@ -10,8 +31,7 @@ CDNTrackStream::CDNTrackStream(
   this->crypto = std::make_unique<Crypto>();
 }
 
-CDNTrackStream::~CDNTrackStream() {
-}
+CDNTrackStream::~CDNTrackStream() {}
 
 void CDNTrackStream::fail() {
   this->status = Status::FAILED;
@@ -40,7 +60,9 @@ void CDNTrackStream::fetchFile(const std::vector<uint8_t>& trackId,
 
 #ifdef BELL_ONLY_CJSON
     cJSON* jsonResult = cJSON_Parse(result.data());
-    std::string cdnUrl = cJSON_GetArrayItem(cJSON_GetObjectItem(jsonResult, "cdnurl"), 0)->valuestring;
+    std::string cdnUrl =
+        cJSON_GetArrayItem(cJSON_GetObjectItem(jsonResult, "cdnurl"), 0)
+            ->valuestring;
     cJSON_Delete(jsonResult);
 #else
     auto jsonResult = nlohmann::json::parse(result);

components/spotify/cspot/src/LoginBlob.cpp

@@ -1,8 +1,18 @@
 #include "LoginBlob.h"
-#include "ConstantParameters.h"
-#include "Logger.h"
+
+#include <stdio.h>                           // for sprintf
+#include <initializer_list>                  // for initializer_list
+
+#include "BellLogger.h"                      // for AbstractLogger
+#include "ConstantParameters.h"              // for brandName, cspot, protoc...
+#include "Logger.h"                          // for CSPOT_LOG
+#include "protobuf/authentication.pb.h"      // for AuthenticationType_AUTHE...
 #ifdef BELL_ONLY_CJSON
 #include "cJSON.h"
+#else
+#include "nlohmann/detail/json_pointer.hpp"  // for json_pointer<>::string_t
+#include "nlohmann/json.hpp"                 // for basic_json<>::object_t
+#include "nlohmann/json_fwd.hpp"             // for json
 #endif
 
 using namespace cspot;

components/spotify/cspot/src/MercurySession.cpp

@@ -1,11 +1,25 @@
 #include "MercurySession.h"
-#include <memory>
-#include <mutex>
-#include "BellLogger.h"
-#include "BellTask.h"
-#include "BellUtils.h"
-#include "CSpotContext.h"
-#include "Logger.h"
+
+#include <string.h>     // for memcpy
+#include <memory>       // for shared_ptr
+#include <mutex>        // for scoped_lock
+#include <stdexcept>    // for runtime_error
+#include <type_traits>  // for remove_extent_t, __underlying_type_impl<>:...
+#include <utility>      // for pair
+
+#ifndef _WIN32
+#include <arpa/inet.h>
+#endif
+
+#include "BellLogger.h"         // for AbstractLogger
+#include "BellTask.h"           // for Task
+#include "BellUtils.h"          // for BELL_SLEEP_MS
+#include "Logger.h"             // for CSPOT_LOG
+#include "NanoPBHelper.h"       // for pbPutString, pbDecode, pbEncode
+#include "PlainConnection.h"    // for PlainConnection
+#include "ShannonConnection.h"  // for ShannonConnection
+#include "TimeProvider.h"       // for TimeProvider
+#include "Utils.h"              // for extract, pack, hton64
 
 using namespace cspot;
 
@@ -167,7 +181,7 @@ void MercurySession::handlePacket() {
 }
 
 void MercurySession::failAllPending() {
-  Response response = { };
+  Response response = {};
   response.fail = true;
 
   // Fail all callbacks

components/spotify/cspot/src/PlainConnection.cpp

@@ -1,12 +1,24 @@
 #include "PlainConnection.h"
-#include <cstring>
+
+#ifndef _WIN32
+#include <netdb.h>        // for addrinfo, freeaddrinfo, getaddrinfo
+#include <netinet/in.h>   // for IPPROTO_IP, IPPROTO_TCP
+#include <sys/errno.h>    // for EAGAIN, EINTR, ETIMEDOUT, errno
+#include <sys/socket.h>   // for setsockopt, connect, recv, send, shutdown
+#include <sys/time.h>     // for timeval
+#endif
+#include <cstring>        // for memset
+#include <stdexcept>      // for runtime_error
 #ifdef _WIN32
 #include <ws2tcpip.h>
 #else
-#include <netinet/tcp.h>
+#include <netinet/tcp.h>  // for TCP_NODELAY
+#include <arpa/inet.h>
 #endif
-#include <errno.h>
-#include "Logger.h"
+#include "BellLogger.h"   // for AbstractLogger
+#include "Logger.h"       // for CSPOT_LOG
+#include "Packet.h"       // for cspot
+#include "Utils.h"        // for extract, pack
 
 using namespace cspot;
 

components/spotify/cspot/src/PlaybackState.cpp

@@ -1,7 +1,20 @@
 #include "PlaybackState.h"
-#include <memory>
-#include "CSpotContext.h"
-#include "Logger.h"
+
+#include <string.h>              // for strdup, memcpy, strcpy, strlen
+#include <cstdint>               // for uint8_t
+#include <cstdlib>               // for free, NULL, realloc, rand
+#include <memory>                // for shared_ptr
+#include <type_traits>           // for remove_extent_t
+#include <utility>               // for swap
+
+#include "BellLogger.h"          // for AbstractLogger
+#include "CSpotContext.h"        // for Context::ConfigState, Context (ptr o...
+#include "ConstantParameters.h"  // for protocolVersion, swVersion
+#include "Logger.h"              // for CSPOT_LOG
+#include "NanoPBHelper.h"        // for pbEncode, pbPutString
+#include "Packet.h"              // for cspot
+#include "pb.h"                  // for pb_bytes_array_t, PB_BYTES_ARRAY_T_A...
+#include "pb_decode.h"           // for pb_release
 
 using namespace cspot;
 

components/spotify/cspot/src/Session.cpp

@@ -1,6 +1,21 @@
 #include "Session.h"
-#include <memory>
-#include "AuthChallenges.h"
+
+#include <limits.h>     // for CHAR_BIT
+#include <cstdint>      // for uint8_t
+#include <functional>   // for __base
+#include <memory>       // for shared_ptr, unique_ptr, make_unique
+#include <random>       // for default_random_engine, independent_bi...
+#include <type_traits>  // for remove_extent_t
+#include <utility>      // for move
+
+#include "ApResolve.h"          // for ApResolve, cspot
+#include "AuthChallenges.h"     // for AuthChallenges
+#include "BellLogger.h"         // for AbstractLogger
+#include "Logger.h"             // for CSPOT_LOG
+#include "LoginBlob.h"          // for LoginBlob
+#include "Packet.h"             // for Packet
+#include "PlainConnection.h"    // for PlainConnection, timeoutCallback
+#include "ShannonConnection.h"  // for ShannonConnection
 
 using random_bytes_engine =
     std::independent_bits_engine<std::default_random_engine, CHAR_BIT, uint8_t>;

components/spotify/cspot/src/Shannon.cpp

@@ -1,9 +1,7 @@
 #include "Shannon.h"
-// #include <bit>
-#include <stdint.h> // for uint32_t
-#include <limits.h> // for CHAR_BIT
-// #define NDEBUG
-#include <assert.h>
+
+#include <limits.h>  // for CHAR_BIT
+#include <stddef.h>  // for size_t
 
 using std::size_t;
 

components/spotify/cspot/src/ShannonConnection.cpp

@@ -1,5 +1,17 @@
 #include "ShannonConnection.h"
-#include "Packet.h"
+
+#include <type_traits>  // for remove_extent_t
+
+#ifndef _WIN32
+#include <arpa/inet.h>
+#endif
+
+#include "BellLogger.h"       // for AbstractLogger
+#include "Logger.h"           // for CSPOT_LOG
+#include "Packet.h"           // for Packet, cspot
+#include "PlainConnection.h"  // for PlainConnection
+#include "Shannon.h"          // for Shannon
+#include "Utils.h"            // for pack, extract
 
 using namespace cspot;
 

components/spotify/cspot/src/SpircHandler.cpp

@@ -1,14 +1,22 @@
 #include "SpircHandler.h"
-#include <memory>
-#include "AccessKeyFetcher.h"
-#include "BellUtils.h"
-#include "CSpotContext.h"
-#include "Logger.h"
-#include "MercurySession.h"
-#include "PlaybackState.h"
-#include "TrackPlayer.h"
-#include "TrackReference.h"
-#include "protobuf/spirc.pb.h"
+
+#include <cstdint>              // for uint8_t
+#include <memory>               // for shared_ptr, make_unique, unique_ptr
+#include <type_traits>          // for remove_extent_t
+#include <utility>              // for move
+
+#include "BellLogger.h"         // for AbstractLogger
+#include "CSpotContext.h"       // for Context::ConfigState, Context (ptr only)
+#include "Logger.h"             // for CSPOT_LOG
+#include "MercurySession.h"     // for MercurySession, MercurySession::Response
+#include "NanoPBHelper.h"       // for pbDecode
+#include "Packet.h"             // for cspot
+#include "PlaybackState.h"      // for PlaybackState, PlaybackState::State
+#include "TrackPlayer.h"        // for TrackPlayer
+#include "TrackReference.h"     // for TrackReference
+#include "Utils.h"              // for stringHexToBytes
+#include "pb_decode.h"          // for pb_release
+#include "protobuf/spirc.pb.h"  // for Frame, State, Frame_fields, MessageTy...
 
 using namespace cspot;
 
@@ -155,9 +163,9 @@ void SpircHandler::handleFrame(std::vector<uint8_t>& data) {
        * when last track has been reached, we has to restart as we can't tell the difference */
       if ((!isNextTrackPreloaded && this->playbackState.getNextTrackRef()) || isRequestedFromLoad) {
           CSPOT_LOG(debug, "Seek command while streaming current");
-          sendEvent(EventType::SEEK, (int)playbackState.remoteFrame.position);
           playbackState.updatePositionMs(playbackState.remoteFrame.position);
           trackPlayer->seekMs(playbackState.remoteFrame.position);
+          sendEvent(EventType::SEEK, (int)playbackState.remoteFrame.position);		  
       } else {
           CSPOT_LOG(debug, "Seek command while streaming next or before started");
           isRequestedFromLoad = true;

components/spotify/cspot/src/TimeProvider.cpp

@@ -1,5 +1,12 @@
 #include "TimeProvider.h"
-#include "Logger.h"
+
+#ifndef _WIN32
+#include <arpa/inet.h>
+#endif
+
+#include "BellLogger.h"   // for AbstractLogger
+#include "Logger.h"       // for CSPOT_LOG
+#include "Utils.h"        // for extract, getCurrentTimestamp
 
 using namespace cspot;
 

components/spotify/cspot/src/TrackPlayer.cpp

@@ -1,12 +1,22 @@
 #include "TrackPlayer.h"
-#include <cstddef>
-#include <fstream>
-#include <memory>
-#include <mutex>
-#include <vector>
-#include "CDNTrackStream.h"
-#include "Logger.h"
-#include "TrackReference.h"
+
+#include <mutex>               // for mutex, scoped_lock
+#include <string>              // for string
+#include <type_traits>         // for remove_extent_t
+#include <vector>              // for vector, vector<>::value_type
+
+#include "BellLogger.h"        // for AbstractLogger
+#include "BellUtils.h"         // for BELL_SLEEP_MS
+#include "CDNTrackStream.h"    // for CDNTrackStream, CDNTrackStream::TrackInfo
+#include "Logger.h"            // for CSPOT_LOG
+#include "Packet.h"            // for cspot
+#include "TrackProvider.h"     // for TrackProvider
+#include "WrappedSemaphore.h"  // for WrappedSemaphore
+
+namespace cspot {
+struct Context;
+struct TrackReference;
+}  // namespace cspot
 
 using namespace cspot;
 

components/spotify/cspot/src/TrackProvider.cpp

@@ -1,12 +1,26 @@
 #include "TrackProvider.h"
-#include <memory>
-#include "AccessKeyFetcher.h"
-#include "CDNTrackStream.h"
-#include "Logger.h"
-#include "MercurySession.h"
-#include "TrackReference.h"
-#include "Utils.h"
-#include "protobuf/metadata.pb.h"
+
+#include <assert.h>                // for assert
+#include <string.h>                // for strlen
+#include <cstdint>                 // for uint8_t
+#include <functional>              // for __base
+#include <memory>                  // for shared_ptr, weak_ptr, make_shared
+#include <string>                  // for string, operator+
+#include <type_traits>             // for remove_extent_t
+
+#include "AccessKeyFetcher.h"      // for AccessKeyFetcher
+#include "BellLogger.h"            // for AbstractLogger
+#include "CDNTrackStream.h"        // for CDNTrackStream, CDNTrackStream::Tr...
+#include "CSpotContext.h"          // for Context::ConfigState, Context (ptr...
+#include "Logger.h"                // for CSPOT_LOG
+#include "MercurySession.h"        // for MercurySession, MercurySession::Da...
+#include "NanoPBHelper.h"          // for pbArrayToVector, pbDecode
+#include "Packet.h"                // for cspot
+#include "TrackReference.h"        // for TrackReference, TrackReference::Type
+#include "Utils.h"                 // for bytesToHexString, string_format
+#include "WrappedSemaphore.h"      // for WrappedSemaphore
+#include "pb_decode.h"             // for pb_release
+#include "protobuf/metadata.pb.h"  // for Track, _Track, AudioFile, Episode
 
 using namespace cspot;
 
@@ -21,9 +35,11 @@ TrackProvider::TrackProvider(std::shared_ptr<cspot::Context> ctx) {
 
 TrackProvider::~TrackProvider() {
   pb_release(Track_fields, &trackInfo);
+  pb_release(Episode_fields, &trackInfo);
 }
 
-std::shared_ptr<cspot::CDNTrackStream> TrackProvider::loadFromTrackRef(TrackReference& trackRef) {
+std::shared_ptr<cspot::CDNTrackStream> TrackProvider::loadFromTrackRef(
+    TrackReference& trackRef) {
   auto track = std::make_shared<cspot::CDNTrackStream>(this->accessKeyFetcher);
   this->currentTrackReference = track;
   this->trackIdInfo = trackRef;
@@ -34,7 +50,8 @@ std::shared_ptr<cspot::CDNTrackStream> TrackProvider::loadFromTrackRef(TrackRefe
 
 void TrackProvider::queryMetadata() {
   std::string requestUrl = string_format(
-      "hm://metadata/3/%s/%s", trackIdInfo.type == TrackReference::Type::TRACK ? "track" : "episode",
+      "hm://metadata/3/%s/%s",
+      trackIdInfo.type == TrackReference::Type::TRACK ? "track" : "episode",
       bytesToHexString(trackIdInfo.gid).c_str());
   CSPOT_LOG(debug, "Requesting track metadata from %s", requestUrl.c_str());
 
@@ -50,54 +67,40 @@ void TrackProvider::queryMetadata() {
 void TrackProvider::onMetadataResponse(MercurySession::Response& res) {
   CSPOT_LOG(debug, "Got track metadata response");
 
-  pb_release(Track_fields, &trackInfo);
-  pbDecode(trackInfo, Track_fields, res.parts[0]);
+  int alternativeCount, filesCount = 0;
+  bool canPlay = false;
+  AudioFile* selectedFiles;
+  std::vector<uint8_t> trackId, fileId;
 
-  CSPOT_LOG(info, "Track name: %s", trackInfo.name);
-  CSPOT_LOG(info, "Track duration: %d", trackInfo.duration);
+  if (trackIdInfo.type == TrackReference::Type::TRACK) {
+    pb_release(Track_fields, &trackInfo);
+    assert(res.parts.size() > 0);
+    pbDecode(trackInfo, Track_fields, res.parts[0]);
+    CSPOT_LOG(info, "Track name: %s", trackInfo.name);
+    CSPOT_LOG(info, "Track duration: %d", trackInfo.duration);
 
-  CSPOT_LOG(debug, "trackInfo.restriction.size() = %d",
-            trackInfo.restriction_count);
+    CSPOT_LOG(debug, "trackInfo.restriction.size() = %d",
+              trackInfo.restriction_count);
 
-  int altIndex = -1;
-  while (!canPlayTrack(altIndex)) {
-    altIndex++;
-    CSPOT_LOG(info, "Trying alternative %d", altIndex);
-
-    if (altIndex >= trackInfo.alternative_count) {
-      // no alternatives for song
-      if (!this->currentTrackReference.expired()) {
-        auto trackRef = this->currentTrackReference.lock();
-        trackRef->status = CDNTrackStream::Status::FAILED;
-        trackRef->trackReady->give();
+    if (doRestrictionsApply(trackInfo.restriction,
+                            trackInfo.restriction_count)) {
+      // Go through alternatives
+      for (int x = 0; x < trackInfo.alternative_count; x++) {
+        if (!doRestrictionsApply(trackInfo.alternative[x].restriction,
+                                 trackInfo.alternative[x].restriction_count)) {
+          selectedFiles = trackInfo.alternative[x].file;
+          filesCount = trackInfo.alternative[x].file_count;
+          trackId = pbArrayToVector(trackInfo.alternative[x].gid);
+          break;
+        }
       }
-      return;
+    } else {
+      selectedFiles = trackInfo.file;
+      filesCount = trackInfo.file_count;
+      trackId = pbArrayToVector(trackInfo.gid);
     }
-  }
 
-  std::vector<uint8_t> trackId;
-  std::vector<uint8_t> fileId;
-  
-  if (altIndex < 0) {
-    trackId = pbArrayToVector(trackInfo.gid);
-    for (int x = 0; x < trackInfo.file_count; x++) {
-      if (trackInfo.file[x].format == ctx->config.audioFormat) {
-        fileId = pbArrayToVector(trackInfo.file[x].file_id);
-        break;  // If file found stop searching
-      }
-    }
-  } else {
-    trackId = pbArrayToVector(trackInfo.alternative[altIndex].gid);
-    for (int x = 0; x < trackInfo.alternative[altIndex].file_count; x++) {
-      if (trackInfo.alternative[altIndex].file[x].format == ctx->config.audioFormat) {
-        fileId =
-            pbArrayToVector(trackInfo.alternative[altIndex].file[x].file_id);
-        break;  // If file found stop searching
-      }
-    }
-  }
-
-  if (!this->currentTrackReference.expired()) {
+    // Set track's metadata
     auto trackRef = this->currentTrackReference.lock();
 
     auto imageId =
@@ -110,6 +113,60 @@ void TrackProvider::onMetadataResponse(MercurySession::Response& res) {
     trackRef->trackInfo.imageUrl =
         "https://i.scdn.co/image/" + bytesToHexString(imageId);
     trackRef->trackInfo.duration = trackInfo.duration;
+  } else {
+    pb_release(Episode_fields, &episodeInfo);
+    assert(res.parts.size() > 0);
+    pbDecode(episodeInfo, Episode_fields, res.parts[0]);
+
+    CSPOT_LOG(info, "Episode name: %s", episodeInfo.name);
+    CSPOT_LOG(info, "Episode duration: %d", episodeInfo.duration);
+
+    CSPOT_LOG(debug, "episodeInfo.restriction.size() = %d",
+              episodeInfo.restriction_count);
+    if (!doRestrictionsApply(episodeInfo.restriction,
+                             episodeInfo.restriction_count)) {
+      selectedFiles = episodeInfo.file;
+      filesCount = episodeInfo.file_count;
+      trackId = pbArrayToVector(episodeInfo.gid);
+    }
+
+    auto trackRef = this->currentTrackReference.lock();
+
+    auto imageId = pbArrayToVector(episodeInfo.covers->image[0].file_id);
+
+    trackRef->trackInfo.trackId = bytesToHexString(trackIdInfo.gid);
+    trackRef->trackInfo.name = std::string(episodeInfo.name);
+    trackRef->trackInfo.album = "";
+    trackRef->trackInfo.artist = "",
+    trackRef->trackInfo.imageUrl =
+        "https://i.scdn.co/image/" + bytesToHexString(imageId);
+    trackRef->trackInfo.duration = episodeInfo.duration;
+  }
+
+  for (int x = 0; x < filesCount; x++) {
+    CSPOT_LOG(debug, "File format: %d", selectedFiles[x].format);
+    if (selectedFiles[x].format == ctx->config.audioFormat) {
+      fileId = pbArrayToVector(selectedFiles[x].file_id);
+      break;  // If file found stop searching
+    }
+
+    // Fallback to OGG Vorbis 96kbps
+    if (fileId.size() == 0 &&
+        selectedFiles[x].format == AudioFormat_OGG_VORBIS_96) {
+      fileId = pbArrayToVector(selectedFiles[x].file_id);
+    }
+  }
+
+  // No viable files found for playback
+  if (fileId.size() == 0) {
+    CSPOT_LOG(info, "File not available for playback");
+    // no alternatives for song
+    if (!this->currentTrackReference.expired()) {
+      auto trackRef = this->currentTrackReference.lock();
+      trackRef->status = CDNTrackStream::Status::FAILED;
+      trackRef->trackReady->give();
+    }
+    return;
   }
 
   this->fetchFile(fileId, trackId);
@@ -147,20 +204,25 @@ bool countryListContains(char* countryList, char* country) {
   return false;
 }
 
+bool TrackProvider::doRestrictionsApply(Restriction* restrictions, int count) {
+  for (int x = 0; x < count; x++) {
+    if (restrictions[x].countries_allowed != nullptr) {
+      return !countryListContains(restrictions[x].countries_allowed,
+                                  (char*)ctx->config.countryCode.c_str());
+    }
+
+    if (restrictions[x].countries_forbidden != nullptr) {
+      return countryListContains(restrictions[x].countries_forbidden,
+                                 (char*)ctx->config.countryCode.c_str());
+    }
+  }
+
+  return false;
+}
+
 bool TrackProvider::canPlayTrack(int altIndex) {
   if (altIndex < 0) {
-    for (int x = 0; x < trackInfo.restriction_count; x++) {
-      if (trackInfo.restriction[x].countries_allowed != nullptr) {
-        return countryListContains(trackInfo.restriction[x].countries_allowed,
-                                   (char*)ctx->config.countryCode.c_str());
-      }
 
-      if (trackInfo.restriction[x].countries_forbidden != nullptr) {
-        return !countryListContains(
-            trackInfo.restriction[x].countries_forbidden,
-            (char*)ctx->config.countryCode.c_str());
-      }
-    }
   } else {
     for (int x = 0; x < trackInfo.alternative[altIndex].restriction_count;
          x++) {

components/spotify/cspot/src/Utils.cpp

@@ -1,168 +1,154 @@
 #include "Utils.h"
-#include <cstring>
-#include <memory>
-#include <chrono>
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <iomanip>
 
-unsigned long long getCurrentTimestamp()
-{
-	return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+#include <stdlib.h>     // for strtol
+#include <iomanip>      // for operator<<, setfill, setw
+#include <iostream>     // for basic_ostream, hex
+#include <sstream>      // for stringstream
+#include <string>       // for string
+#include <type_traits>  // for enable_if<>::type
+#include <chrono>
+#ifndef _WIN32
+#include <arpa/inet.h>
+#endif
+
+unsigned long long getCurrentTimestamp() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             std::chrono::system_clock::now().time_since_epoch())
+      .count();
 }
 
 uint64_t hton64(uint64_t value) {
-    int num = 42;
-    if (*(char *)&num == 42) {
-        uint32_t high_part = htonl((uint32_t)(value >> 32));
-        uint32_t low_part = htonl((uint32_t)(value & 0xFFFFFFFFLL));
-        return (((uint64_t)low_part) << 32) | high_part;
-    } else {
-        return value;
-    }
+  int num = 42;
+  if (*(char*)&num == 42) {
+    uint32_t high_part = htonl((uint32_t)(value >> 32));
+    uint32_t low_part = htonl((uint32_t)(value & 0xFFFFFFFFLL));
+    return (((uint64_t)low_part) << 32) | high_part;
+  } else {
+    return value;
+  }
 }
 
-std::vector<uint8_t> stringHexToBytes(const std::string & s) {
-    std::vector<uint8_t> v;
-    v.reserve(s.length() / 2);
+std::vector<uint8_t> stringHexToBytes(const std::string& s) {
+  std::vector<uint8_t> v;
+  v.reserve(s.length() / 2);
 
-    for (std::string::size_type i = 0; i < s.length(); i += 2) {
-        std::string byteString = s.substr(i, 2);
-        uint8_t byte = (uint8_t) strtol(byteString.c_str(), NULL, 16);
-        v.push_back(byte);
-    }
+  for (std::string::size_type i = 0; i < s.length(); i += 2) {
+    std::string byteString = s.substr(i, 2);
+    uint8_t byte = (uint8_t)strtol(byteString.c_str(), NULL, 16);
+    v.push_back(byte);
+  }
 
-    return v;
+  return v;
 }
 
 std::string bytesToHexString(const std::vector<uint8_t>& v) {
-    std::stringstream ss;
-    ss << std::hex << std::setfill('0');
-    std::vector<uint8_t>::const_iterator it;
+  std::stringstream ss;
+  ss << std::hex << std::setfill('0');
+  std::vector<uint8_t>::const_iterator it;
 
-    for (it = v.begin(); it != v.end(); it++) {
-        ss << std::setw(2) << static_cast<unsigned>(*it);
-    }
+  for (it = v.begin(); it != v.end(); it++) {
+    ss << std::setw(2) << static_cast<unsigned>(*it);
+  }
 
-    return ss.str();
+  return ss.str();
 }
 
-std::vector<uint8_t> bigNumAdd(std::vector<uint8_t> num, int n)
-{
-    auto carry = n;
-    for (int x = num.size() - 1; x >= 0; x--)
-    {
-        int res = num[x] + carry;
-        if (res < 256)
-        {
-            carry = 0;
-            num[x] = res;
-        }
-        else
-        {
-            // Carry the rest of the division
-            carry = res / 256;
-            num[x] = res % 256;
+std::vector<uint8_t> bigNumAdd(std::vector<uint8_t> num, int n) {
+  auto carry = n;
+  for (int x = num.size() - 1; x >= 0; x--) {
+    int res = num[x] + carry;
+    if (res < 256) {
+      carry = 0;
+      num[x] = res;
+    } else {
+      // Carry the rest of the division
+      carry = res / 256;
+      num[x] = res % 256;
 
-            // extend the vector at the last index
-            if (x == 0)
-            {
-                num.insert(num.begin(), carry);
-                return num;
-            }
-        }
-    }
-
-    return num;
-}
-
-std::vector<uint8_t> bigNumDivide(std::vector<uint8_t> num, int n)
-{
-    auto carry = 0;
-    for (int x = 0; x < num.size(); x++)
-    {
-        int res = num[x] + carry * 256;
-        if (res < n)
-        {
-            carry = res;
-            num[x] = 0;
-        }
-        else
-        {
-            // Carry the rest of the division
-            carry = res % n;
-            num[x] = res / n;
-        }
-    }
-
-    return num;
-}
-
-std::vector<uint8_t> bigNumMultiply(std::vector<uint8_t> num, int n)
-{
-    auto carry = 0;
-    for (int x = num.size() - 1; x >= 0; x--)
-    {
-        int res = num[x] * n + carry;
-        if (res < 256)
-        {
-            carry = 0;
-            num[x] = res;
-        }
-        else
-        {
-            // Carry the rest of the division
-            carry = res / 256;
-            num[x] = res % 256;
-
-            // extend the vector at the last index
-            if (x == 0)
-            {
-                num.insert(num.begin(), carry);
-                return num;
-            }
-        }
-    }
-
-    return num;
-}
-unsigned char h2int(char c)
-{
-    if (c >= '0' && c <='9'){
-        return((unsigned char)c - '0');
-    }
-    if (c >= 'a' && c <='f'){
-        return((unsigned char)c - 'a' + 10);
-    }
-    if (c >= 'A' && c <='F'){
-        return((unsigned char)c - 'A' + 10);
-    }
-    return(0);
-}
-
-std::string urlDecode(std::string str)
-{
-    std::string encodedString="";
-    char c;
-    char code0;
-    char code1;
-    for (int i =0; i < str.length(); i++){
-        c=str[i];
-      if (c == '+'){
-        encodedString+=' ';  
-      }else if (c == '%') {
-        i++;
-        code0=str[i];
-        i++;
-        code1=str[i];
-        c = (h2int(code0) << 4) | h2int(code1);
-        encodedString+=c;
-      } else{
-        
-        encodedString+=c;  
+      // extend the vector at the last index
+      if (x == 0) {
+        num.insert(num.begin(), carry);
+        return num;
       }
     }
-    
-   return encodedString;
+  }
+
+  return num;
+}
+
+std::vector<uint8_t> bigNumDivide(std::vector<uint8_t> num, int n) {
+  auto carry = 0;
+  for (int x = 0; x < num.size(); x++) {
+    int res = num[x] + carry * 256;
+    if (res < n) {
+      carry = res;
+      num[x] = 0;
+    } else {
+      // Carry the rest of the division
+      carry = res % n;
+      num[x] = res / n;
+    }
+  }
+
+  return num;
+}
+
+std::vector<uint8_t> bigNumMultiply(std::vector<uint8_t> num, int n) {
+  auto carry = 0;
+  for (int x = num.size() - 1; x >= 0; x--) {
+    int res = num[x] * n + carry;
+    if (res < 256) {
+      carry = 0;
+      num[x] = res;
+    } else {
+      // Carry the rest of the division
+      carry = res / 256;
+      num[x] = res % 256;
+
+      // extend the vector at the last index
+      if (x == 0) {
+        num.insert(num.begin(), carry);
+        return num;
+      }
+    }
+  }
+
+  return num;
+}
+unsigned char h2int(char c) {
+  if (c >= '0' && c <= '9') {
+    return ((unsigned char)c - '0');
+  }
+  if (c >= 'a' && c <= 'f') {
+    return ((unsigned char)c - 'a' + 10);
+  }
+  if (c >= 'A' && c <= 'F') {
+    return ((unsigned char)c - 'A' + 10);
+  }
+  return (0);
+}
+
+std::string urlDecode(std::string str) {
+  std::string encodedString = "";
+  char c;
+  char code0;
+  char code1;
+  for (int i = 0; i < str.length(); i++) {
+    c = str[i];
+    if (c == '+') {
+      encodedString += ' ';
+    } else if (c == '%') {
+      i++;
+      code0 = str[i];
+      i++;
+      code1 = str[i];
+      c = (h2int(code0) << 4) | h2int(code1);
+      encodedString += c;
+    } else {
+
+      encodedString += c;
+    }
+  }
+
+  return encodedString;
 }

components/squeezelite/opus.c

@@ -54,7 +54,6 @@ struct opus {
 	size_t overframes;
 	u8_t *overbuf;
 	int channels;
-    bool eos;
 };
 
 #if !LINKALL
@@ -133,7 +132,7 @@ static opus_uint32 parse_uint32(const unsigned char* _data) {
 }
 
 static int get_opus_packet(void) {
-	int status = 0;
+	int status, packet = -1;
 
 	LOCK_S;
 	size_t bytes = min(_buf_used(streambuf), _buf_cont_read(streambuf));
@@ -152,9 +151,13 @@ static int get_opus_packet(void) {
 		// if we have a new page, put it in
 		if (status)	OG(&go, stream_pagein, &u->state, &u->page);
 	} 
+    
+    // only return a negative value when end of streaming is reached
+    if (status > 0) packet = status;
+    else if (stream.state > DISCONNECT) packet = 0;
 
 	UNLOCK_S;
-	return status;
+	return packet;
 }
 
 static int read_opus_header(void) {
@@ -219,7 +222,6 @@ static int read_opus_header(void) {
 
 static decode_state opus_decompress(void) {
 	frames_t frames;
-	int n;
 	u8_t *write_buf;
 
 	if (decode.new_stream) {      
@@ -257,6 +259,8 @@ static decode_state opus_decompress(void) {
 		frames = process.max_in_frames;
 		write_buf = process.inbuf;
 	);
+    
+    int packet, n = 0;
 	
     // get some packets and decode them, or use the leftover from previous pass
     if (u->overframes) {
@@ -265,7 +269,7 @@ static decode_state opus_decompress(void) {
 		memcpy(write_buf, u->overbuf, u->overframes * BYTES_PER_FRAME);
 		n = u->overframes;
 		u->overframes = 0;
-	} else if (get_opus_packet() > 0) {
+	} else if ((packet = get_opus_packet()) > 0) {
 		if (frames < MAX_OPUS_FRAMES) {
 			// don't have enough contiguous space, use the overflow buffer
 			n = OP(&gu, decode, u->decoder, u->packet.packet, u->packet.bytes, (opus_int16*) u->overbuf, MAX_OPUS_FRAMES, 0);
@@ -280,10 +284,10 @@ static decode_state opus_decompress(void) {
 			 * outputbuf and streambuf for maybe a long time while we process it all, so don't do that */
 			n = OP(&gu, decode, u->decoder, u->packet.packet, u->packet.bytes, (opus_int16*) write_buf, frames, 0);
 		}
-	} else if (!OG(&go, page_eos, &u->page)) {
+	} else if (!packet && !OG(&go, page_eos, &u->page)) {
 		UNLOCK_O_direct;
 		return DECODE_RUNNING;
-	} else u->eos = true;
+	}
 			
 	if (n > 0) {
 		frames_t count;
@@ -326,7 +330,7 @@ static decode_state opus_decompress(void) {
 
 	} else if (n == 0) {
 
-		if (stream.state <= DISCONNECT && u->eos) {
+		if (packet < 0) {
 			LOG_INFO("end of decode");
 			UNLOCK_O_direct;
 			return DECODE_COMPLETE;
@@ -351,7 +355,6 @@ static void opus_open(u8_t size, u8_t rate, u8_t chan, u8_t endianness) {
     
 	if (!u->overbuf) u->overbuf = malloc(MAX_OPUS_FRAMES * BYTES_PER_FRAME);
     
-    u->eos = false;
     u->status = OGG_SYNC;
 	u->overframes = 0;
 	

components/squeezelite/vorbis.c

@@ -65,7 +65,6 @@ struct vorbis {
 	};
 	int rate, channels;
     uint32_t overflow;
-    bool eos;
 };
 
 #if !LINKALL
@@ -133,7 +132,7 @@ extern struct processstate process;
 #endif
 
 static int get_ogg_packet(void) {
-	int status = 0;
+	int status, packet = -1;
 
 	LOCK_S;
 	size_t bytes = min(_buf_used(streambuf), _buf_cont_read(streambuf));
@@ -152,9 +151,13 @@ static int get_ogg_packet(void) {
 		// if we have a new page, put it in
 		if (status)	OG(&go, stream_pagein, &v->state, &v->page);
 	}
+    
+    // only return a negative value when end of streaming is reached
+    if (status > 0) packet = status;
+    else if (stream.state > DISCONNECT) packet = 0;
 
 	UNLOCK_S;
-	return status;
+	return packet;
 }
 
 static int read_vorbis_header(void) {
@@ -261,10 +264,8 @@ inline int pcm_out(vorbis_dsp_state* decoder, void*** pcm) {
 
 static decode_state vorbis_decode(void) {
 	frames_t frames;
-	int n = 0;
 	u8_t *write_buf;
-    void** pcm = NULL;
-
+    
 	if (decode.new_stream) {
         int status = read_vorbis_header();
 
@@ -300,19 +301,22 @@ static decode_state vorbis_decode(void) {
 		frames = process.max_in_frames;
 		write_buf = process.inbuf;
 	);
+    
+    void** pcm = NULL;
+    int packet, n = 0;
 	
     if (v->overflow) {
         n = pcm_out(&v->decoder, &pcm);
         v->overflow = n - min(n, frames);                
-    } else if (get_ogg_packet() > 0) {
+    } else if ((packet = get_ogg_packet()) > 0) {
 		n = OV(&gv, synthesis, &v->block, &v->packet);
 		if (n == 0) n = OV(&gv, synthesis_blockin, &v->decoder, &v->block);
         if (n == 0) n = pcm_out(&v->decoder, &pcm);
         v->overflow = n - min(n, frames);
-	} else if (!OG(&go, page_eos, &v->page)) {
+	} else if (!packet && !OG(&go, page_eos, &v->page)) {
 		UNLOCK_O_direct;
 		return DECODE_RUNNING;
-	} else v->eos = true;
+	}
 
 	if (n > 0) {
         ISAMPLE_T *optr = (ISAMPLE_T*) write_buf;     
@@ -370,7 +374,7 @@ static decode_state vorbis_decode(void) {
 
 	} else if (n == 0) {
 
-		if (stream.state <= DISCONNECT && v->eos) {
+		if (packet < 0) {
 			LOG_INFO("end of decode");
 			UNLOCK_O_direct;
 			return DECODE_COMPLETE;
@@ -397,7 +401,6 @@ static void vorbis_open(u8_t size, u8_t rate, u8_t chan, u8_t endianness) {
 		OV(&go, dsp_clear, &v->decoder);
 	}
     
-    v->eos = false;
     v->opened = false;
 	v->status = OGG_SYNC;
     v->overflow = 0;

components/wifi-manager/webapp/dist/src/js/test.d.ts

@@ -40,6 +40,11 @@ declare function getStatus(): {};
 declare function getStatus(): {};
 declare function getStatus(): {};
 declare function getStatus(): {};
+declare function getStatus(): {};
+declare function getStatus(): {};
+declare function getStatus(): {};
+declare function getStatus(): {};
+declare function getStatus(): {};
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
@@ -82,6 +87,16 @@ declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
+declare function getRadioButton(entry: any): string;
+declare function getRadioButton(entry: any): string;
+declare function getRadioButton(entry: any): string;
+declare function getRadioButton(entry: any): string;
+declare function getRadioButton(entry: any): string;
+declare function pushStatus(): void;
+declare function pushStatus(): void;
+declare function pushStatus(): void;
+declare function pushStatus(): void;
+declare function pushStatus(): void;
 declare function pushStatus(): void;
 declare function pushStatus(): void;
 declare function pushStatus(): void;

components/wifi-manager/webapp/webapp.cmake

@@ -1,5 +1,5 @@
 target_add_binary_data( __idf_wifi-manager webapp/dist/css/index.cd56ff129e3113d8cd3a.css.gz BINARY)
 target_add_binary_data( __idf_wifi-manager webapp/dist/favicon-32x32.png BINARY)
 target_add_binary_data( __idf_wifi-manager webapp/dist/index.html.gz BINARY)
-target_add_binary_data( __idf_wifi-manager webapp/dist/js/index.ab1d13.bundle.js.gz BINARY)
-target_add_binary_data( __idf_wifi-manager webapp/dist/js/node_vendors.ab1d13.bundle.js.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/js/index.1a3b6c.bundle.js.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/js/node_vendors.1a3b6c.bundle.js.gz BINARY)

components/wifi-manager/webapp/webpack.c

@@ -6,29 +6,29 @@ extern const uint8_t _favicon_32x32_png_start[] asm("_binary_favicon_32x32_png_s
 extern const uint8_t _favicon_32x32_png_end[] asm("_binary_favicon_32x32_png_end");
 extern const uint8_t _index_html_gz_start[] asm("_binary_index_html_gz_start");
 extern const uint8_t _index_html_gz_end[] asm("_binary_index_html_gz_end");
-extern const uint8_t _index_ab1d13_bundle_js_gz_start[] asm("_binary_index_ab1d13_bundle_js_gz_start");
-extern const uint8_t _index_ab1d13_bundle_js_gz_end[] asm("_binary_index_ab1d13_bundle_js_gz_end");
-extern const uint8_t _node_vendors_ab1d13_bundle_js_gz_start[] asm("_binary_node_vendors_ab1d13_bundle_js_gz_start");
-extern const uint8_t _node_vendors_ab1d13_bundle_js_gz_end[] asm("_binary_node_vendors_ab1d13_bundle_js_gz_end");
+extern const uint8_t _index_1a3b6c_bundle_js_gz_start[] asm("_binary_index_1a3b6c_bundle_js_gz_start");
+extern const uint8_t _index_1a3b6c_bundle_js_gz_end[] asm("_binary_index_1a3b6c_bundle_js_gz_end");
+extern const uint8_t _node_vendors_1a3b6c_bundle_js_gz_start[] asm("_binary_node_vendors_1a3b6c_bundle_js_gz_start");
+extern const uint8_t _node_vendors_1a3b6c_bundle_js_gz_end[] asm("_binary_node_vendors_1a3b6c_bundle_js_gz_end");
 const char * resource_lookups[] = {
 	"/css/index.cd56ff129e3113d8cd3a.css.gz",
 	"/favicon-32x32.png",
 	"/index.html.gz",
-	"/js/index.ab1d13.bundle.js.gz",
-	"/js/node_vendors.ab1d13.bundle.js.gz",
+	"/js/index.1a3b6c.bundle.js.gz",
+	"/js/node_vendors.1a3b6c.bundle.js.gz",
 ""
 };
 const uint8_t * resource_map_start[] = {
 	_index_cd56ff129e3113d8cd3a_css_gz_start,
 	_favicon_32x32_png_start,
 	_index_html_gz_start,
-	_index_ab1d13_bundle_js_gz_start,
-	_node_vendors_ab1d13_bundle_js_gz_start
+	_index_1a3b6c_bundle_js_gz_start,
+	_node_vendors_1a3b6c_bundle_js_gz_start
 };
 const uint8_t * resource_map_end[] = {
 	_index_cd56ff129e3113d8cd3a_css_gz_end,
 	_favicon_32x32_png_end,
 	_index_html_gz_end,
-	_index_ab1d13_bundle_js_gz_end,
-	_node_vendors_ab1d13_bundle_js_gz_end
+	_index_1a3b6c_bundle_js_gz_end,
+	_node_vendors_1a3b6c_bundle_js_gz_end
 };

components/wifi-manager/webapp/webpack.h

@@ -1,6 +1,6 @@
 /***********************************
 webpack_headers
-dist/css/index.cd56ff129e3113d8cd3a.css.gz,dist/favicon-32x32.png,dist/index.html.gz,dist/js/index.ab1d13.bundle.js.gz,dist/js/node_vendors.ab1d13.bundle.js.gz
+dist/css/index.cd56ff129e3113d8cd3a.css.gz,dist/favicon-32x32.png,dist/index.html.gz,dist/js/index.1a3b6c.bundle.js.gz,dist/js/node_vendors.1a3b6c.bundle.js.gz
 ***********************************/
 #pragma once
 #include <inttypes.h>