Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-09 13:07:03 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into httpd

Browse Source 
Conflicts:
	Makefile
	components/wifi-manager/index.html
This commit is contained in:
Sebastien
2020-02-19 08:14:49 -05:00
parent 22a1df82e1 b9de51a125
commit 2dad83e965
40 changed files with 1009 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@@ -2,3 +2,6 @@
path = components/telnet/libtelnet
url = https://github.com/seanmiddleditch/libtelnet
branch = develop
[submodule "esp-dsp"]
path = esp-dsp
url = https://github.com/philippe44/esp-dsp

2
Makefile
View File

@@ -15,7 +15,7 @@
PROJECT_NAME?=squeezelite
CPPFLAGS+= -Wno-error=maybe-uninitialized \
-I$(PROJECT_PATH)/main
EXTRA_COMPONENT_DIRS := esp-dsp
include $(IDF_PATH)/make/project.mk
# for future gcc version, this could be needed: CPPFLAGS+= -Wno-error=format-overflow -Wno-error=stringop-truncation

1
Makefile_std.mk
View File

@@ -1,2 +1,3 @@
PROJECT_NAME?= squeezelite
EXTRA_COMPONENT_DIRS := $(PROJECT_PATH)/esp-dsp
include $(IDF_PATH)/make/project.mk

6
README.md
View File

@@ -314,4 +314,10 @@ See squeezlite command line, but keys options are
- LINKALL (mandatory)
- NO_FAAD unless you want to us faad, which currently overloads the CPU
- TREMOR_ONLY (mandatory)
- When initially cloning the repo, make sure you do it recursively. For example:
- git clone --recursive https://github.com/sle118/squeezelite-esp32.git
- 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

5
build-scripts/ESP32-A1S-sdkconfig.defaults
View File

@@ -3,6 +3,11 @@
# Espressif IoT Development Framework (ESP-IDF) Project Configuration
#
# DSP
CONFIG_DSP_OPTIMIZED=y
CONFIG_DSP_OPTIMIZATION=1
CONFIG_DSP_MAX_FFT_SIZE_512=y
# ESP32-A1S defaults (with AC101 codec)
CONFIG_I2S_NUM=0
CONFIG_I2C_LOCKED=y

6
build-scripts/I2S-4MFlash-sdkconfig.defaults
View File

@@ -3,6 +3,12 @@
# Espressif IoT Development Framework (ESP-IDF) Project Configuration
#
# DSP
CONFIG_DSP_OPTIMIZED=y
CONFIG_DSP_OPTIMIZATION=1
CONFIG_DSP_MAX_FFT_SIZE_512=y
# SqueezeESP32
CONFIG_DISPLAY_CONFIG=""
CONFIG_I2C_CONFIG=""
CONFIG_SPI_CONFIG=""

6
build-scripts/NonOTA-I2S-4MFlash-sdkconfig.defaults
View File

@@ -3,6 +3,12 @@
# Espressif IoT Development Framework (ESP-IDF) Project Configuration
#
# DSP
CONFIG_DSP_OPTIMIZED=y
CONFIG_DSP_OPTIMIZATION=1
CONFIG_DSP_MAX_FFT_SIZE_512=y
# SqueezeESP32
CONFIG_DISPLAY_CONFIG=""
CONFIG_I2C_CONFIG=""
CONFIG_SPI_CONFIG=""

5
build-scripts/NonOTA-SqueezeAmp-sdkconfig.defaults
View File

@@ -3,6 +3,11 @@
# Espressif IoT Development Framework (ESP-IDF) Project Configuration
#
# DSP
CONFIG_DSP_OPTIMIZED=y
CONFIG_DSP_OPTIMIZATION=1
CONFIG_DSP_MAX_FFT_SIZE_512=y
# SqueezeAMP defaults
CONFIG_JACK_LOCKED=y
CONFIG_BAT_LOCKED=y

5
build-scripts/SqueezeAmp4MBFlash-sdkconfig.defaults
View File

@@ -3,6 +3,11 @@
# Espressif IoT Development Framework (ESP-IDF) Project Configuration
#
# DSP
CONFIG_DSP_OPTIMIZED=y
CONFIG_DSP_OPTIMIZATION=1
CONFIG_DSP_MAX_FFT_SIZE_512=y
# SqueezeAMP defaults
CONFIG_JACK_LOCKED=y
CONFIG_BAT_LOCKED=y

5
build-scripts/SqueezeAmp8MBFlash-sdkconfig.defaults
View File

@@ -3,6 +3,11 @@
# Espressif IoT Development Framework (ESP-IDF) Project Configuration
#
# DSP
CONFIG_DSP_OPTIMIZED=y
CONFIG_DSP_OPTIMIZATION=1
CONFIG_DSP_MAX_FFT_SIZE_512=y
# SqueezeAMP defaults
CONFIG_JACK_LOCKED=y
CONFIG_BAT_LOCKED=y

5
components/display/display.c
View File

@@ -117,7 +117,7 @@ static void displayer_task(void *args) {
if (displayer.state == DISPLAYER_IDLE) display->line(2, 0, DISPLAY_CLEAR | DISPLAY_UPDATE, displayer.string);
vTaskSuspend(NULL);
scroll_sleep = 0;
display->clear();
display->clear(true);
display->line(1, DISPLAY_LEFT, DISPLAY_UPDATE, displayer.header);
} else if (displayer.refresh) {
// little trick when switching master while in IDLE and missing it
@@ -301,16 +301,19 @@ void displayer_control(enum displayer_cmd_e cmd, ...) {
displayer.string[0] = '\0';
displayer.elapsed = displayer.duration = 0;
displayer.offset = displayer.boundary = 0;
display_bus(&displayer, DISPLAY_BUS_TAKE);
vTaskResume(displayer.task);
break;
}
case DISPLAYER_SUSPEND:
// task will display the line 2 from beginning and suspend
displayer.state = DISPLAYER_IDLE;
display_bus(&displayer, DISPLAY_BUS_GIVE);
break;
case DISPLAYER_SHUTDOWN:
// let the task self-suspend (we might be doing i2c_write)
displayer.state = DISPLAYER_DOWN;
display_bus(&displayer, DISPLAY_BUS_GIVE);
break;
case DISPLAYER_TIMER_RUN:
if (!displayer.timer) {

15
components/display/display.h
View File

@@ -28,6 +28,9 @@
So it can conflict with other display direct writes that have been made during
sleep. Note that if DISPLAY_SHUTDOWN has been called meanwhile, it (almost)
never happens
The display_bus() shall be subscribed by other displayers so that at least
when this one (the main) wants to take control over display, it can signal
that to others
*/
#define DISPLAY_CLEAR 0x01
@@ -51,8 +54,9 @@ enum displayer_time_e { DISPLAYER_ELAPSED, DISPLAYER_REMAINING };
// don't change anything there w/o changing all drivers init code
extern struct display_s {
int width, height;
bool dirty;
bool (*init)(char *config, char *welcome);
void (*clear)(void);
void (*clear)(bool full, ...);
bool (*set_font)(int num, enum display_font_e font, int space);
void (*on)(bool state);
void (*brightness)(uint8_t level);
@@ -60,10 +64,15 @@ extern struct display_s {
bool (*line)(int num, int x, int attribute, char *text);
int (*stretch)(int num, char *string, int max);
void (*update)(void);
void (*draw)(int x1, int y1, int x2, int y2, bool by_column, uint8_t *data);
void (*draw_cbr)(uint8_t *data, int height); // height is the # of columns in data, as oppoosed to display height (0 = display height)
void (*draw_raw)(int x1, int y1, int x2, int y2, bool by_column, bool MSb, uint8_t *data);
void (*draw_cbr)(uint8_t *data, int width, int height); // width and height is the # of rows/columns in data, as opposed to display height (0 = display width, 0 = display height)
void (*draw_line)(int x1, int y1, int x2, int y2);
void (*draw_box)( int x1, int y1, int x2, int y2, bool fill);
} *display;
enum display_bus_cmd_e { DISPLAY_BUS_TAKE, DISPLAY_BUS_GIVE };
bool (*display_bus)(void *from, enum display_bus_cmd_e cmd);
void displayer_scroll(char *string, int speed);
void displayer_control(enum displayer_cmd_e cmd, ...);
void displayer_metadata(char *artist, char *album, char *title);

161
components/display/driver_SSD13x6.c
View File

@@ -38,25 +38,26 @@ static const char *TAG = "display";
// handlers
static bool init(char *config, char *welcome);
static void clear(void);
static void clear(bool full, ...);
static bool set_font(int num, enum display_font_e font, int space);
static void text(enum display_font_e font, enum display_pos_e pos, int attribute, char *text, ...);
static bool line(int num, int x, int attribute, char *text);
static int stretch(int num, char *string, int max);
static void draw_cbr(u8_t *data, int height);
static void draw(int x1, int y1, int x2, int y2, bool by_column, u8_t *data);
static void draw_cbr(u8_t *data, int width, int height);
static void draw_raw(int x1, int y1, int x2, int y2, bool by_column, bool MSb, u8_t *data);
static void draw_line(int x1, int y1, int x2, int y2);
static void draw_box( int x1, int y1, int x2, int y2, bool fill);
static void brightness(u8_t level);
static void on(bool state);
static void update(void);
// display structure for others to use
struct display_s SSD13x6_display = { 0, 0,
struct display_s SSD13x6_display = { 0, 0, true,
init, clear, set_font, on, brightness,
text, line, stretch, update, draw, draw_cbr, NULL };
text, line, stretch, update, draw_raw, draw_cbr, draw_line, draw_box };
// SSD13x6 specific function
static struct SSD13x6_Device Display;
static SSD13x6_AddressMode AddressMode = AddressMode_Invalid;
static const unsigned char BitReverseTable256[] =
{
@@ -150,9 +151,24 @@ static bool init(char *config, char *welcome) {
/****************************************************************************************
*
*/
static void clear(void) {
static void clear(bool full, ...) {
bool commit = true;
if (full) {
SSD13x6_Clear( &Display, SSD_COLOR_BLACK );
SSD13x6_Update( &Display );
} else {
va_list args;
va_start(args, full);
commit = va_arg(args, int);
int x1 = va_arg(args, int), y1 = va_arg(args, int), x2 = va_arg(args, int), y2 = va_arg(args, int);
if (x2 < 0) x2 = display->width - 1;
if (y2 < 0) y2 = display->height - 1;
SSD13x6_ClearWindow( &Display, x1, y1, x2, y2, SSD_COLOR_BLACK );
va_end(args);
}
SSD13x6_display.dirty = true;
if (commit) update();
}
/****************************************************************************************
@@ -209,12 +225,6 @@ static bool line(int num, int x, int attribute, char *text) {
// counting 1..n
num--;
// always horizontal mode for text display
if (AddressMode != AddressMode_Horizontal) {
AddressMode = AddressMode_Horizontal;
SSD13x6_SetDisplayAddressMode( &Display, AddressMode );
}
SSD13x6_SetFont( &Display, lines[num].font );
if (attribute & DISPLAY_MONOSPACE) SSD13x6_FontForceMonospace( &Display, true );
@@ -237,7 +247,8 @@ static bool line(int num, int x, int attribute, char *text) {
ESP_LOGD(TAG, "displaying %s line %u (x:%d, attr:%u)", text, num+1, x, attribute);
// update whole display if requested
if (attribute & DISPLAY_UPDATE) SSD13x6_Update( &Display );
SSD13x6_display.dirty = true;
if (attribute & DISPLAY_UPDATE) update();
return width + x < Display.Width;
}
@@ -278,13 +289,14 @@ static int stretch(int num, char *string, int max) {
static void text(enum display_font_e font, enum display_pos_e pos, int attribute, char *text, ...) {
va_list args;
va_start(args, text);
TextAnchor Anchor = TextAnchor_Center;
if (attribute & DISPLAY_CLEAR) SSD13x6_Clear( &Display, SSD_COLOR_BLACK );
if (!text) return;
va_start(args, text);
switch(font) {
case DISPLAY_FONT_LINE_1:
SSD13x6_SetFont( &Display, &Font_line_1 );
@@ -327,113 +339,56 @@ static void text(enum display_font_e font, enum display_pos_e pos, int attribute
ESP_LOGD(TAG, "SSDD13x6 displaying %s at %u with attribute %u", text, Anchor, attribute);
if (AddressMode != AddressMode_Horizontal) {
AddressMode = AddressMode_Horizontal;
SSD13x6_SetDisplayAddressMode( &Display, AddressMode );
}
SSD13x6_FontDrawAnchoredString( &Display, Anchor, text, SSD_COLOR_WHITE );
if (attribute & DISPLAY_UPDATE) SSD13x6_Update( &Display );
SSD13x6_display.dirty = true;
if (attribute & DISPLAY_UPDATE) update();
va_end(args);
}
/****************************************************************************************
* Process graphic display data from column-oriented bytes, MSbit first
* Process graphic display data from column-oriented data (MSbit first)
*/
static void draw_cbr(u8_t *data, int height) {
#ifndef FULL_REFRESH
// force addressing mode by rows
if (AddressMode != AddressMode_Horizontal) {
AddressMode = AddressMode_Horizontal;
SSD13x6_SetDisplayAddressMode( &Display, AddressMode );
}
static void draw_cbr(u8_t *data, int width, int height) {
if (!height) height = Display.Height;
if (!width) width = Display.Width;
// try to minimize I2C traffic which is very slow
int rows = (height ? height : Display.Height) / 8;
for (int r = 0; r < rows; r++) {
uint8_t first = 0, last;
uint8_t *optr = Display.Framebuffer + r*Display.Width, *iptr = data + r;
// row/col swap, frame buffer comparison and bit-reversing
for (int c = 0; c < Display.Width; c++) {
u8_t byte = BitReverseTable256[*iptr];
if (byte != *optr) {
if (!first) first = c + 1;
last = c ;
}
*optr++ = byte;
iptr += rows;
}
// now update the display by "byte rows"
if (first--) {
SSD13x6_SetColumnAddress( &Display, first, last );
SSD13x6_SetPageAddress( &Display, r, r);
SSD13x6_WriteRawData( &Display, Display.Framebuffer + r*Display.Width + first, last - first + 1);
}
}
#else
if (!height) height = Display->Height;
SSD13x6_SetPageAddress( &Display, 0, height / 8 - 1);
// force addressing mode by columns (if we can)
if (SSD13x6_GetCaps( &Display ) & CAPS_ADDRESS_VERTICAL) {
// just copy data in frame buffer with bit-reverse
for (int c = 0; c < Display.Width; c++)
for (int r = 0; r < height / 8; r++)
Display.Framebuffer[c*Display.Height/8 + r] = BitReverseTable256[data[c*height/8 +r]];
if (AddressMode != AddressMode_Vertical) {
AddressMode = AddressMode_Vertical;
SSD13x6_SetDisplayAddressMode( &Display, AddressMode );
}
} else {
// need to do rwo/col swap and bit-reverse
int rows = (height ? height : Display.Height) / 8;
// need to do row/col swap and bit-reverse
int rows = height / 8;
for (int r = 0; r < rows; r++) {
uint8_t *optr = Display.Framebuffer + r*Display.Width, *iptr = data + r;
for (int c = 0; c < Display.Width; c++) {
for (int c = width; --c >= 0;) {
*optr++ = BitReverseTable256[*iptr];;
iptr += rows;
}
}
ESP_LOGW(TAG, "Can't set addressing mode to vertical, swapping");
}
SSD13x6_WriteRawData(&Display, Display.Framebuffer, Display.Width * Display.Height/8);
#endif
SSD13x6_display.dirty = true;
}
/****************************************************************************************
* Process graphic display data MSBit first
* WARNING: this has not been tested yet
*/
static void draw(int x1, int y1, int x2, int y2, bool by_column, u8_t *data) {
if (y1 % 8 || y2 % 8) {
ESP_LOGW(TAG, "must write rows on byte boundaries (%u,%u) to (%u,%u)", x1, y1, x2, y2);
return;
}
static void draw_raw(int x1, int y1, int x2, int y2, bool by_column, bool MSb, u8_t *data) {
// default end point to display size
if (x2 == -1) x2 = Display.Width - 1;
if (y2 == -1) y2 = Display.Height - 1;
display->dirty = true;
// not a boundary draw
if (y1 % 8 || y2 % 8 || x1 % 8 | x2 % 8) {
ESP_LOGW(TAG, "can't write on non cols/rows boundaries for now");
} else {
// set addressing mode to match data
if (by_column) {
if (AddressMode != AddressMode_Vertical) {
AddressMode = AddressMode_Vertical;
SSD13x6_SetDisplayAddressMode( &Display, AddressMode );
}
// copy the window and do row/col exchange
for (int r = y1/8; r <= y2/8; r++) {
uint8_t *optr = Display.Framebuffer + r*Display.Width + x1, *iptr = data + r;
for (int c = x1; c <= x2; c++) {
*optr++ = *iptr;
*optr++ = MSb ? BitReverseTable256[*iptr] : *iptr;
iptr += (y2-y1)/8 + 1;
}
}
@@ -444,10 +399,23 @@ static void draw(int x1, int y1, int x2, int y2, bool by_column, u8_t *data) {
for (int c = x1; c <= x2; c++) *optr++ = *iptr++;
}
}
}
}
SSD13x6_SetColumnAddress( &Display, x1, x2);
SSD13x6_SetPageAddress( &Display, y1/8, y2/8);
SSD13x6_WriteRawData( &Display, data, (x2-x1 + 1) * ((y2-y1)/8 + 1));
/****************************************************************************************
* Draw line
*/
static void draw_line( int x1, int y1, int x2, int y2) {
SSD13x6_DrawLine( &Display, x1, y1, x2, y2, SSD_COLOR_WHITE );
SSD13x6_display.dirty = true;
}
/****************************************************************************************
* Draw Box
*/
static void draw_box( int x1, int y1, int x2, int y2, bool fill) {
SSD13x6_DrawBox( &Display, x1, y1, x2, y2, SSD_COLOR_WHITE, fill );
SSD13x6_display.dirty = true;
}
/****************************************************************************************
@@ -470,7 +438,8 @@ static void on(bool state) {
* Update
*/
static void update(void) {
SSD13x6_Update( &Display );
if (SSD13x6_display.dirty) SSD13x6_Update( &Display );
SSD13x6_display.dirty = false;
}

38
components/display/tarablessd13x6/ssd13x6.c
View File

@@ -15,6 +15,8 @@
#include "ssd13x6.h"
#define SHADOW_BUFFER
// used by both but different
static uint8_t SSDCmd_Set_Display_Start_Line;
static uint8_t SSDCmd_Set_Display_Offset;
@@ -111,8 +113,32 @@ void SSD13x6_SetDisplayAddressMode( struct SSD13x6_Device* DeviceHandle, SSD13x6
}
void SSD13x6_Update( struct SSD13x6_Device* DeviceHandle ) {
#ifdef SHADOW_BUFFER
// not sure the compiler does not have to redo all calculation in for loops, so local it is
int width = DeviceHandle->Width, rows = DeviceHandle->Height / 8;
uint8_t *optr = DeviceHandle->Shadowbuffer, *iptr = DeviceHandle->Framebuffer;
// by row, find first and last columns that have been updated
for (int r = 0; r < rows; r++) {
uint8_t first = 0, last;
for (int c = 0; c < width; c++) {
if (*iptr != *optr) {
if (!first) first = c + 1;
last = c ;
}
*optr++ = *iptr++;
}
// now update the display by "byte rows"
if (first--) {
SSD13x6_SetColumnAddress( DeviceHandle, first, last );
SSD13x6_SetPageAddress( DeviceHandle, r, r);
SSD13x6_WriteData( DeviceHandle, DeviceHandle->Shadowbuffer + r*width + first, last - first + 1);
}
}
#else
if (DeviceHandle->Model == SH1106) {
// SH1106 requires a page-by-page update and ahs no end Page/Column
// SH1106 requires a page-by-page update and has no end Page/Column
for (int i = 0; i < DeviceHandle->Height / 8 ; i++) {
SSD13x6_SetPageAddress( DeviceHandle, i, 0);
SSD13x6_SetColumnAddress( DeviceHandle, 0, 0);
@@ -124,6 +150,7 @@ void SSD13x6_Update( struct SSD13x6_Device* DeviceHandle ) {
SSD13x6_SetPageAddress( DeviceHandle, 0, DeviceHandle->Height / 8 - 1);
SSD13x6_WriteData( DeviceHandle, DeviceHandle->Framebuffer, DeviceHandle->FramebufferSize );
}
#endif
}
void SSD13x6_WriteRawData( struct SSD13x6_Device* DeviceHandle, uint8_t* Data, size_t DataLength ) {
@@ -214,6 +241,11 @@ static bool SSD13x6_Init( struct SSD13x6_Device* DeviceHandle, int Width, int He
DeviceHandle->Width = Width;
DeviceHandle->Height = Height;
#ifdef SHADOW_BUFFER
DeviceHandle->Shadowbuffer = heap_caps_malloc( DeviceHandle->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
memset( DeviceHandle->Shadowbuffer, 0xFF, DeviceHandle->FramebufferSize );
#endif
SSD13x6_HWReset( DeviceHandle );
SSD13x6_DisplayOff( DeviceHandle );
@@ -308,7 +340,11 @@ bool SSD13x6_Init_SPI( struct SSD13x6_Device* DeviceHandle, int Width, int Heigh
DeviceHandle->CSPin = CSPin;
DeviceHandle->FramebufferSize = ( Width * Height ) / 8;
#ifdef SHADOW_BUFFER
DeviceHandle->Framebuffer = calloc( 1, DeviceHandle->FramebufferSize );
#else
DeviceHandle->Framebuffer = heap_caps_calloc( 1, DeviceHandle->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
#endif
NullCheck( DeviceHandle->Framebuffer, return false );
return SSD13x6_Init( DeviceHandle, Width, Height );

2
components/display/tarablessd13x6/ssd13x6.h
View File

@@ -58,7 +58,7 @@ struct SSD13x6_Device {
enum { SSD1306, SSD1326, SH1106 } Model;
uint8_t ReMap;
uint8_t* Framebuffer;
uint8_t* Framebuffer, *Shadowbuffer;
int FramebufferSize;
WriteCommandProc WriteCommand;

38
components/display/tarablessd13x6/ssd13x6_draw.c
View File

@@ -16,6 +16,9 @@
#include "ssd13x6.h"
#include "ssd13x6_draw.h"
#undef NullCheck
#define NullCheck(X,Y)
__attribute__( ( always_inline ) ) static inline bool IsPixelVisible( struct SSD13x6_Device* DeviceHandle, int x, int y ) {
bool Result = (
( x >= 0 ) &&
@@ -75,7 +78,7 @@ void IRAM_ATTR SSD13x6_DrawHLine( struct SSD13x6_Device* DeviceHandle, int x, in
NullCheck( DeviceHandle, return );
NullCheck( DeviceHandle->Framebuffer, return );
for ( ; x <= XEnd; x++ ) {
for ( ; x < XEnd; x++ ) {
if ( IsPixelVisible( DeviceHandle, x, y ) == true ) {
SSD13x6_DrawPixelFast( DeviceHandle, x, y, Color );
} else {
@@ -90,7 +93,7 @@ void IRAM_ATTR SSD13x6_DrawVLine( struct SSD13x6_Device* DeviceHandle, int x, in
NullCheck( DeviceHandle, return );
NullCheck( DeviceHandle->Framebuffer, return );
for ( ; y <= YEnd; y++ ) {
for ( ; y < YEnd; y++ ) {
if ( IsPixelVisible( DeviceHandle, x, y ) == true ) {
SSD13x6_DrawPixel( DeviceHandle, x, y, Color );
} else {
@@ -114,7 +117,7 @@ static inline void IRAM_ATTR DrawWideLine( struct SSD13x6_Device* DeviceHandle,
Error = ( dy * 2 ) - dx;
for ( ; x <= x1; x++ ) {
for ( ; x < x1; x++ ) {
if ( IsPixelVisible( DeviceHandle, x, y ) == true ) {
SSD13x6_DrawPixelFast( DeviceHandle, x, y, Color );
}
@@ -219,3 +222,32 @@ void SSD13x6_Clear( struct SSD13x6_Device* DeviceHandle, int Color ) {
memset( DeviceHandle->Framebuffer, Color, DeviceHandle->FramebufferSize );
}
void SSD13x6_ClearWindow( struct SSD13x6_Device* DeviceHandle, int x1, int y1, int x2, int y2, int Color ) {
NullCheck( DeviceHandle, return );
NullCheck( DeviceHandle->Framebuffer, return );
/*
int xr = ((x1 - 1) / 8) + 1 ) * 8;
int xl = (x2 / 8) * 8;
for (int y = y1; y <= y2; y++) {
for (int x = x1; x < xr; x++) SSD13x6_DrawPixelFast( DeviceHandle, x, y, Color);
if (xl > xr) memset( DeviceHandle->Framebuffer + (y / 8) * DeviceHandle->Width + xr, 0, xl - xr );
for (int x = xl; x <= x2; x++) SSD13x6_DrawPixelFast( DeviceHandle, x, y, Color);
}
return;
*/
// cheap optimization on boundaries
if (x1 == 0 && x2 == DeviceHandle->Width - 1 && y1 % 8 == 0 && (y2 + 1) % 8 == 0) {
memset( DeviceHandle->Framebuffer + (y1 / 8) * DeviceHandle->Width, 0, (y2 - y1 + 1) / 8 * DeviceHandle->Width );
} else {
for (int y = y1; y <= y2; y++) {
for (int x = x1; x <= x2; x++) {
SSD13x6_DrawPixelFast( DeviceHandle, x, y, Color);
}
}
}
}

1
components/display/tarablessd13x6/ssd13x6_draw.h
View File

@@ -39,6 +39,7 @@ extern "C" {
#define SSD_COLOR_XOR 2
void SSD13x6_Clear( struct SSD13x6_Device* DeviceHandle, int Color );
void SSD13x6_ClearWindow( struct SSD13x6_Device* DeviceHandle, int x1, int y1, int x2, int y2, int Color );
void SSD13x6_DrawPixel( struct SSD13x6_Device* DeviceHandle, int X, int Y, int Color );
void SSD13x6_DrawPixelFast( struct SSD13x6_Device* DeviceHandle, int X, int Y, int Color );
void SSD13x6_DrawHLine( struct SSD13x6_Device* DeviceHandle, int x, int y, int Width, int Color );

92
components/raop/raop.c
View File

@@ -55,7 +55,7 @@ typedef struct raop_ctx_s {
short unsigned port; // RTSP port for AirPlay
int sock; // socket of the above
struct in_addr peer; // IP of the iDevice (airplay sender)
bool running;
bool running, abort;
#ifdef WIN32
pthread_t thread, search_thread;
#else
@@ -83,6 +83,7 @@ typedef struct raop_ctx_s {
TaskHandle_t thread, joiner;
StaticTask_t *xTaskBuffer;
StackType_t xStack[SEARCH_STACK_SIZE] __attribute__ ((aligned (4)));;
SemaphoreHandle_t destroy_mutex;
#endif
} active_remote;
void *owner;
@@ -93,6 +94,7 @@ extern log_level raop_loglevel;
static log_level *loglevel = &raop_loglevel;
static void* rtsp_thread(void *arg);
static void abort_rtsp(raop_ctx_t *ctx);
static bool handle_rtsp(raop_ctx_t *ctx, int sock);
static char* rsa_apply(unsigned char *input, int inlen, int *outlen, int mode);
@@ -198,6 +200,12 @@ struct raop_ctx_s *raop_create(struct in_addr host, char *name,
ESP_ERROR_CHECK( mdns_service_add(id, "_raop", "_tcp", ctx->port, txt, sizeof(txt) / sizeof(mdns_txt_item_t)) );
ctx->xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
ctx->thread = xTaskCreateStatic( (TaskFunction_t) rtsp_thread, "RTSP_thread", RTSP_STACK_SIZE, ctx, ESP_TASK_PRIO_MIN + 1, ctx->xStack, ctx->xTaskBuffer);
#endif
return ctx;
}
/*----------------------------------------------------------------------------*/
void raop_abort(struct raop_ctx_s *ctx) {
LOG_INFO("[%p]: aborting RTSP session at next select() wakeup", ctx);
@@ -270,7 +278,7 @@ if (!ctx) return;
NFREE(ctx->rtsp.aeskey);
NFREE(ctx->rtsp.aesiv);
NFREE(ctx->rtsp.fmtp);
NFREE(ctx->rtsp.fmtp);
free(ctx);
}
@@ -323,7 +331,7 @@ void raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
break;
}
default:
break;
break;
}
// no command to send to remote or no remote found yet
@@ -354,6 +362,8 @@ void raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
LOG_INFO("[%p]: sending airplay remote\n%s<== received ==>\n%s", ctx, buf, resp);
NFREE(method);
NFREE(buf);
kd_free(headers);
}
free(command);
@@ -373,6 +383,7 @@ static void *rtsp_thread(void *arg) {
int n;
bool res = false;
if (sock == -1) {
struct sockaddr_in peer;
socklen_t addrlen = sizeof(struct sockaddr_in);
@@ -384,11 +395,12 @@ static void *rtsp_thread(void *arg) {
LOG_INFO("got RTSP connection %u", sock);
} else continue;
}
FD_ZERO(&rfds);
FD_SET(sock, &rfds);
n = select(sock + 1, &rfds, NULL, NULL, &timeout);
n = select(sock + 1, &rfds, NULL, NULL, &timeout);
if (!n && !ctx->abort) continue;
if (n > 0) res = handle_rtsp(ctx, sock);
@@ -461,27 +473,6 @@ static bool handle_rtsp(raop_ctx_t *ctx, int sock)
kd_add(resp, "Public", "ANNOUNCE, SETUP, RECORD, PAUSE, FLUSH, TEARDOWN, OPTIONS, GET_PARAMETER, SET_PARAMETER");
} else if (!strcmp(method, "ANNOUNCE")) {
char *padded, *p;
NFREE(ctx->rtsp.aeskey);
NFREE(ctx->rtsp.aesiv);
NFREE(ctx->rtsp.fmtp);
// LMS might has taken over the player, leaving us with a running RTP session (should not happen)
if (ctx->rtp) {
LOG_WARN("[%p]: closing unfinished RTP session", ctx);
rtp_end(ctx->rtp);
}
// same, should not happen unless we have missed a teardown ...
if (ctx->active_remote.running) {
ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
ctx->active_remote.running = false;
vTaskResume(ctx->active_remote.thread);
ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
vTaskDelete(ctx->active_remote.thread);
char *padded, *p;
NFREE(ctx->rtsp.aeskey);
@@ -522,6 +513,7 @@ static bool handle_rtsp(raop_ctx_t *ctx, int sock)
// on announce, search remote
if ((buf = kd_lookup(headers, "DACP-ID")) != NULL) strcpy(ctx->active_remote.DACPid, buf);
if ((buf = kd_lookup(headers, "Active-Remote")) != NULL) strcpy(ctx->active_remote.id, buf);
#ifdef WIN32
ctx->active_remote.handle = init_mDNS(false, ctx->host);
pthread_create(&ctx->search_thread, NULL, &search_remote, ctx);
@@ -600,10 +592,9 @@ static bool handle_rtsp(raop_ctx_t *ctx, int sock)
// need to make sure no search is on-going and reclaim pthread memory
#ifdef WIN32
if (ctx->active_remote.handle) close_mDNS(ctx->active_remote.handle);
pthread_join(ctx->search_thread, NULL);
#else
if (ctx->active_remote.handle) close_mDNS(ctx->active_remote.handle);
pthread_join(ctx->search_thread, NULL);
#else
ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
ctx->active_remote.running = false;
@@ -681,6 +672,35 @@ static bool handle_rtsp(raop_ctx_t *ctx, int sock)
NFREE(body);
NFREE(buf);
kd_free(resp);
kd_free(headers);
return true;
}
/*----------------------------------------------------------------------------*/
void abort_rtsp(raop_ctx_t *ctx) {
// first stop RTP process
if (ctx->rtp) {
rtp_end(ctx->rtp);
ctx->rtp = NULL;
LOG_INFO("[%p]: RTP thread aborted", ctx);
}
if (ctx->active_remote.running) {
// need to make sure no search is on-going and reclaim task memory
ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
ctx->active_remote.running = false;
xSemaphoreTake(ctx->active_remote.destroy_mutex, portMAX_DELAY);
vTaskDelete(ctx->active_remote.thread);
vSemaphoreDelete(ctx->active_remote.thread);
heap_caps_free(ctx->active_remote.xTaskBuffer);
memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
LOG_INFO("[%p]: Remote search thread aborted", ctx);
}
NFREE(ctx->rtsp.aeskey);
NFREE(ctx->rtsp.aesiv);
@@ -746,18 +766,8 @@ static void* search_remote(void *args) {
ctx->active_remote.host.s_addr = a->addr.u_addr.ip4.addr;
ctx->active_remote.port = r->port;
LOG_INFO("found remote %s %s:%hu", r->instance_name, inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
}
}
mdns_query_results_free(results);
}
/*
for some reason which is beyond me, if that tasks gives the semaphore
before the RTSP tasks waits for it, then freeRTOS crashes in queue
management caused by LWIP stack once the RTSP socket is closed. I have
no clue why, but so we'll suspend the tasks as soon as we're done with
search and wait for the resume then give the semaphore
}
}
mdns_query_results_free(results);
}

3
components/raop/raop.h
View File

@@ -27,6 +27,7 @@
struct raop_ctx_s* raop_create(struct in_addr host, char *name, unsigned char mac[6], int latency,
raop_cmd_cb_t cmd_cb, raop_data_cb_t data_cb);
void raop_delete(struct raop_ctx_s *ctx);
void raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param);
void raop_abort(struct raop_ctx_s *ctx);
bool raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param);
#endif

3
components/raop/raop_sink.c
View File

@@ -178,6 +178,7 @@ void raop_sink_init(raop_cmd_vcb_t cmd_cb, raop_data_cb_t data_cb) {
void raop_disconnect(void) {
LOG_INFO("forced disconnection");
displayer_control(DISPLAYER_SHUTDOWN);
raop_cmd(raop, RAOP_STOP, NULL);
// in case we can't communicate with AirPlay controller, abort session
if (!raop_cmd(raop, RAOP_STOP, NULL)) raop_abort(raop);
actrls_unset();
}

6
components/services/monitor.c
View File

@@ -146,4 +146,10 @@ void monitor_svc_init(void) {
xTimerStart(monitor_timer, portMAX_DELAY);
}
free(p);
ESP_LOGI(TAG, "Heap internal:%zu (min:%zu) external:%zu (min:%zu)",
heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL),
heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM));
}

18
components/squeezelite/decode_external.c
View File

@@ -46,7 +46,7 @@ static bool enable_airplay;
#define SYNC_NB 5
static raop_event_t raop_state;
static bool raop_expect_stop = false;
static struct {
bool enabled, start;
s32_t error[SYNC_NB];
@@ -123,9 +123,8 @@ static bool bt_sink_cmd_handler(bt_sink_cmd_t cmd, va_list args)
LOG_INFO("BT sink started");
break;
case BT_SINK_AUDIO_STOPPED:
// do we still need that?
if (output.external == DECODE_BT) {
output.state = OUTPUT_OFF;
if (output.state > OUTPUT_STOPPED) output.state = OUTPUT_STOPPED;
LOG_INFO("BT sink stopped");
}
break;
@@ -136,6 +135,7 @@ static bool bt_sink_cmd_handler(bt_sink_cmd_t cmd, va_list args)
case BT_SINK_STOP:
_buf_flush(outputbuf);
output.state = OUTPUT_STOPPED;
output.stop_time = gettime_ms();
LOG_INFO("BT sink stopped");
break;
case BT_SINK_PAUSE:
@@ -253,18 +253,14 @@ static bool raop_sink_cmd_handler(raop_event_t event, va_list args)
output.next_sample_rate = output.current_sample_rate = RAOP_SAMPLE_RATE;
break;
case RAOP_STOP:
LOG_INFO("Stop", NULL);
output.state = OUTPUT_OFF;
output.frames_played = 0;
raop_state = event;
break;
case RAOP_FLUSH:
LOG_INFO("Flush", NULL);
raop_expect_stop = true;
if (event == RAOP_FLUSH) { LOG_INFO("Flush", NULL); }
else { LOG_INFO("Stop", NULL); }
raop_state = event;
_buf_flush(outputbuf);
output.state = OUTPUT_STOPPED;
if (output.state > OUTPUT_STOPPED) output.state = OUTPUT_STOPPED;
output.frames_played = 0;
output.stop_time = gettime_ms();
break;
case RAOP_PLAY: {
LOG_INFO("Play", NULL);

547
components/squeezelite/display.c
View File

@@ -18,6 +18,8 @@
*/
#include <ctype.h>
#include <math.h>
#include "esp_dsp.h"
#include "squeezelite.h"
#include "slimproto.h"
#include "display.h"
@@ -54,6 +56,27 @@ struct grfg_packet {
u16_t width; // # of pixels of scrollable
};
struct visu_packet {
char opcode[4];
u8_t which;
u8_t count;
union {
struct {
u32_t bars;
u32_t spectrum_scale;
} full;
struct {
u32_t width;
u32_t height;
s32_t col;
s32_t row;
u32_t border;
u32_t bars;
u32_t spectrum_scale;
};
};
};
struct ANIC_header {
char opcode[4];
u32_t length;
@@ -64,20 +87,62 @@ struct ANIC_header {
extern struct outputstate output;
static struct {
TaskHandle_t task;
SemaphoreHandle_t mutex;
int width, height;
bool dirty;
bool owned;
} displayer = { .dirty = true, .owned = true };
#define LONG_WAKE (10*1000)
#define SB_HEIGHT 32
// lenght are number of frames, i.e. 2 channels of 16 bits
#define FFT_LEN_BIT 6
#define FFT_LEN (1 << FFT_LEN_BIT)
#define RMS_LEN_BIT 6
#define RMS_LEN (1 << RMS_LEN_BIT)
#define DISPLAY_BW 20000
static struct scroller_s {
// copy of grfs content
u8_t screen, direction;
u8_t screen;
u32_t pause, speed;
u16_t by, mode, full_width, window_width;
u16_t max, size;
int wake;
u16_t mode;
s16_t by;
// scroller management & sharing between grfg and scrolling task
TaskHandle_t task;
u8_t *scroll_frame, *back_frame;
bool active, updated;
u8_t *scroll_ptr;
int scroll_len, scroll_step;
bool active, first;
int scrolled;
struct {
u8_t *frame;
u32_t width;
u32_t max, size;
} scroll;
struct {
u8_t *frame;
u32_t width;
} back;
u8_t *frame;
u32_t width;
} scroller;
#define MAX_BARS 32
static EXT_RAM_ATTR struct {
int bar_gap, bar_width, bar_border;
struct {
int current, max;
int limit;
} bars[MAX_BARS];
float spectrum_scale;
int n, col, row, height, width, border;
enum { VISU_BLANK, VISU_VUMETER, VISU_SPECTRUM, VISU_WAVEFORM } mode;
int speed, wake;
float fft[FFT_LEN*2], samples[FFT_LEN*2], hanning[FFT_LEN];
} visu;
#define ANIM_NONE 0x00
#define ANIM_TRANSITION 0x01 // A transition animation has finished
#define ANIM_SCROLL_ONCE 0x02
@@ -91,23 +156,27 @@ static u8_t SETD_width;
#define LINELEN 40
static log_level loglevel = lINFO;
static SemaphoreHandle_t display_mutex;
static bool (*slimp_handler_chain)(u8_t *data, int len);
static void (*slimp_loop_chain)(void);
static void (*notify_chain)(in_addr_t ip, u16_t hport, u16_t cport);
static int display_width, display_height;
static bool (*display_bus_chain)(void *from, enum display_bus_cmd_e cmd);
#define max(a,b) (((a) > (b)) ? (a) : (b))
static void server(in_addr_t ip, u16_t hport, u16_t cport);
static void send_server(void);
static bool handler(u8_t *data, int len);
static bool display_bus_handler(void *from, enum display_bus_cmd_e cmd);
static void vfdc_handler( u8_t *_data, int bytes_read);
static void grfe_handler( u8_t *data, int len);
static void grfb_handler(u8_t *data, int len);
static void grfs_handler(u8_t *data, int len);
static void grfg_handler(u8_t *data, int len);
static void scroll_task(void* arg);
static void visu_handler(u8_t *data, int len);
static void displayer_task(void* arg);
/* scrolling undocumented information
grfs
@@ -150,18 +219,25 @@ bool sb_display_init(void) {
}
// need to force height to 32 maximum
display_width = display->width;
display_height = min(display->height, 32);
displayer.width = display->width;
displayer.height = min(display->height, SB_HEIGHT);
SETD_width = display->width;
// create visu configuration
visu.bar_gap = 1;
visu.speed = 100;
dsps_fft2r_init_fc32(visu.fft, FFT_LEN);
dsps_wind_hann_f32(visu.hanning, FFT_LEN);
// create scroll management task
display_mutex = xSemaphoreCreateMutex();
scroller.task = xTaskCreateStatic( (TaskFunction_t) scroll_task, "scroll_thread", SCROLL_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
displayer.mutex = xSemaphoreCreateMutex();
displayer.task = xTaskCreateStatic( (TaskFunction_t) displayer_task, "displayer_thread", SCROLL_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
// size scroller
scroller.max = (display_width * display_height / 8) * 10;
scroller.scroll_frame = malloc(scroller.max);
scroller.back_frame = malloc(display_width * display_height / 8);
scroller.scroll.max = (displayer.width * displayer.height / 8) * 10;
scroller.scroll.frame = malloc(scroller.scroll.max);
scroller.back.frame = malloc(displayer.width * displayer.height / 8);
scroller.frame = malloc(displayer.width * displayer.height / 8);
// chain handlers
slimp_handler_chain = slimp_handler;
@@ -173,9 +249,39 @@ bool sb_display_init(void) {
notify_chain = server_notify;
server_notify = server;
display_bus_chain = display_bus;
display_bus = display_bus_handler;
return true;
}
/****************************************************************************************
* Receive display bus commands
*/
static bool display_bus_handler(void *from, enum display_bus_cmd_e cmd) {
// don't answer to own requests
if (from == &displayer) return false ;
LOG_INFO("Display bus command %d", cmd);
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
switch (cmd) {
case DISPLAY_BUS_TAKE:
displayer.owned = false;
break;
case DISPLAY_BUS_GIVE:
displayer.owned = true;
break;
}
xSemaphoreGive(displayer.mutex);
if (display_bus_chain) return (*display_bus_chain)(from, cmd);
else return true;
}
/****************************************************************************************
* Send message to server (ANIC at that time)
*/
@@ -224,7 +330,9 @@ static void send_server(void) {
static void server(in_addr_t ip, u16_t hport, u16_t cport) {
char msg[32];
sprintf(msg, "%s:%hu", inet_ntoa(ip), hport);
display->text(DISPLAY_FONT_DEFAULT, DISPLAY_CENTERED, DISPLAY_CLEAR | DISPLAY_UPDATE, msg);
if (displayer.owned) display->text(DISPLAY_FONT_DEFAULT, DISPLAY_CENTERED, DISPLAY_CLEAR | DISPLAY_UPDATE, msg);
SETD_width = display->width;
displayer.dirty = true;
if (notify_chain) (*notify_chain)(ip, hport, cport);
}
@@ -234,8 +342,6 @@ static void server(in_addr_t ip, u16_t hport, u16_t cport) {
static bool handler(u8_t *data, int len){
bool res = true;
// don't do anything if we dont own the display (no lock needed)
if (!output.external || output.state < OUTPUT_STOPPED) {
if (!strncmp((char*) data, "vfdc", 4)) {
vfdc_handler(data, len);
} else if (!strncmp((char*) data, "grfe", 4)) {
@@ -246,10 +352,11 @@ static bool handler(u8_t *data, int len){
grfs_handler(data, len);
} else if (!strncmp((char*) data, "grfg", 4)) {
grfg_handler(data, len);
} else if (!strncmp((char*) data, "visu", 4)) {
visu_handler(data, len);
} else {
res = false;
}
}
// chain protocol handlers (bitwise or is fine)
if (*slimp_handler_chain) res |= (*slimp_handler_chain)(data, len);
@@ -374,12 +481,30 @@ static void vfdc_handler( u8_t *_data, int bytes_read) {
* Process graphic display data
*/
static void grfe_handler( u8_t *data, int len) {
xSemaphoreTake(display_mutex, portMAX_DELAY);
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
scroller.active = false;
display->draw_cbr(data + sizeof(struct grfe_packet), display_height);
xSemaphoreGive(display_mutex);
// we are not in control or we are displaying visu on a small screen, do not do screen update
if (visu.mode && !visu.col && visu.row < SB_HEIGHT) {
xSemaphoreGive(displayer.mutex);
return;
}
if (displayer.owned) {
// did we have something that might have write on the bottom of a SB_HEIGHT+ display
if (displayer.dirty) {
display->clear(true);
displayer.dirty = false;
}
// draw new frame
display->draw_cbr(data + sizeof(struct grfe_packet), displayer.width, displayer.height);
display->update();
}
xSemaphoreGive(displayer.mutex);
LOG_DEBUG("grfe frame %u", len);
}
@@ -416,35 +541,45 @@ static void grfs_handler(u8_t *data, int len) {
htonl(pkt->speed), // in ms
htons(pkt->by), // # of pixel of scroll step
htons(pkt->mode), // 0=continuous, 1=once and stop, 2=once and end
htons(pkt->width), // total width of animation
htons(pkt->width), // last column of animation that contains a "full" screen
htons(pkt->offset) // offset if multiple packets are sent
);
// new grfs frame, build scroller info
if (!offset) {
// use the display as a general lock
xSemaphoreTake(display_mutex, portMAX_DELAY);
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
// copy & set scroll parameters
scroller.screen = pkt->screen;
scroller.direction = pkt->direction;
scroller.pause = htonl(pkt->pause);
scroller.speed = htonl(pkt->speed);
scroller.by = htons(pkt->by);
scroller.mode = htons(pkt->mode);
scroller.full_width = htons(pkt->width);
scroller.updated = scroller.active = true;
scroller.scroll.width = htons(pkt->width);
scroller.first = true;
xSemaphoreGive(display_mutex);
// background excludes space taken by visu (if any)
scroller.back.width = displayer.width - ((visu.mode && visu.row < SB_HEIGHT) ? visu.width : 0);
// set scroller steps & beginning
if (pkt->direction == 1) {
scroller.scrolled = 0;
scroller.by = htons(pkt->by);
} else {
scroller.scrolled = scroller.scroll.width;
scroller.by = -htons(pkt->by);
}
xSemaphoreGive(displayer.mutex);
}
// copy scroll frame data (no semaphore needed)
if (scroller.size + size < scroller.max) {
memcpy(scroller.scroll_frame + offset, data + sizeof(struct grfs_packet), size);
scroller.size = offset + size;
LOG_INFO("scroller current size %u", scroller.size);
if (scroller.scroll.size + size < scroller.scroll.max) {
memcpy(scroller.scroll.frame + offset, data + sizeof(struct grfs_packet), size);
scroller.scroll.size = offset + size;
LOG_INFO("scroller current size %u", scroller.scroll.size);
} else {
LOG_INFO("scroller too larger %u/%u", scroller.size + size, scroller.max);
LOG_INFO("scroller too larger %u/%u", scroller.scroll.size + size, scroller.scroll.max);
}
}
@@ -456,110 +591,310 @@ static void grfg_handler(u8_t *data, int len) {
LOG_DEBUG("gfrg s:%hu w:%hu (len:%u)", htons(pkt->screen), htons(pkt->width), len);
memcpy(scroller.back_frame, data + sizeof(struct grfg_packet), len - sizeof(struct grfg_packet));
scroller.window_width = htons(pkt->width);
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
xSemaphoreTake(display_mutex, portMAX_DELAY);
// size of scrollable area (less than background)
scroller.width = htons(pkt->width);
memcpy(scroller.back.frame, data + sizeof(struct grfg_packet), len - sizeof(struct grfg_packet));
// can't be in grfs as we need full size & scroll_width
if (scroller.updated) {
scroller.scroll_len = display_width * display_height / 8 - (display_width - scroller.window_width) * display_height / 8;
if (scroller.direction == 1) {
scroller.scroll_ptr = scroller.scroll_frame;
scroller.scroll_step = scroller.by * display_height / 8;
} else {
scroller.scroll_ptr = scroller.scroll_frame + scroller.size - scroller.scroll_len;
scroller.scroll_step = -scroller.by * display_height / 8;
// update display asynchronously (frames are oganized by columns)
memcpy(scroller.frame, scroller.back.frame, scroller.back.width * displayer.height / 8);
for (int i = 0; i < scroller.width * displayer.height / 8; i++) scroller.frame[i] |= scroller.scroll.frame[scroller.scrolled * displayer.height / 8 + i];
// can only write if we really own display
if (displayer.owned) {
display->draw_cbr(scroller.frame, scroller.back.width, displayer.height);
display->update();
}
scroller.updated = false;
}
// now we can active scrolling, but only if we are not on a small screen
if (!visu.mode || visu.col || visu.row >= SB_HEIGHT) scroller.active = true;
if (!scroller.active) {
// this is a background update and scroller has been finished, so need to update here
u8_t *frame = malloc(display_width * display_height / 8);
memcpy(frame, scroller.back_frame, display_width * display_height / 8);
for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i];
display->draw_cbr(frame, display_height);
free(frame);
LOG_DEBUG("direct drawing");
}
else {
// if we just got a content update, let the scroller manage the screen
LOG_DEBUG("resuming scrolling task");
vTaskResume(scroller.task);
xSemaphoreGive(displayer.mutex);
// resume task once we have background, not in grfs
vTaskResume(displayer.task);
}
xSemaphoreGive(display_mutex);
/****************************************************************************************
* Update visualization bars
*/
static void visu_update(void) {
// no need to protect against no woning the display as we are playing
if (pthread_mutex_trylock(&visu_export.mutex)) return;
// not enough samples
if (visu_export.level < (visu.mode == VISU_VUMETER ? RMS_LEN : FFT_LEN) * 2 && visu_export.running) {
pthread_mutex_unlock(&visu_export.mutex);
return;
}
// reset bars for all cases first
for (int i = visu.n; --i >= 0;) visu.bars[i].current = 0;
if (visu_export.running && visu_export.running) {
if (visu.mode == VISU_VUMETER) {
s16_t *iptr = visu_export.buffer;
// calculate sum(L²+R²), try to not overflow at the expense of some precision
for (int i = RMS_LEN; --i >= 0;) {
visu.bars[0].current += (*iptr * *iptr + (1 << (RMS_LEN_BIT - 2))) >> (RMS_LEN_BIT - 1);
iptr++;
visu.bars[1].current += (*iptr * *iptr + (1 << (RMS_LEN_BIT - 2))) >> (RMS_LEN_BIT - 1);
iptr++;
}
// convert to dB (1 bit remaining for getting X²/N, 60dB dynamic starting from 0dBFS = 3 bits back-off)
for (int i = visu.n; --i >= 0;) {
visu.bars[i].current = 32 * (0.01667f*10*log10f(0.0000001f + (visu.bars[i].current >> 1)) - 0.2543f);
if (visu.bars[i].current > 31) visu.bars[i].current = 31;
else if (visu.bars[i].current < 0) visu.bars[i].current = 0;
}
} else {
// on xtensa/esp32 the floating point FFT takes 1/2 cycles of the fixed point
for (int i = 0 ; i < FFT_LEN ; i++) {
// don't normalize here, but we are due INT16_MAX and FFT_LEN / 2 / 2
visu.samples[i * 2 + 0] = (float) (visu_export.buffer[2*i] + visu_export.buffer[2*i + 1]) * visu.hanning[i];
visu.samples[i * 2 + 1] = 0;
}
// actual FFT that might be less cycle than all the crap below
dsps_fft2r_fc32_ae32(visu.samples, FFT_LEN);
dsps_bit_rev_fc32_ansi(visu.samples, FFT_LEN);
float rate = visu_export.rate;
// now arrange the result with the number of bar and sampling rate (don't want DC)
for (int i = 0, j = 1; i < visu.n && j < (FFT_LEN / 2); i++) {
float power, count;
// find the next point in FFT (this is real signal, so only half matters)
for (count = 0, power = 0; j * visu_export.rate < visu.bars[i].limit * FFT_LEN && j < FFT_LEN / 2; j++, count += 1) {
power += visu.samples[2*j] * visu.samples[2*j] + visu.samples[2*j+1] * visu.samples[2*j+1];
}
// due to sample rate, we have reached the end of the available spectrum
if (j >= (FFT_LEN / 2)) {
// normalize accumulated data
if (count) power /= count * 2.;
} else if (count) {
// how much of what remains do we need to add
float ratio = j - (visu.bars[i].limit * FFT_LEN) / rate;
power += (visu.samples[2*j] * visu.samples[2*j] + visu.samples[2*j+1] * visu.samples[2*j+1]) * ratio;
// normalize accumulated data
power /= (count + ratio) * 2;
} else {
// no data for that band (sampling rate too high), just assume same as previous one
power = (visu.samples[2*j] * visu.samples[2*j] + visu.samples[2*j+1] * visu.samples[2*j+1]) / 2.;
}
// convert to dB and bars, same back-off
if (power) visu.bars[i].current = 32 * (0.01667f*10*(log10f(power) - log10f(FFT_LEN/2*2)) - 0.2543f);
if (visu.bars[i].current > 31) visu.bars[i].current = 31;
else if (visu.bars[i].current < 0) visu.bars[i].current = 0;
}
}
}
// we took what we want, we can release the buffer
visu_export.level = 0;
pthread_mutex_unlock(&visu_export.mutex);
display->clear(false, false, visu.col, visu.row, visu.col + visu.width - 1, visu.row + visu.height - 1);
for (int i = visu.n; --i >= 0;) {
int x1 = visu.col + visu.border + visu.bar_border + i*(visu.bar_width + visu.bar_gap);
int y1 = visu.row + visu.height - 1;
if (visu.bars[i].current > visu.bars[i].max) visu.bars[i].max = visu.bars[i].current;
else if (visu.bars[i].max) visu.bars[i].max--;
for (int j = 0; j <= visu.bars[i].current; j += 2)
display->draw_line( x1, y1 - j, x1 + visu.bar_width - 1, y1 - j);
if (visu.bars[i].max > 2) {
display->draw_line( x1, y1 - visu.bars[i].max, x1 + visu.bar_width - 1, y1 - visu.bars[i].max);
display->draw_line( x1, y1 - visu.bars[i].max + 1, x1 + visu.bar_width - 1, y1 - visu.bars[i].max + 1);
}
}
}
/****************************************************************************************
* Visu packet handler
*/
void spectrum_limits(int min, int n, int pos) {
if (n / 2) {
int i;
float step = (DISPLAY_BW - min) * visu.spectrum_scale / (n/2);
visu.bars[pos].limit = min + step;
for (i = 1; i < n/2; i++) visu.bars[pos+i].limit = visu.bars[pos+i-1].limit + step;
spectrum_limits(visu.bars[pos + n/2 - 1].limit, n/2, pos + n/2);
} else {
visu.bars[pos].limit = DISPLAY_BW;
}
}
/****************************************************************************************
* Visu packet handler
*/
static void visu_handler( u8_t *data, int len) {
struct visu_packet *pkt = (struct visu_packet*) data;
int bars = 0;
LOG_DEBUG("visu %u with %u parameters", pkt->which, pkt->count);
/*
If width is specified, then respect all coordinates, otherwise we try to
use the bottom part of the display and if it is a small display, we overwrite
text
*/
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
visu.mode = pkt->which;
// little trick to clean the taller screens when switching visu
if (visu.row >= SB_HEIGHT) display->clear(false, true, visu.col, visu.row, visu.col + visu.width - 1, visu.row - visu.height - 1);
if (visu.mode) {
if (pkt->count >= 4) {
// small visu, then go were we are told to
pkt->height = htonl(pkt->height);
pkt->row = htonl(pkt->row);
pkt->col = htonl(pkt->col);
visu.width = htonl(pkt->width);
visu.height = pkt->height ? pkt->height : SB_HEIGHT;
visu.col = pkt->col < 0 ? display->width + pkt->col : pkt->col;
visu.row = pkt->row < 0 ? display->height + pkt->row : pkt->row;
visu.border = htonl(pkt->border);
bars = htonl(pkt->bars);
visu.spectrum_scale = htonl(pkt->spectrum_scale) / 100.;
} else {
// full screen visu, try to use bottom screen if available
visu.width = display->width;
visu.height = display->height > SB_HEIGHT ? display->height - SB_HEIGHT : display->height;
visu.col = visu.border = 0;
visu.row = display->height - visu.height;
bars = htonl(pkt->full.bars);
visu.spectrum_scale = htonl(pkt->full.spectrum_scale) / 100.;
}
// try to adapt to what we have
if (visu.mode == VISU_SPECTRUM) {
visu.n = bars ? bars : MAX_BARS;
if (visu.spectrum_scale <= 0 || visu.spectrum_scale > 0.5) visu.spectrum_scale = 0.5;
spectrum_limits(0, visu.n, 0);
} else {
visu.n = 2;
}
do {
visu.bar_width = (visu.width - visu.border - visu.bar_gap * (visu.n - 1)) / visu.n;
if (visu.bar_width > 0) break;
} while (--visu.n);
visu.bar_border = (visu.width - visu.border - (visu.bar_width + visu.bar_gap) * visu.n + visu.bar_gap) / 2;
// give up if not enough space
if (visu.bar_width < 0) {
visu.mode = VISU_BLANK;
LOG_WARN("Not enough room for displaying visu");
} else {
// de-activate scroller if we are taking main screen
if (visu.row < SB_HEIGHT) scroller.active = false;
vTaskResume(displayer.task);
}
visu.wake = 0;
// reset bars maximum
for (int i = visu.n; --i >= 0;) visu.bars[i].max = 0;
display->clear(false, true, visu.col, visu.row, visu.col + visu.width - 1, visu.row - visu.height - 1);
LOG_INFO("Visualizer with %u bars of width %d:%d:%d:%d (%w:%u,h:%u,c:%u,r:%u,s:%.02f)", visu.n, visu.bar_border, visu.bar_width, visu.bar_gap, visu.border, visu.width, visu.height, visu.col, visu.row, visu.spectrum_scale);
} else {
LOG_INFO("Stopping visualizer");
}
xSemaphoreGive(displayer.mutex);
}
/****************************************************************************************
* Scroll task
* - with the addition of the visualizer, it's a bit a 2-headed beast not easy to
* maintain, so som better separation between the visu and scroll is probably needed
*/
static void scroll_task(void *args) {
u8_t *frame = NULL;
int len = display_width * display_height / 8;
static void displayer_task(void *args) {
int sleep;
while (1) {
xSemaphoreTake(display_mutex, portMAX_DELAY);
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
// suspend ourselves if nothing to do, grfg will wake us up
if (!scroller.active) {
xSemaphoreGive(display_mutex);
// suspend ourselves if nothing to do, grfg or visu will wake us up
if (!scroller.active && !visu.mode) {
xSemaphoreGive(displayer.mutex);
vTaskSuspend(NULL);
xSemaphoreTake(display_mutex, portMAX_DELAY);
xSemaphoreTake(displayer.mutex, portMAX_DELAY);
scroller.wake = visu.wake = 0;
}
// lock screen & active status
frame = malloc(display_width * display_height / 8);
// go for long sleep when either item is disabled
if (!visu.mode) visu.wake = LONG_WAKE;
if (!scroller.active) scroller.wake = LONG_WAKE;
// scroll required amount of columns (within the window)
while (scroller.direction == 1 ? (scroller.scroll_ptr <= scroller.scroll_frame + scroller.size - scroller.scroll_step - len) :
(scroller.scroll_ptr + scroller.scroll_step >= scroller.scroll_frame) ) {
if (scroller.active && scroller.wake <= 0) {
// by default go for the long sleep, will change below if required
scroller.wake = LONG_WAKE;
// don't do anything if we have aborted
if (!scroller.active) break;
// do we have more to scroll (scroll.width is the last column from which we havea full zone)
if (scroller.by > 0 ? (scroller.scrolled <= scroller.scroll.width) : (scroller.scrolled >= 0)) {
memcpy(scroller.frame, scroller.back.frame, scroller.back.width * displayer.height / 8);
for (int i = 0; i < scroller.width * displayer.height / 8; i++) scroller.frame[i] |= scroller.scroll.frame[scroller.scrolled * displayer.height / 8 + i];
scroller.scrolled += scroller.by;
if (displayer.owned) display->draw_cbr(scroller.frame, scroller.width, displayer.height);
// scroll required amount of columns (within the window)
memcpy(frame, scroller.back_frame, display_width * display_height / 8);
for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i];
scroller.scroll_ptr += scroller.scroll_step;
display->draw_cbr(frame, display_height);
xSemaphoreGive(display_mutex);
vTaskDelay(scroller.speed / portTICK_PERIOD_MS);
xSemaphoreTake(display_mutex, portMAX_DELAY);
}
// done with scrolling cycle reset scroller ptr
scroller.scroll_ptr = scroller.scroll_frame + (scroller.direction == 2 ? scroller.size - scroller.scroll_len : 0);
// scrolling done, update screen and see if we need to continue
if (scroller.active) {
memcpy(frame, scroller.back_frame, len);
for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i];
display->draw_cbr(frame, display_height);
free(frame);
// short sleep & don't need background update
scroller.wake = scroller.speed;
} else if (scroller.first || !scroller.mode) {
// at least one round done
scroller.first = false;
// see if we need to pause or if we are done
if (scroller.mode) {
scroller.active = false;
xSemaphoreGive(display_mutex);
// can't call directly send_packet from slimproto as it's not re-entrant
ANIC_resp = ANIM_SCROLL_ONCE | ANIM_SCREEN_1;
LOG_INFO("scroll-once terminated");
} else {
xSemaphoreGive(display_mutex);
vTaskDelay(scroller.pause / portTICK_PERIOD_MS);
scroller.wake = scroller.pause;
LOG_DEBUG("scroll cycle done, pausing for %u (ms)", scroller.pause);
}
} else {
free(frame);
xSemaphoreGive(display_mutex);
LOG_INFO("scroll aborted");
// need to reset pointers for next scroll
scroller.scrolled = scroller.by < 0 ? scroller.scroll.width : 0;
}
}
// update visu if active
if (visu.mode && visu.wake <= 0) {
visu_update();
visu.wake = 100;
}
// need to make sure we own display
if (displayer.owned) display->update();
// release semaphore and sleep what's needed
xSemaphoreGive(displayer.mutex);
sleep = min(visu.wake, scroller.wake);
vTaskDelay(sleep / portTICK_PERIOD_MS);
scroller.wake -= sleep;
visu.wake -= sleep;
}
}

11
components/squeezelite/embedded.h
View File

@@ -54,6 +54,17 @@ void register_external(void);
void deregister_external(void);
void decode_restore(int external);
// to be defined to nothing if you don't want to support these
extern struct visu_export_s {
pthread_mutex_t mutex;
u32_t level, size, rate;
s16_t *buffer;
bool running;
} visu_export;
void output_visu_export(s16_t *frames, frames_t out_frames, u32_t rate, bool silence);
void output_visu_init(log_level level);
void output_visu_close(void);
// optional, please chain if used
bool (*slimp_handler)(u8_t *data, int len);
void (*slimp_loop)(void);

2
components/squeezelite/output_bt.c
View File

@@ -121,6 +121,8 @@ static int _write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t g
memcpy(btout + oframes * BYTES_PER_FRAME, buf, out_frames * BYTES_PER_FRAME);
}
output_visu_export((s16_t*) (btout + oframes * BYTES_PER_FRAME), out_frames, output.current_sample_rate, silence);
return (int)out_frames;
}

3
components/squeezelite/output_embedded.c
View File

@@ -68,6 +68,8 @@ void output_init_embedded(log_level level, char *device, unsigned output_buf_siz
output_init_i2s(level, device, output_buf_size, params, rates, rate_delay, idle);
}
output_visu_init(level);
LOG_INFO("init completed.");
}
@@ -75,6 +77,7 @@ void output_close_embedded(void) {
LOG_INFO("close output");
if (close_cb) (*close_cb)();
output_close_common();
output_visu_close();
}
void set_volume(unsigned left, unsigned right) {

2
components/squeezelite/output_i2s.c
View File

@@ -365,6 +365,8 @@ static int _i2s_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32
_scale_and_pack_frames(obuf + oframes * bytes_per_frame, optr, out_frames, gainL, gainR, output.format);
#endif
output_visu_export((s16_t*) (obuf + oframes * bytes_per_frame), out_frames, output.current_sample_rate, silence);
oframes += out_frames;
return out_frames;

76
components/squeezelite/output_visu.c Normal file
View File

@@ -0,0 +1,76 @@
/*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, triode1@btinternet.com
* Ralph Irving 2015-2017, ralph_irving@hotmail.com
* Philippe_44 2020, philippe_44@outloook.com
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "squeezelite.h"
#define VISUEXPORT_SIZE 2048
EXT_BSS struct visu_export_s visu_export;
static struct visu_export_s *visu = &visu_export;
static log_level loglevel = lINFO;
void output_visu_export(s16_t *frames, frames_t out_frames, u32_t rate, bool silence) {
// no data to process
if (silence) {
visu->running = false;
return;
}
// do not block, try to stuff data put wait for consumer to have used them
if (!pthread_mutex_trylock(&visu->mutex)) {
// don't mix sample rates
if (visu->rate != rate) visu->level = 0;
// stuff buffer up and wait for consumer to read it (should reset level)
if (visu->level < visu->size) {
u32_t space = min(visu->size - visu->level, out_frames * 2) * 2;
memcpy(visu->buffer + visu->level, frames, space);
visu->level += space / 2;
visu->running = true;
visu->rate = rate ? rate : 44100;
}
// mutex must be released
pthread_mutex_unlock(&visu->mutex);
}
}
void output_visu_close(void) {
pthread_mutex_lock(&visu->mutex);
visu->running = false;
free(visu->buffer);
pthread_mutex_unlock(&visu->mutex);
}
void output_visu_init(log_level level) {
loglevel = level;
pthread_mutex_init(&visu->mutex, NULL);
visu->size = VISUEXPORT_SIZE;
visu->running = false;
visu->rate = 44100;
visu->buffer = malloc(VISUEXPORT_SIZE * sizeof(s16_t) * 2);
LOG_INFO("Initialize VISUEXPORT %u 16 bits samples", VISUEXPORT_SIZE);
}

7
components/squeezelite/slimproto.c
View File

@@ -690,6 +690,7 @@ static void slimproto_run() {
UNLOCK_D;
LOCK_O;
if (!output.external) {
status.output_full = _buf_used(outputbuf);
status.output_size = outputbuf->size;
status.frames_played = output.frames_played_dmp;
@@ -711,7 +712,7 @@ static void slimproto_run() {
if (_start_output && (output.state == OUTPUT_STOPPED || output.state == OUTPUT_OFF)) {
output.state = OUTPUT_BUFFER;
}
if (!output.external && output.state == OUTPUT_RUNNING && !sentSTMu && status.output_full == 0 && status.stream_state <= DISCONNECT &&
if (output.state == OUTPUT_RUNNING && !sentSTMu && status.output_full == 0 && status.stream_state <= DISCONNECT &&
_decode_state == DECODE_STOPPED) {
_sendSTMu = true;
@@ -721,15 +722,15 @@ static void slimproto_run() {
output.stop_time = now;
}
if (output.state == OUTPUT_RUNNING && !sentSTMo && status.output_full == 0 && status.stream_state == STREAMING_HTTP) {
_sendSTMo = true;
sentSTMo = true;
}
}
if (output.state == OUTPUT_STOPPED && output.idle_to && (now - output.stop_time > output.idle_to)) {
output.state = OUTPUT_OFF;
LOG_DEBUG("output timeout");
}
if (!output.external && output.state == OUTPUT_RUNNING && now - status.last > 1000) {
if (output.state == OUTPUT_RUNNING && now - status.last > 1000) {
_sendSTMt = true;
status.last = now;
}

30
components/squeezelite/squeezelite.h
View File

@@ -387,6 +387,21 @@ typedef BOOL bool;
#endif
typedef u32_t frames_t;
typedef int sockfd;
// logging
typedef enum { lERROR = 0, lWARN, lINFO, lDEBUG, lSDEBUG } log_level;
const char *logtime(void);
void logprint(const char *fmt, ...);
#define LOG_ERROR(fmt, ...) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_WARN(fmt, ...) if (loglevel >= lWARN) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_INFO(fmt, ...) if (loglevel >= lINFO) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_DEBUG(fmt, ...) if (loglevel >= lDEBUG) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_SDEBUG(fmt, ...) if (loglevel >= lSDEBUG) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#if EMBEDDED
#include "embedded.h"
#endif
@@ -395,9 +410,6 @@ typedef BOOL bool;
#define MSG_NOSIGNAL 0
#endif
typedef u32_t frames_t;
typedef int sockfd;
#if EVENTFD
#include <sys/eventfd.h>
#define event_event int
@@ -473,18 +485,6 @@ void _wake_create(event_event*);
#define min(a,b) (((a) < (b)) ? (a) : (b))
// logging
typedef enum { lERROR = 0, lWARN, lINFO, lDEBUG, lSDEBUG } log_level;
const char *logtime(void);
void logprint(const char *fmt, ...);
#define LOG_ERROR(fmt, ...) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_WARN(fmt, ...) if (loglevel >= lWARN) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_INFO(fmt, ...) if (loglevel >= lINFO) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_DEBUG(fmt, ...) if (loglevel >= lDEBUG) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_SDEBUG(fmt, ...) if (loglevel >= lSDEBUG) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__)
// utils.c (non logging)
typedef enum { EVENT_TIMEOUT = 0, EVENT_READ, EVENT_WAKE } event_type;
#if WIN && USE_SSL

1
components/squeezelite/utils.c
View File

@@ -78,6 +78,7 @@ void logprint(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fflush(stderr);
}

1
esp-dsp Submodule

Submodule esp-dsp added at de39220fb4

BIN
plugin/SqueezeESP32.zip
View File

Binary file not shown.

68
plugin/SqueezeESP32/Graphics.pm
View File

@@ -11,7 +11,12 @@ my $prefs = preferences('plugin.squeezeesp32');
my $log = logger('plugin.squeezeesp32');
my $VISUALIZER_NONE = 0;
my $VISUALIZER_VUMETER = 1;
my $VISUALIZER_SPECTRUM_ANALYZER = 2;
my $VISUALIZER_WAVEFORM = 3;
my $width = $prefs->get('width') || 128;
my $spectrum_scale = $prefs->get('spectrum_scale') || 50;
my @modes = (
# mode 0
@@ -42,6 +47,44 @@ my @modes = (
{ desc => ['SETUP_SHOWBUFFERFULLNESS'],
bar => 0, secs => 0, width => $width, fullness => 1,
params => [$VISUALIZER_NONE] },
# mode 7
{ desc => ['VISUALIZER_VUMETER_SMALL'],
bar => 0, secs => 0, width => $width, _width => -20,
# extra parameters (width, height, col (< 0 = from right), row (< 0 = from bottom), bars, left space)
params => [$VISUALIZER_VUMETER, 20, 32, -20, 0, 2] },
# mode 8
{ desc => ['VISUALIZER_SPECTRUM_ANALYZER_SMALL'],
bar => 0, secs => 0, width => $width, _width => -32,
# extra parameters (width, height, col (< 0 = from right), row (< 0 = from bottom), bars, left space)
params => [$VISUALIZER_SPECTRUM_ANALYZER, 32, 32, -32, 0, 2, 6, $spectrum_scale] },
# mode 9
{ desc => ['VISUALIZER_VUMETER'],
bar => 0, secs => 0, width => $width,
params => [$VISUALIZER_VUMETER] },
# mode 10
{ desc => ['VISUALIZER_SPECTRUM_ANALYZER'],
bar => 0, secs => 0, width => $width,
# extra parameters (bars)
params => [$VISUALIZER_SPECTRUM_ANALYZER, 16, $spectrum_scale] },
# mode 11
{ desc => ['VISUALIZER_VUMETER', 'AND', 'ELAPSED'],
bar => 0, secs => 1, width => $width,
params => [$VISUALIZER_VUMETER] },
# mode 12
{ desc => ['VISUALIZER_SPECTRUM_ANALYZER', 'AND', 'ELAPSED'],
bar => 0, secs => 1, width => $width,
# extra parameters (bars)
params => [$VISUALIZER_SPECTRUM_ANALYZER, 16, $spectrum_scale] },
# mode 13
{ desc => ['VISUALIZER_VUMETER', 'AND', 'REMAINING'],
bar => 0, secs => -1, width => $width,
params => [$VISUALIZER_VUMETER] },
# mode 14
{ desc => ['VISUALIZER_SPECTRUM_ANALYZER', 'AND', 'REMAINING'],
bar => 0, secs => -1, width => $width,
# extra parameters (bars)
params => [$VISUALIZER_SPECTRUM_ANALYZER, 16, $spectrum_scale] },
);
sub modes {
@@ -52,6 +95,27 @@ sub nmodes {
return $#modes;
}
sub displayWidth {
my $display = shift;
my $client = $display->client;
# if we're showing the always-on visualizer & the current buttonmode
# hasn't overridden, then use the playing display mode to index
# into the display width, otherwise, it's fullscreen.
my $mode = 0;
if ( $display->showVisualizer() && !defined($client->modeParam('visu')) ) {
my $cprefs = preferences('server')->client($client);
$mode = $cprefs->get('playingDisplayModes')->[ $cprefs->get('playingDisplayMode') ];
}
if ($display->widthOverride) {
return $display->widthOverride + ($display->modes->[$mode || 0]{_width} || 0);
} else {
return $display->modes->[$mode || 0]{width};
}
}
# I don't think LMS renderer handles properly screens other than 32 pixels. It
# seems that all we get is a 32 pixel-tall data with anything else padded to 0
# i.e. if we try 64 pixels height, bytes 0..3 and 4..7 will contains the same
@@ -72,10 +136,6 @@ sub displayHeight {
return 32;
}
sub displayWidth {
return shift->widthOverride(@_) || $width;
}
sub vfdmodel {
return 'graphic-'.$width.'x32';
}

9
plugin/SqueezeESP32/HTML/EN/plugins/SqueezeESP32/settings/basic.html
View File

@@ -1,11 +1,20 @@
[% PROCESS settings/header.html %]
[% WRAPPER setting title="PLUGIN_SQUEEZEESP32_BANNER" %]
<div>[% "PLUGIN_SQUEEZEESP32_BANNER_TEXT" | string %]</div>
[% END %]
<div class="prefDesc">
[% WRAPPER setting title="PLUGIN_SQUEEZEESP32_WIDTH" desc="PLUGIN_SQUEEZEESP32_WIDTH_DESC" %]
<input type="text" class="stdedit" name="pref_width" id="pref_width" value="[% prefs.pref_width %]" size="3">
[% END %]
[% WRAPPER setting title="PLUGIN_SQUEEZEESP32_SPECTRUM_SCALE" desc="PLUGIN_SQUEEZEESP32_SPECTRUM_SCALE_DESC" %]
<input type="number" min="10" max= "50" step="5" class="stdedit" name="pref_spectrum_scale" id="pref_spectrum_scale" value="[% prefs.pref_spectrum_scale %]" size="3">
[% END %]
</div>
[% PROCESS settings/footer.html %]

1
plugin/SqueezeESP32/Plugin.pm
View File

@@ -10,6 +10,7 @@ my $prefs = preferences('plugin.squeezeesp32');
$prefs->init({
width => 128,
spectrum_scale => 50,
});
my $log = Slim::Utils::Log->addLogCategory({

4
plugin/SqueezeESP32/Settings.pm
View File

@@ -6,7 +6,7 @@ use strict;
use Slim::Utils::Prefs;
use Slim::Utils::Log;
my $log = logger('plugin.SqueezeESP32');
my $log = logger('plugin.squeezeesp32');
sub name {
return 'PLUGIN_SQUEEZEESP32';
@@ -17,7 +17,7 @@ sub page {
}
sub prefs {
return (preferences('plugin.SqueezeESP32'), qw(width));
return (preferences('plugin.squeezeesp32'), qw(width spectrum_scale));
}
sub handler {

2
plugin/SqueezeESP32/install.xml
View File

@@ -10,6 +10,6 @@
<name>PLUGIN_SQUEEZEESP32</name>
<description>PLUGIN_SQUEEZEESP32_DESC</description>
<module>Plugins::SqueezeESP32::Plugin</module>
<version>0.9</version>
<version>0.12</version>
<creator>Philippe</creator>
</extensions>

14
plugin/SqueezeESP32/strings.txt
View File

@@ -4,8 +4,22 @@ WELCOME_TO_SQUEEZEESP32
PLUGIN_SQUEEZEESP32
EN SqueezeESP32
PLUGIN_SQUEEZEESP32_BANNER
EN WARNING
PLUGIN_SQUEEZEESP32_BANNER_TEXT
EN You need to restart LMS for these parameters to be taken into account
PLUGIN_SQUEEZEESP32_DESC
EN Adds a new player id (100) to enable display with SqueezeESP32
PLUGIN_SQUEEZEESP32_WIDTH
EN Screen width
PLUGIN_SQUEEZEESP32_SPECTRUM_SCALE
EN Spectrum scale
PLUGIN_SQUEEZEESP32_SPECTRUM_SCALE_DESC
EN Sets the scale factor % of spectrum visualizer by halves for better representation.
EN For example, 50 means that 50% of spectrum is displayed in 1/2 of the screen, so it's linear...
EN But 25 means that only 25% of spectrum is displayed in 1/2 of the screen, so it's a sort of log

4
plugin/repo.xml
View File

@@ -1,10 +1,10 @@
<?xml version='1.0' standalone='yes'?>
<extensions>
<plugins>
<plugin version="0.9" name="SqueezeESP32" minTarget="7.5" maxTarget="*">
<plugin version="0.12" name="SqueezeESP32" minTarget="7.5" maxTarget="*">
<link>https://github.com/sle118/squeezelite-esp32</link>
<creator>Philippe</creator>
<sha>89c68b54ad4373df6c0cd37222a07b53013c4815</sha>
<sha>3e60650efdff28cd0da9a7e9d0ddccf3a68d350d</sha>
<email>philippe_44@outlook.com</email>
<desc lang="EN">SqueezeESP32 additional player id (100)</desc>
<url>http://github.com/sle118/squeezelite-esp32/raw/master/plugin/SqueezeESP32.zip</url>