Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2026-01-31 14:51:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

more display tweaks

Browse Source
This commit is contained in:
philippe44
2020-01-23 22:47:05 -08:00
parent 766d6972b1
commit dc392b342f
5 changed files with 73 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/squeezelite/decode_external.c
View File

@@ -339,7 +339,7 @@ void deregister_external(void) {
} }
} }
void decode_resume(int external) { void decode_restore(int external) {
switch (external) { switch (external) {
case DECODE_BT: case DECODE_BT:
bt_disconnect(); bt_disconnect();

83
components/squeezelite/display.c
View File

@@ -53,6 +53,12 @@ struct grfg_packet {
u16_t width; // # of pixels of scrollable u16_t width; // # of pixels of scrollable
}; };
struct ANIC_header {
char opcode[4];
u32_t length;
u8_t mode;
};
#pragma pack(pop) #pragma pack(pop)
static struct scroller_s { static struct scroller_s {
@@ -69,30 +75,28 @@ static struct scroller_s {
int scroll_len, scroll_step; int scroll_len, scroll_step;
} scroller; } scroller;
/* #define ANIM_NONE 0x00
ANIM_SCREEN_1 => end of first scroll on screen 1
ANIM_SCREEN_2 => end of first scroll on screen 2
ANIM_SCROLL_ONCE | ANIM_SCREEN_1 => end of scroll once on screen 1
ANIM_SCROLL_ONCE | ANIM_SCREEN_2 => end of scroll once on screen 2
*/
#define ANIM_TRANSITION 0x01 // A transition animation has finished #define ANIM_TRANSITION 0x01 // A transition animation has finished
#define ANIM_SCROLL_ONCE 0x02 #define ANIM_SCROLL_ONCE 0x02
#define ANIM_SCREEN_1 0x04 #define ANIM_SCREEN_1 0x04
#define ANIM_SCREEN_2 0x08 #define ANIM_SCREEN_2 0x08
#define SCROLL_STACK_SIZE 2048 static u8_t ANIC_resp = ANIM_NONE;
#define SCROLL_STACK_SIZE 2048
#define LINELEN 40 #define LINELEN 40
#define HEIGHT 32
static log_level loglevel = lINFO; static log_level loglevel = lINFO;
static SemaphoreHandle_t display_sem; static SemaphoreHandle_t display_sem;
static bool (*slimp_handler_chain)(u8_t *data, int len); 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 void (*notify_chain)(in_addr_t ip, u16_t hport, u16_t cport);
static int display_width, display_height;
#define max(a,b) (((a) > (b)) ? (a) : (b)) #define max(a,b) (((a) > (b)) ? (a) : (b))
static void server(in_addr_t ip, u16_t hport, u16_t cport); 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 handler(u8_t *data, int len);
static void vfdc_handler( u8_t *_data, int bytes_read); static void vfdc_handler( u8_t *_data, int bytes_read);
static void grfe_handler( u8_t *data, int len); static void grfe_handler( u8_t *data, int len);
@@ -135,23 +139,55 @@ void sb_display_init(void) {
static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4))); static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
static EXT_RAM_ATTR StackType_t xStack[SCROLL_STACK_SIZE] __attribute__ ((aligned (4))); static EXT_RAM_ATTR StackType_t xStack[SCROLL_STACK_SIZE] __attribute__ ((aligned (4)));
// need to force height to 32 maximum
display_width = display->width;
display_height = min(display->height, 32);
// create scroll management task // create scroll management task
display_sem = xSemaphoreCreateMutex(); display_sem = xSemaphoreCreateMutex();
scroller.task = xTaskCreateStatic( (TaskFunction_t) scroll_task, "scroll_thread", SCROLL_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer); scroller.task = xTaskCreateStatic( (TaskFunction_t) scroll_task, "scroll_thread", SCROLL_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
// size scroller // size scroller
scroller.max = (display->width * display->height / 8) * 10; scroller.max = (display_width * display_height / 8) * 10;
scroller.scroll_frame = malloc(scroller.max); scroller.scroll_frame = malloc(scroller.max);
scroller.back_frame = malloc(display->width * display->height / 8); scroller.back_frame = malloc(display_width * display_height / 8);
// chain handlers // chain handlers
slimp_handler_chain = slimp_handler; slimp_handler_chain = slimp_handler;
slimp_handler = handler; slimp_handler = handler;
slimp_loop_chain = slimp_loop;
slimp_loop = send_server;
notify_chain = server_notify; notify_chain = server_notify;
server_notify = server; server_notify = server;
} }
/****************************************************************************************
* Send message to server (ANIC at that time)
*/
static void send_server(void) {
/*
This complication is needed as we cannot send direclty to LMS, because
send_packet is not thread safe. So must subscribe to slimproto busy loop
end send from there
*/
if (ANIC_resp != ANIM_NONE) {
struct ANIC_header pkt_header;
memset(&pkt_header, 0, sizeof(pkt_header));
memcpy(&pkt_header.opcode, "ANIC", 4);
pkt_header.length = htonl(sizeof(pkt_header) - 8);
pkt_header.mode = ANIC_resp;
send_packet((u8_t *)&pkt_header, sizeof(pkt_header));
ANIC_resp = ANIM_NONE;
}
if (slimp_loop_chain) (*slimp_loop_chain)();
}
/**************************************************************************************** /****************************************************************************************
* *
*/ */
@@ -307,7 +343,7 @@ static void grfe_handler( u8_t *data, int len) {
xSemaphoreTake(display_sem, portMAX_DELAY); xSemaphoreTake(display_sem, portMAX_DELAY);
scroller.active = false; scroller.active = false;
display->draw_cbr(data + sizeof(struct grfe_packet), HEIGHT); display->draw_cbr(data + sizeof(struct grfe_packet), display_height);
xSemaphoreGive(display_sem); xSemaphoreGive(display_sem);
@@ -393,13 +429,13 @@ static void grfg_handler(u8_t *data, int len) {
// can't be in grfs as we need full size & scroll_width // can't be in grfs as we need full size & scroll_width
if (scroller.updated) { if (scroller.updated) {
scroller.scroll_len = display->width * display->height / 8 - (display->width - scroller.window_width) * display->height / 8; scroller.scroll_len = display_width * display_height / 8 - (display_width - scroller.window_width) * display_height / 8;
if (scroller.direction == 1) { if (scroller.direction == 1) {
scroller.scroll_ptr = scroller.scroll_frame; scroller.scroll_ptr = scroller.scroll_frame;
scroller.scroll_step = scroller.by * display->height / 8; scroller.scroll_step = scroller.by * display_height / 8;
} else { } else {
scroller.scroll_ptr = scroller.scroll_frame + scroller.size - scroller.scroll_len; scroller.scroll_ptr = scroller.scroll_frame + scroller.size - scroller.scroll_len;
scroller.scroll_step = -scroller.by * display->height / 8; scroller.scroll_step = -scroller.by * display_height / 8;
} }
scroller.updated = false; scroller.updated = false;
@@ -407,10 +443,10 @@ static void grfg_handler(u8_t *data, int len) {
if (!scroller.active) { if (!scroller.active) {
// this is a background update and scroller has been finished, so need to update here // this is a background update and scroller has been finished, so need to update here
u8_t *frame = malloc(display->width * display->height / 8); u8_t *frame = malloc(display_width * display_height / 8);
memcpy(frame, scroller.back_frame, 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]; for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i];
display->draw_cbr(frame, HEIGHT); display->draw_cbr(frame, display_height);
free(frame); free(frame);
LOG_DEBUG("direct drawing"); LOG_DEBUG("direct drawing");
} }
@@ -428,7 +464,7 @@ static void grfg_handler(u8_t *data, int len) {
*/ */
static void scroll_task(void *args) { static void scroll_task(void *args) {
u8_t *frame = NULL; u8_t *frame = NULL;
int len = display->width * display->height / 8; int len = display_width * display_height / 8;
while (1) { while (1) {
xSemaphoreTake(display_sem, portMAX_DELAY); xSemaphoreTake(display_sem, portMAX_DELAY);
@@ -441,7 +477,7 @@ static void scroll_task(void *args) {
} }
// lock screen & active status // lock screen & active status
frame = malloc(display->width * display->height / 8); frame = malloc(display_width * display_height / 8);
// scroll required amount of columns (within the window) // scroll required amount of columns (within the window)
while (scroller.direction == 1 ? (scroller.scroll_ptr <= scroller.scroll_frame + scroller.size - scroller.scroll_step - len) : while (scroller.direction == 1 ? (scroller.scroll_ptr <= scroller.scroll_frame + scroller.size - scroller.scroll_step - len) :
@@ -451,10 +487,10 @@ static void scroll_task(void *args) {
if (!scroller.active) break; if (!scroller.active) break;
// scroll required amount of columns (within the window) // scroll required amount of columns (within the window)
memcpy(frame, scroller.back_frame, 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]; for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i];
scroller.scroll_ptr += scroller.scroll_step; scroller.scroll_ptr += scroller.scroll_step;
display->draw_cbr(frame, HEIGHT); display->draw_cbr(frame, display_height);
xSemaphoreGive(display_sem); xSemaphoreGive(display_sem);
usleep(scroller.speed * 1000); usleep(scroller.speed * 1000);
@@ -468,14 +504,15 @@ static void scroll_task(void *args) {
if (scroller.active) { if (scroller.active) {
memcpy(frame, scroller.back_frame, len); memcpy(frame, scroller.back_frame, len);
for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i]; for (int i = 0; i < scroller.scroll_len; i++) frame[i] |= scroller.scroll_ptr[i];
display->draw_cbr(frame, HEIGHT); display->draw_cbr(frame, display_height);
free(frame); free(frame);
// see if we need to pause or if we are done // see if we need to pause or if we are done
if (scroller.mode) { if (scroller.mode) {
scroller.active = false; scroller.active = false;
xSemaphoreGive(display_sem); xSemaphoreGive(display_sem);
//sendANIC(ANIM_SCROLL_ONCE | ANIM_SCREEN_1); // 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"); LOG_INFO("scroll-once terminated");
} else { } else {
xSemaphoreGive(display_sem); xSemaphoreGive(display_sem);

5
components/squeezelite/embedded.h
View File

@@ -49,10 +49,11 @@ int pthread_create_name(pthread_t *thread, _CONST pthread_attr_t *attr,
void embedded_init(void); void embedded_init(void);
void register_external(void); void register_external(void);
void deregister_external(void); void deregister_external(void);
void decode_resume(int external); void decode_restore(int external);
// optional, please chain // optional, please chain if used
bool (*slimp_handler)(u8_t *data, int len); bool (*slimp_handler)(u8_t *data, int len);
void (*slimp_loop)(void);
void (*server_notify)(in_addr_t ip, u16_t hport, u16_t cport); void (*server_notify)(in_addr_t ip, u16_t hport, u16_t cport);
#endif // EMBEDDED_H #endif // EMBEDDED_H

15
components/squeezelite/slimproto.c
View File

@@ -87,13 +87,13 @@ static struct {
stream_state stream_state; stream_state stream_state;
} status; } status;
int autostart; static int autostart;
bool sentSTMu, sentSTMo, sentSTMl; static bool sentSTMu, sentSTMo, sentSTMl;
u32_t new_server; static u32_t new_server;
char *new_server_cap; static char *new_server_cap;
#define PLAYER_NAME_LEN 64 #define PLAYER_NAME_LEN 64
char player_name[PLAYER_NAME_LEN + 1] = ""; static char player_name[PLAYER_NAME_LEN + 1] = "";
const char *name_file = NULL; static const char *name_file = NULL;
void send_packet(u8_t *packet, size_t len) { void send_packet(u8_t *packet, size_t len) {
u8_t *ptr = packet; u8_t *ptr = packet;
@@ -377,7 +377,7 @@ static void process_strm(u8_t *pkt, int len) {
sentSTMu = sentSTMo = sentSTMl = false; sentSTMu = sentSTMo = sentSTMl = false;
LOCK_O; LOCK_O;
#if EMBEDDED #if EMBEDDED
if (output.external) decode_resume(output.external); if (output.external) decode_restore(output.external);
output.external = 0; output.external = 0;
_buf_resize(outputbuf, output.init_size); _buf_resize(outputbuf, output.init_size);
#endif #endif
@@ -770,6 +770,7 @@ static void slimproto_run() {
#if IR #if IR
if (_sendIR) sendIR(ir_code, ir_ts); if (_sendIR) sendIR(ir_code, ir_ts);
#endif #endif
if (*slimp_loop) (*slimp_loop)();
} }
} }
} }

1
components/squeezelite/squeezelite.h
View File

@@ -553,6 +553,7 @@ void buf_destroy(struct buffer *buf);
void slimproto(log_level level, char *server, u8_t mac[6], const char *name, const char *namefile, const char *modelname, int maxSampleRate); void slimproto(log_level level, char *server, u8_t mac[6], const char *name, const char *namefile, const char *modelname, int maxSampleRate);
void slimproto_stop(void); void slimproto_stop(void);
void wake_controller(void); void wake_controller(void);
void send_packet(u8_t *packet, size_t len);
// stream.c // stream.c
typedef enum { STOPPED = 0, DISCONNECT, STREAMING_WAIT, typedef enum { STOPPED = 0, DISCONNECT, STREAMING_WAIT,