Merge branch 'master-v4.3' of https://github.com/sle118/squeezelite-esp32 into master-v4.3

CHANGELOG

@@ -1,3 +1,9 @@
+2024-01-10
+ - add OggFlac to stream metadata
+ - fix OggFlac deadlock in flac callback when not enough data in streambuf
+ - fix no displayer due to threadshold too high (use 500ms instead)
+ - reset outputbuf when cspot starts
+ 
 2024-01-01
  - ogg stream are parsed to foward metadata to LMS
  - fix some ogg parsing on multi-stream containers

components/squeezelite/decode_external.c

@@ -288,6 +288,7 @@ static bool raop_sink_cmd_handler(raop_event_t event, va_list args)
 			output.frames_played = 0;
 			output.external = DECODE_RAOP;
 			output.state = OUTPUT_STOPPED;
+
 			if (decode.state != DECODE_STOPPED) decode.state = DECODE_ERROR;
 			LOG_INFO("resizing buffer %u", outputbuf->size);
 			break;
@@ -377,6 +378,7 @@ static bool cspot_cmd_handler(cspot_event_t cmd, va_list args)
 		output.state = OUTPUT_STOPPED;
         sink_state = SINK_ABORT;
 		_buf_flush(outputbuf);
+        _buf_limit(outputbuf, 0);
 		if (decode.state != DECODE_STOPPED) decode.state = DECODE_ERROR;
 		LOG_INFO("CSpot start track");
 		break;

components/squeezelite/flac.c

@@ -121,6 +121,9 @@ static FLAC__StreamDecoderReadStatus read_cb(const FLAC__StreamDecoder *decoder,
 	_buf_inc_readp(streambuf, bytes);
 	UNLOCK_S;
 
+    // give some time for stream to acquire data otherwise flac will hammer us
+    if (!end && !bytes) usleep(100 * 1000);
+
 	*want = bytes;
 
 	return end ? FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM : FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;

components/squeezelite/output_bt.c

@@ -139,8 +139,11 @@ static int _write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t g
 		u8_t *buf = silencebuf;
 		memcpy(btout + oframes * BYTES_PER_FRAME, buf, out_frames * BYTES_PER_FRAME);
 	}
-	
-	output_visu_export(btout + oframes * BYTES_PER_FRAME, out_frames, output.current_sample_rate, silence, (gainL  + gainR) / 2);
+
+    // don't update visu if we don't have enough data in buffer (500 ms)
+    if (silence || _buf_used(outputbuf) >  BYTES_PER_FRAME * output.current_sample_rate / 2) {
+    	output_visu_export(btout + oframes * BYTES_PER_FRAME, out_frames, output.current_sample_rate, silence, (gainL  + gainR) / 2);
+    }
 	
 	oframes += out_frames;
 

components/squeezelite/output_i2s.c

@@ -485,8 +485,8 @@ static int _i2s_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32
 		memcpy(obuf + oframes * BYTES_PER_FRAME, silencebuf, out_frames * BYTES_PER_FRAME);
 	}
 
-	// don't update visu if we don't have enough data in buffer
-	if (silence || output.external || _buf_used(outputbuf) > outputbuf->size >> 2 ) {
+	// don't update visu if we don't have enough data in buffer (500 ms)
+	if (silence || _buf_used(outputbuf) >  BYTES_PER_FRAME * output.current_sample_rate / 2) {
 		output_visu_export(obuf + oframes * BYTES_PER_FRAME, out_frames, output.current_sample_rate, silence, (gainL + gainR) / 2);
 	}
 		

components/squeezelite/slimproto.c

@@ -393,7 +393,9 @@ static void process_strm(u8_t *pkt, int len) {
 				stream_file(header, header_len, strm->threshold * 1024);
 				autostart -= 2;
 			} else {
-				stream_sock(ip, port, strm->format, header, header_len, strm->threshold * 1024, autostart >= 2);
+				stream_sock(ip, port, strm->flags & 0x20, 
+                            strm->format == 'o' || strm->format == 'u' || (strm->format == 'f' && strm->pcm_sample_size == 'o'),
+                            header, header_len, strm->threshold * 1024, autostart >= 2);
 			}
 			sendSTAT("STMc", 0);
 			sentSTMu = sentSTMo = sentSTMl = false;

components/squeezelite/squeezelite.h

@@ -580,26 +580,12 @@ struct streamstate {
 	u32_t meta_next;
 	u32_t meta_left;
 	bool  meta_send;
-    struct {
-		enum { STREAM_OGG_OFF, STREAM_OGG_SYNC, STREAM_OGG_HEADER, STREAM_OGG_SEGMENTS, STREAM_OGG_PAGE } state;
-		u32_t want, miss, match;
-		u8_t* data, segments[255];
-#pragma pack(push, 1)
-		struct {
-			char pattern[4];
-			u8_t version, type;
-			u64_t granule;
-			u32_t serial, page, checksum;
-			u8_t count;
-		} header;
-    } ogg;
-#pragma pack(pop)
 };
 
 void stream_init(log_level level, unsigned stream_buf_size);
 void stream_close(void);
 void stream_file(const char *header, size_t header_len, unsigned threshold);
-void stream_sock(u32_t ip, u16_t port, char codec, const char *header, size_t header_len, unsigned threshold, bool cont_wait);
+void stream_sock(u32_t ip, u16_t port, bool use_ssl, bool use_ogg, const char *header, size_t header_len, unsigned threshold, bool cont_wait);
 bool stream_disconnect(void);
 
 // decode.c

components/squeezelite/stream.c

@@ -61,6 +61,23 @@ static sockfd fd;
 
 struct EXT_RAM_ATTR streamstate stream;
 
+static EXT_RAM_ATTR struct {
+    bool flac;
+	enum { OGG_OFF, OGG_SYNC, OGG_HEADER, OGG_SEGMENTS, OGG_PAGE } state;
+	size_t want, miss, match;
+    u64_t granule;
+	u8_t* data, segments[255];
+#pragma pack(push, 1)    
+	struct {
+		char pattern[4];
+		u8_t version, type;
+		u64_t granule;
+		u32_t serial, page, checksum;
+		u8_t count;
+	} header;
+#pragma pack(pop)    
+} ogg;
+
 #if USE_SSL
 static SSL_CTX *SSLctx;
 SSL *ssl;
@@ -113,7 +130,6 @@ static int _poll(SSL *ssl, struct pollfd *pollinfo, int timeout) {
 }
 #endif
 
-
 static bool send_header(void) {
 	char *ptr = stream.header;
 	int len = stream.header_len;
@@ -148,8 +164,8 @@ static bool running = true;
 static void _disconnect(stream_state state, disconnect_code disconnect) {
 	stream.state = state;
 	stream.disconnect = disconnect;
-    if (stream.ogg.state == STREAM_OGG_PAGE && stream.ogg.data) free(stream.ogg.data);
-    stream.ogg.data = NULL;
+    if (ogg.state == OGG_PAGE && ogg.data) free(ogg.data);
+    ogg.data = NULL;
 #if USE_SSL
 	if (ssl) {
 		SSL_shutdown(ssl);
@@ -162,81 +178,93 @@ static void _disconnect(stream_state state, disconnect_code disconnect) {
 	wake_controller();
 }
 
-static u32_t memfind(const u8_t* haystack, u32_t n, const char* needle, u32_t len, u32_t *offset) {
-	int i;
+static size_t memfind(const u8_t* haystack, size_t n, const char* needle, size_t len, size_t* offset) {
+	size_t i;
 	for (i = 0; i < n && *offset != len; i++) *offset = (haystack[i] == needle[*offset]) ? *offset + 1 : 0;
 	return i;
 }
 
+/* https://xiph.org/ogg/doc/framing.html 
+ * https://xiph.org/flac/ogg_mapping.html
+ * https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-610004.2 */
+ 
 static void stream_ogg(size_t n) {
-	if (stream.ogg.state == STREAM_OGG_OFF) return;
+	if (ogg.state == OGG_OFF) return;
 	u8_t* p = streambuf->writep;
 
 	while (n) {
-		size_t consumed = min(stream.ogg.miss, n);
+		size_t consumed = min(ogg.miss, n);
 
 		// copy as many bytes as possible and come back later if we do'nt have enough
-		if (stream.ogg.data) {
-			memcpy(stream.ogg.data + stream.ogg.want - stream.ogg.miss, p, consumed);
-			stream.ogg.miss -= consumed;
-			if (stream.ogg.miss) return;
+		if (ogg.data) {
+			memcpy(ogg.data + ogg.want - ogg.miss, p, consumed);
+			ogg.miss -= consumed;
+			if (ogg.miss) return;
 		}
 
 		// we have what we want, let's parse
-		switch (stream.ogg.state) {
-		case STREAM_OGG_SYNC: {
-			stream.ogg.miss -= consumed;
+		switch (ogg.state) {
+		case OGG_SYNC: {
+			ogg.miss -= consumed;
 			if (consumed) break;
 
 			// we have to memorize position in case any of last 3 bytes match...
-			int pos = memfind(p, n, "OggS", 4, &stream.ogg.match);
-			if (stream.ogg.match == 4) {
-				consumed = pos - stream.ogg.match;
-				stream.ogg.state = STREAM_OGG_HEADER;
-				stream.ogg.miss = stream.ogg.want = sizeof(stream.ogg.header);
-				stream.ogg.data = (u8_t*) &stream.ogg.header;
-				stream.ogg.match = 0;
+			size_t pos = memfind(p, n, "OggS", 4, &ogg.match);
+			if (ogg.match == 4) {
+				consumed = pos - ogg.match;
+				ogg.state = OGG_HEADER;
+				ogg.miss = ogg.want = sizeof(ogg.header);
+				ogg.data = (u8_t*) &ogg.header;
+				ogg.match = 0;
 			} else {
-				LOG_INFO("OggS not at expected position");
+                if (!ogg.match) LOG_INFO("OggS not at expected position %zu/%zu", pos, n);
+                LOG_INFO("OggS not at expected position %zu/%zu", pos, n);
 				return;
 			}
 			break;
 		}
-		case STREAM_OGG_HEADER:
-			if (!memcmp(stream.ogg.header.pattern, "OggS", 4)) {
-				stream.ogg.miss = stream.ogg.want = stream.ogg.header.count;
-				stream.ogg.data = stream.ogg.segments;
-				stream.ogg.state = STREAM_OGG_SEGMENTS;
+		case OGG_HEADER:
+			if (!memcmp(ogg.header.pattern, "OggS", 4)) {
+				ogg.miss = ogg.want = ogg.header.count;
+				ogg.data = ogg.segments;
+				ogg.state = OGG_SEGMENTS;
 			} else {
-				stream.ogg.state = STREAM_OGG_SYNC;
-				stream.ogg.data = NULL;
+				ogg.state = OGG_SYNC;
+				ogg.data = NULL;
 			}
 			break;
-		case STREAM_OGG_SEGMENTS:
+		case OGG_SEGMENTS:
 			// calculate size of page using lacing values
-			for (int i = 0; i < stream.ogg.want; i++) stream.ogg.miss += stream.ogg.data[i];
-			stream.ogg.want = stream.ogg.miss;
+			for (size_t i = 0; i < ogg.want; i++) ogg.miss += ogg.data[i];
+			ogg.want = ogg.miss;
 
-			if (stream.ogg.header.granule == 0) {
+            if (ogg.header.granule == 0 || (ogg.header.granule == -1 && ogg.granule == 0)) {
 				// granule 0 means a new stream, so let's look into it
-				stream.ogg.state = STREAM_OGG_PAGE;
-				stream.ogg.data = malloc(stream.ogg.want);
+				ogg.state = OGG_PAGE;
+				ogg.data = malloc(ogg.want);
 			} else {
 				// otherwise, jump over data
-				stream.ogg.state = STREAM_OGG_SYNC;
-				stream.ogg.data = NULL;
+				ogg.state = OGG_SYNC;
+				ogg.data = NULL;
 			}
-			break;
-		case STREAM_OGG_PAGE: {
-			u32_t offset = 0;
 
-			// try to find one of valid Ogg pattern (vorbis, opus)
-			for (char** tag = (char*[]) { "\x3vorbis", "OpusTags", NULL }; *tag; tag++, offset = 0) {
-				u32_t pos = memfind(stream.ogg.data, stream.ogg.want, *tag, strlen(*tag), &offset);
-				if (offset != strlen(*tag)) continue;
-				
+            // memorize granule for next page
+            if (ogg.header.granule != -1) ogg.granule = ogg.header.granule;            
+			break;
+		case OGG_PAGE: {
+			char** tag = (char* []){ "\x3vorbis", "OpusTags", NULL };
+			size_t ofs = 0;
+
+			/* with OggFlac, we need the next page (packet) - VorbisComment is wrapped into a FLAC_METADATA
+			 * and except with vorbis, comment packet starts a new page but even in vorbis, it won't span
+			 * accross multiple pages */
+			if (ogg.flac) ofs = 4;
+			else if (!memcmp(ogg.data, "\x7f""FLAC", 5)) ogg.flac = true;
+			else for (size_t n = 0; *tag; tag++, ofs = 0) if ((ofs = memfind(ogg.data, ogg.want, *tag, strlen(*tag), &n)) && n == strlen(*tag)) break;
+	
+			if (ofs) {			
 				// u32:len,char[]:vendorId, u32:N, N x (u32:len,char[]:comment)
-				char* p = (char*) stream.ogg.data + pos;
+				char* p = (char*) ogg.data + ofs;
 				p += *p + 4;
 				u32_t count = *p;
 				p += 4;
@@ -256,16 +284,18 @@ static void stream_ogg(size_t n) {
 						stream.header[stream.header_len++] = len;
 						memcpy(stream.header + stream.header_len, p, len);
 						stream.header_len += len;
+                        LOG_INFO("metadata: %.*s", len, p);
 					}
 				}
 
+                ogg.flac = false;
 				stream.meta_send = true;
 				wake_controller();
 				LOG_INFO("Ogg metadata length: %u", stream.header_len - 3);
-				break;
 			}
-			free(stream.ogg.data);
-			stream.ogg.state = STREAM_OGG_SYNC;
+			free(ogg.data);
+            ogg.data = NULL;
+			ogg.state = OGG_SYNC;
 			break;
 		}
         default: 
@@ -603,7 +633,7 @@ void stream_file(const char *header, size_t header_len, unsigned threshold) {
 	UNLOCK;
 }
 
-void stream_sock(u32_t ip, u16_t port, char codec, const char *header, size_t header_len, unsigned threshold, bool cont_wait) {
+void stream_sock(u32_t ip, u16_t port, bool use_ssl, bool use_ogg, const char *header, size_t header_len, unsigned threshold, bool cont_wait) {
 	struct sockaddr_in addr;
 
 #if EMBEDDED
@@ -703,8 +733,9 @@ void stream_sock(u32_t ip, u16_t port, char codec, const char *header, size_t he
 	stream.bytes = 0;
 	stream.threshold = threshold;
     
-    stream.ogg.miss = stream.ogg.match = 0;
-	stream.ogg.state = (codec == 'o' || codec == 'p') ? STREAM_OGG_SYNC : STREAM_OGG_OFF;
+    ogg.miss = ogg.match = 0;
+	ogg.state = use_ogg ? OGG_SYNC : OGG_OFF;
+    ogg.flac = false;
 
 	UNLOCK;
 }
@@ -725,8 +756,8 @@ bool stream_disconnect(void) {
 		disc = true;
 	}
 	stream.state = STOPPED;
-    if (stream.ogg.state == STREAM_OGG_PAGE && stream.ogg.data) free(stream.ogg.data);
-    stream.ogg.data = NULL;
+    if (ogg.state == OGG_PAGE && ogg.data) free(ogg.data);
+    ogg.data = NULL;
 	UNLOCK;
 	return disc;
 }

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

@@ -73,6 +73,10 @@ 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;
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
@@ -223,6 +227,8 @@ 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 let sd: {};
 declare let rf: boolean;
 declare function refreshStatus(): void;

components/wifi-manager/webapp/webapp.cmake

@@ -1,5 +1,5 @@
 target_add_binary_data( __idf_wifi-manager webapp/dist/css/index.4bbe29a78a667faa2b6f.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.105fd5.bundle.js.gz BINARY)
-target_add_binary_data( __idf_wifi-manager webapp/dist/js/node_vendors.105fd5.bundle.js.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/js/index.baf383.bundle.js.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/js/node_vendors.baf383.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_105fd5_bundle_js_gz_start[] asm("_binary_index_105fd5_bundle_js_gz_start");
-extern const uint8_t _index_105fd5_bundle_js_gz_end[] asm("_binary_index_105fd5_bundle_js_gz_end");
-extern const uint8_t _node_vendors_105fd5_bundle_js_gz_start[] asm("_binary_node_vendors_105fd5_bundle_js_gz_start");
-extern const uint8_t _node_vendors_105fd5_bundle_js_gz_end[] asm("_binary_node_vendors_105fd5_bundle_js_gz_end");
+extern const uint8_t _index_baf383_bundle_js_gz_start[] asm("_binary_index_baf383_bundle_js_gz_start");
+extern const uint8_t _index_baf383_bundle_js_gz_end[] asm("_binary_index_baf383_bundle_js_gz_end");
+extern const uint8_t _node_vendors_baf383_bundle_js_gz_start[] asm("_binary_node_vendors_baf383_bundle_js_gz_start");
+extern const uint8_t _node_vendors_baf383_bundle_js_gz_end[] asm("_binary_node_vendors_baf383_bundle_js_gz_end");
 const char * resource_lookups[] = {
 	"/css/index.4bbe29a78a667faa2b6f.css.gz",
 	"/favicon-32x32.png",
 	"/index.html.gz",
-	"/js/index.105fd5.bundle.js.gz",
-	"/js/node_vendors.105fd5.bundle.js.gz",
+	"/js/index.baf383.bundle.js.gz",
+	"/js/node_vendors.baf383.bundle.js.gz",
 ""
 };
 const uint8_t * resource_map_start[] = {
 	_index_4bbe29a78a667faa2b6f_css_gz_start,
 	_favicon_32x32_png_start,
 	_index_html_gz_start,
-	_index_105fd5_bundle_js_gz_start,
-	_node_vendors_105fd5_bundle_js_gz_start
+	_index_baf383_bundle_js_gz_start,
+	_node_vendors_baf383_bundle_js_gz_start
 };
 const uint8_t * resource_map_end[] = {
 	_index_4bbe29a78a667faa2b6f_css_gz_end,
 	_favicon_32x32_png_end,
 	_index_html_gz_end,
-	_index_105fd5_bundle_js_gz_end,
-	_node_vendors_105fd5_bundle_js_gz_end
+	_index_baf383_bundle_js_gz_end,
+	_node_vendors_baf383_bundle_js_gz_end
 };

components/wifi-manager/webapp/webpack.h

@@ -1,6 +1,6 @@
 /***********************************
 webpack_headers
-dist/css/index.4bbe29a78a667faa2b6f.css.gz,dist/favicon-32x32.png,dist/index.html.gz,dist/js/index.105fd5.bundle.js.gz,dist/js/node_vendors.105fd5.bundle.js.gz
+dist/css/index.4bbe29a78a667faa2b6f.css.gz,dist/favicon-32x32.png,dist/index.html.gz,dist/js/index.baf383.bundle.js.gz,dist/js/node_vendors.baf383.bundle.js.gz
 ***********************************/
 #pragma once
 #include <inttypes.h>