Merge branch 'httpd' of github.com:sle118/squeezelite-esp32 into httpd

README.md

@@ -30,7 +30,7 @@ Use the `squeezelite-esp32-I2S-4MFlash-sdkconfig.defaults` configuration file.
 To access NVS, in the webUI, go to credits and select "shows nvs editor". Go into the NVS editor tab to change NFS parameters. In syntax description below \<\> means a value while \[\] describe optional parameters. 
 
 ### I2C
-The NVS parameter "i2c_config" set the i2c's gpio used for generic purpose (e.g. display). Leave it blank to disable I2C usage. Note that on SqueezeAMP, port must be 1. Default speed is 400000. Syntax is
+The NVS parameter "i2c_config" set the i2c's gpio used for generic purpose (e.g. display). Leave it blank to disable I2C usage. Note that on SqueezeAMP, port must be 1. Default speed is 400000 but some display can do up to 800000 or more. Syntax is
 ```
 sda=<gpio>,scl=<gpio>[,port=0|1][,speed=<speed>]
 ```
@@ -62,16 +62,18 @@ I2C,width=<pixels>,height=<pixels>[address=<i2c_address>][,HFlip][,VFlip][driver
 SPI,width=<pixels>,height=<pixels>,cs=<gpio>[,speed=<speed>][,HFlip][,VFlip][driver=SSD1306|SSD1326|SH1106]
 ```
 - VFlip and HFlip are optional can be used to change display orientation
-- Default speed is 8000000 (8MHz)
+- Default speed is 8000000 (8MHz) but SPI can work up to 26MHz or even 40MHz
 
 Currently 128x32/64 I2C display like [this](https://www.buydisplay.com/i2c-blue-0-91-inch-oled-display-module-128x32-arduino-raspberry-pi) and [this](https://www.waveshare.com/wiki/1.3inch_OLED_HAT) are supported
 
 The NVS parameter "metadata_config" sets how metadata is displayed for AirPlay and Bluetooth. Syntax is
 ```
-[format=<display_content>][,speed=<speed>]
+[format=<display_content>][,speed=<speed>][,pause=<pause>]
 ```
 - 'speed' is the scrolling speed in ms (default is 33ms)
 
+- 'pause' is the pause time between scrolls in ms (default is 3600ms)
+
 - 'format' can contain free text and any of the 3 keywords %artist%, %album%, %title%. Using that format string, the keywords are replaced by their value to build the string to be displayed. Note that the plain text following a keyword that happens to be empty during playback of a track will be removed. For example, if you have set format=%artist% - %title% and there is no artist in the metadata then only <title> will be displayed not " - <title>".
 
 ### Set GPIO

components/display/SH1106.c

@@ -17,9 +17,14 @@
 #include "gds_private.h"
 
 #define SHADOW_BUFFER
+#define USE_IRAM
 
 static char TAG[] = "SH1106";
 
+struct SH1106_Private {
+	uint8_t *Shadowbuffer;
+};
+
 // Functions are not declared to minimize # of lines
 
 static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
@@ -35,9 +40,10 @@ static void SetPageAddress( struct GDS_Device* Device, uint8_t Start, uint8_t En
 
 static void Update( struct GDS_Device* Device ) {
 #ifdef SHADOW_BUFFER
+	struct SH1106_Private *Private = (struct SH1106_Private*) Device->Private;
 	// not sure the compiler does not have to redo all calculation in for loops, so local it is
 	int width = Device->Width, rows = Device->Height / 8;
-	uint8_t *optr = Device->Shadowbuffer, *iptr = Device->Framebuffer;
+	uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
 	
 	// by row, find first and last columns that have been updated
 	for (int r = 0; r < rows; r++) {
@@ -54,7 +60,7 @@ static void Update( struct GDS_Device* Device ) {
 		if (first--) {
 			SetColumnAddress( Device, first, last );
 			SetPageAddress( Device, r, r);
-			Device->WriteData( Device, Device->Shadowbuffer + r*width + first, last - first + 1);
+			Device->WriteData( Device, Private->Shadowbuffer + r*width + first, last - first + 1);
 		}
 	}	
 #else	
@@ -79,14 +85,26 @@ static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
 
 static bool Init( struct GDS_Device* Device ) {
 	Device->FramebufferSize = ( Device->Width * Device->Height ) / 8;	
-	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
-    NullCheck( Device->Framebuffer, return false );
 	
+// benchmarks showed little gain to have SPI memory already in IRAL vs letting driver copy		
 #ifdef SHADOW_BUFFER	
-	if (Device->IF == IF_I2C) Device->Shadowbuffer = malloc( Device->FramebufferSize );
-	else Device->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-	NullCheck( Device->Shadowbuffer, return false );
-	memset(Device->Shadowbuffer, 0xFF, Device->FramebufferSize);
+	struct SH1106_Private *Private = (struct SH1106_Private*) Device->Private;
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
+    NullCheck( Device->Framebuffer, return false );
+#ifdef USE_IRAM
+	if (Device->IF == IF_SPI) Private->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+	else 
+#endif
+	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
+	NullCheck( Private->Shadowbuffer, return false );
+	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+#else	// not SHADOW_BUFFER
+#ifdef USE_IRAM
+	// benchmarks showed little gain to have SPI memory already in IRAL vs letting driver copy
+	if (Device->IF == IF_SPI) Device->Framebuffer = heap_caps_calloc( 1, Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+	else 
+#endif
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
 #endif	
 		
 	// need to be off and disable display RAM
@@ -130,8 +148,9 @@ static bool Init( struct GDS_Device* Device ) {
 static const struct GDS_Device SH1106 = {
 	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
 	.SetVFlip = SetVFlip, .SetHFlip = SetHFlip,
-	.DrawPixelFast = GDS_DrawPixelFast,
 	.Update = Update, .Init = Init,
+	//.DrawPixelFast = GDS_DrawPixelFast,
+	//.ClearWindow = ClearWindow,
 };	
 
 struct GDS_Device* SH1106_Detect(char *Driver, struct GDS_Device* Device) {
@@ -139,6 +158,7 @@ struct GDS_Device* SH1106_Detect(char *Driver, struct GDS_Device* Device) {
 	
 	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
 	*Device = SH1106;	
+	Device->Depth = 1;
 	ESP_LOGI(TAG, "SH1106 driver");
 	
 	return Device;

components/display/SSD1306.c

@@ -17,10 +17,15 @@
 #include "gds_private.h"
 
 #define SHADOW_BUFFER
+#define USE_IRAM
 
 static char TAG[] = "SSD1306";
 
-// Functions are not deckared to minimize # of lines
+struct SSD1306_Private {
+	uint8_t *Shadowbuffer;
+};
+
+// Functions are not declared to minimize # of lines
 
 static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
 	Device->WriteCommand( Device, 0x21 );
@@ -35,9 +40,11 @@ static void SetPageAddress( struct GDS_Device* Device, uint8_t Start, uint8_t En
 
 static void Update( struct GDS_Device* Device ) {
 #ifdef SHADOW_BUFFER
+	struct SSD1306_Private *Private = (struct SSD1306_Private*) Device->Private;
 	// not sure the compiler does not have to redo all calculation in for loops, so local it is
 	int width = Device->Width, rows = Device->Height / 8;
-	uint8_t *optr = Device->Shadowbuffer, *iptr = Device->Framebuffer;
+	uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
+	int CurrentRow = -1, FirstCol = -1, LastCol = -1;
 	
 	// by row, find first and last columns that have been updated
 	for (int r = 0; r < rows; r++) {
@@ -52,9 +59,22 @@ static void Update( struct GDS_Device* Device ) {
 		
 		// now update the display by "byte rows"
 		if (first--) {
-			SetColumnAddress( Device, first, last );
-			SetPageAddress( Device, r, r);
-			Device->WriteData( Device, Device->Shadowbuffer + r*width + first, last - first + 1);
+			// only set column when useful, saves a fair bit of CPU
+			if (first > FirstCol && first <= FirstCol + 4 && last < LastCol && last >= LastCol - 4) {
+				first = FirstCol;
+				last = LastCol;
+			} else {	
+				SetColumnAddress( Device, first, last );
+				FirstCol = first;
+				LastCol = last;
+			}
+			
+			// Set row only when needed, otherwise let auto-increment work
+			if (r != CurrentRow) SetPageAddress( Device, r, Device->Height / 8 - 1 );
+			CurrentRow = r + 1;
+			
+			// actual write
+			Device->WriteData( Device, Private->Shadowbuffer + r*width + first, last - first + 1);
 		}
 	}	
 #else	
@@ -77,14 +97,26 @@ static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
 
 static bool Init( struct GDS_Device* Device ) {
 	Device->FramebufferSize = ( Device->Width * Device->Height ) / 8;	
-	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
-    NullCheck( Device->Framebuffer, return false );
 	
+	// benchmarks showed little gain to have SPI memory already in IRAL vs letting driver copy		
 #ifdef SHADOW_BUFFER	
-	if (Device->IF == IF_I2C) Device->Shadowbuffer = malloc( Device->FramebufferSize );
-	else Device->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-	NullCheck( Device->Shadowbuffer, return false );
-	memset(Device->Shadowbuffer, 0xFF, Device->FramebufferSize);
+	struct SSD1306_Private *Private = (struct SSD1306_Private*) Device->Private;
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
+    NullCheck( Device->Framebuffer, return false );
+#ifdef USE_IRAM
+	if (Device->IF == IF_SPI) Private->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+	else 
+#endif
+	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
+	NullCheck( Private->Shadowbuffer, return false );
+	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+#else	// not SHADOW_BUFFER
+#ifdef USE_IRAM
+	// benchmarks showed little gain to have SPI memory already in IRAL vs letting driver copy
+	if (Device->IF == IF_SPI) Device->Framebuffer = heap_caps_calloc( 1, Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+	else 
+#endif
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
 #endif	
 		
 	// need to be off and disable display RAM
@@ -95,7 +127,7 @@ static bool Init( struct GDS_Device* Device ) {
 	Device->WriteCommand( Device, 0x8D );
 	Device->WriteCommand( Device, 0x14 ); 
 			
-	// COM pins HW config (alternative:EN if 64, DIS if 32, remap:DIS) - some display might need something difference
+	// COM pins HW config (alternative:EN if 64, DIS if 32, remap:DIS) - some display might need something different
 	Device->WriteCommand( Device, 0xDA );
 	Device->WriteCommand( Device, ((Device->Height == 64 ? 1 : 0) << 4) | (0 < 5) );
 		
@@ -131,8 +163,9 @@ static bool Init( struct GDS_Device* Device ) {
 static const struct GDS_Device SSD1306 = {
 	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
 	.SetVFlip = SetVFlip, .SetHFlip = SetHFlip,
-	.DrawPixelFast = GDS_DrawPixelFast,
 	.Update = Update, .Init = Init,
+	//.DrawPixelFast = GDS_DrawPixelFast,
+	//.ClearWindow = ClearWindow,
 };	
 
 struct GDS_Device* SSD1306_Detect(char *Driver, struct GDS_Device* Device) {
@@ -140,6 +173,7 @@ struct GDS_Device* SSD1306_Detect(char *Driver, struct GDS_Device* Device) {
 	
 	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
 	*Device = SSD1306;	
+	Device->Depth = 1;
 	ESP_LOGI(TAG, "SSD1306 driver");
 	
 	return Device;

components/display/SSD132x.c

@@ -0,0 +1,341 @@
+/**
+ * Copyright (c) 2017-2018 Tara Keeling
+ *				 2020 Philippe G.
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <esp_heap_caps.h>
+#include <esp_log.h>
+
+#include "gds.h"
+#include "gds_private.h"
+
+#define SHADOW_BUFFER
+#define USE_IRAM
+#define PAGE_BLOCK	1024
+
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+
+static char TAG[] = "SSD132x";
+
+enum { SSD1326, SSD1327 };
+
+struct SSD132x_Private {
+	uint8_t *iRAM, *Shadowbuffer;
+	uint8_t ReMap, PageSize;
+	uint8_t Model;
+};
+
+static const unsigned char BitReverseTable256[] = 
+{
+  0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, 
+  0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 
+  0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 
+  0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 
+  0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 
+  0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
+  0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, 
+  0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
+  0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
+  0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, 
+  0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
+  0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
+  0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, 
+  0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+  0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 
+  0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+};
+
+// Functions are not declared to minimize # of lines
+
+static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
+	Device->WriteCommand( Device, 0x15 );
+	Device->WriteCommand( Device, Start );
+	Device->WriteCommand( Device, End );
+}
+static void SetRowAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
+	// can be by row, not by page (see Update Optimization)
+	Device->WriteCommand( Device, 0x75 );
+	Device->WriteCommand( Device, Start );
+	Device->WriteCommand( Device, End );
+}
+
+static void Update4( struct GDS_Device* Device ) {
+	struct SSD132x_Private *Private = (struct SSD132x_Private*) Device->Private;
+		
+	// always update by full lines
+	SetColumnAddress( Device, 0, Device->Width / 2 - 1);
+	
+#ifdef SHADOW_BUFFER
+	uint16_t *optr = (uint16_t*) Private->Shadowbuffer, *iptr = (uint16_t*) Device->Framebuffer;
+	bool dirty = false;
+	
+	for (int r = 0, page = 0; r < Device->Height; r++) {
+		// look for change and update shadow (cheap optimization = width always / by 2)
+		for (int c = Device->Width / 2 / 2; --c >= 0;) {
+			if (*optr != *iptr) {
+				dirty = true;
+				*optr = *iptr;
+			}
+			iptr++; optr++;
+		}
+		
+		// one line done, check for page boundary
+		if (++page == Private->PageSize) {
+			if (dirty) {
+				SetRowAddress( Device, r - page + 1, r );
+				// own use of IRAM has not proven to be much better than letting SPI do its copy
+				if (Private->iRAM) {
+					memcpy(Private->iRAM, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2 );
+					Device->WriteData( Device, Private->iRAM, Device->Width * page / 2 );
+				} else	{
+					Device->WriteData( Device, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2 );					
+				}	
+				dirty = false;
+			}	
+			page = 0;
+		}	
+	}	
+#else
+	for (int r = 0; r < Device->Height; r += Private->PageSize) {
+		SetRowAddress( Device, r, r + Private->PageSize - 1 );
+		if (Private->iRAM) {
+			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
+			Device->WriteData( Device, Private->iRAM, Private->PageSize * Device->Width / 2 );
+		} else	{
+			Device->WriteData( Device, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
+		}	
+	}	
+#endif	
+}
+
+/* 
+ We have to make a choice here: either we go by row one by one and send lots of 
+ small packets on the serial interface or we do a page of N rows once at least
+ a change has been detected. So far, choice is to go one-by-one
+*/ 
+static void Update1( struct GDS_Device* Device ) {
+#ifdef SHADOW_BUFFER
+	struct SSD132x_Private *Private = (struct SSD132x_Private*) Device->Private;
+	// not sure the compiler does not have to redo all calculation in for loops, so local it is
+	int width = Device->Width / 8, rows = Device->Height;
+	uint8_t *optr = Private->Shadowbuffer, *iptr = Device->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--) {
+			SetColumnAddress( Device, first, last );
+			SetRowAddress( Device, r, r);
+			Device->WriteData( Device, Private->Shadowbuffer + r*width + first, last - first + 1);
+		}
+	}	
+#else	
+	// automatic counter and end Row/Column
+	SetColumnAddress( Device, 0, Device->Width / 8 - 1);
+	SetRowAddress( Device, 0, Device->Height - 1);
+	Device->WriteData( Device, Device->Framebuffer, Device->FramebufferSize );
+#endif	
+}
+
+// in 1 bit mode, SSD1326 has a different memory map than SSD1306 and SH1106
+static void IRAM_ATTR DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+    uint32_t XBit = ( X & 0x07 );
+    uint8_t* FBOffset = Device->Framebuffer + ( ( Y * Device->Width + X ) >> 3 );
+
+    if ( Color == GDS_COLOR_XOR ) {
+        *FBOffset ^= BIT( 7 - XBit );
+    } else {
+		// we might be able to save the 7-Xbit using BitRemap (A0 bit 2)
+        *FBOffset = ( Color == GDS_COLOR_WHITE ) ? *FBOffset | BIT( 7 - XBit ) : *FBOffset & ~BIT( 7 - XBit );
+    }
+}
+
+static void ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color ) {
+	uint8_t _Color = Color == GDS_COLOR_BLACK ? 0: 0xff;
+	uint8_t Width = Device->Width >> 3;
+	uint8_t *optr = Device->Framebuffer;
+
+	for (int r = y1; r <= y2; r++) {
+		int c = x1;
+		// for a row that is not on a boundary, not column opt can be done, so handle all columns on that line
+		while (c & 0x07 && c <= x2) DrawPixel1Fast( Device, c++, r, Color );
+		// at this point we are aligned on column boundary
+		int chunk = (x2 - c + 1) >> 3;
+		memset(optr + Width * r + (c >> 3), _Color, chunk );
+		c += chunk * 8;
+		while (c <= x2) DrawPixel1Fast( Device, c++, r, Color );
+	}
+	
+	Device->Dirty = true;
+}
+
+static void DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color ) {
+	uint8_t *optr = Device->Framebuffer;
+	
+	if (!Height) Height = Device->Height;
+	if (!Width) Width = Device->Width;
+	
+	// just do bitreverse and if BitRemap works, there will be even nothing to do	
+	for (int i = Height * Width >> 3; --i >= 0;) *optr++ = BitReverseTable256[*Data++];
+	
+	// Dirty is set for us
+}
+
+static void SetHFlip( struct GDS_Device* Device, bool On ) { 
+	struct SSD132x_Private *Private = (struct SSD132x_Private*) Device->Private;
+	if (Private->Model == SSD1326) Private->ReMap = On ? (Private->ReMap | ((1 << 0) | (1 << 2))) : (Private->ReMap & ~((1 << 0) | (1 << 2)));
+	else Private->ReMap = On ? (Private->ReMap | ((1 << 0) | (1 << 1))) : (Private->ReMap & ~((1 << 0) | (1 << 1)));
+	Device->WriteCommand( Device, 0xA0 );
+	Device->WriteCommand( Device, Private->ReMap );
+}	
+
+static void SetVFlip( struct GDS_Device *Device, bool On ) { 
+	struct SSD132x_Private *Private = (struct SSD132x_Private*) Device->Private;
+	if (Private->Model == SSD1326) Private->ReMap = On ? (Private->ReMap | (1 << 1)) : (Private->ReMap & ~(1 << 1));
+	else Private->ReMap = On ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
+	Device->WriteCommand( Device, 0xA0 );
+	Device->WriteCommand( Device, Private->ReMap );
+}	
+	
+static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAF ); }
+static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAE ); }
+
+static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
+    Device->WriteCommand( Device, 0x81 );
+    Device->WriteCommand( Device, Contrast );
+}
+
+static bool Init( struct GDS_Device* Device ) {
+	struct SSD132x_Private *Private = (struct SSD132x_Private*) Device->Private;
+	
+	// find a page size that is not too small is an integer of height
+	Private->PageSize = min(8, PAGE_BLOCK / (Device->Width / 2));
+	Private->PageSize = Device->Height / (Device->Height / Private->PageSize) ;	
+	
+#ifdef USE_IRAM	
+	// let SPI driver allocate memory, it has not proven to be more efficient
+	if (Device->IF == IF_SPI) Private->iRAM = heap_caps_malloc( Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+#endif	
+	Device->FramebufferSize = ( Device->Width * Device->Height ) / 2;	
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
+    NullCheck( Device->Framebuffer, return false );
+	
+// benchmarks showed little gain to have SPI memory already in IRAM vs letting driver copy		
+#ifdef SHADOW_BUFFER	
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
+    NullCheck( Device->Framebuffer, return false );
+#ifdef USE_IRAM
+	if (Device->IF == IF_SPI) {
+		if (Device->Depth == 1) {
+			Private->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+		} else {
+			Private->Shadowbuffer = malloc( Device->FramebufferSize );	
+			Private->iRAM = heap_caps_malloc( Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+		}	
+	} else
+#endif
+	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
+	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+#else	// not SHADOW_BUFFER
+#ifdef USE_IRAM
+	if (Device->IF == IF_SPI) {
+		if (Device->Depth == 1) {
+			Device->Framebuffer = heap_caps_calloc( 1, Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+		} else  {
+			Device->Framebuffer = calloc( 1, Device->FramebufferSize );	
+			Private->iRAM = heap_caps_malloc( Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+		}
+	} else 
+#endif	
+	Device->Framebuffer = calloc( 1, Device->FramebufferSize );
+#endif	
+
+	ESP_LOGI(TAG, "SSD1326/7 with bit depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
+			
+	// need to be off and disable display RAM
+	Device->DisplayOff( Device );
+    Device->WriteCommand( Device, 0xA5 );
+	
+	// need COM split (6)
+	Private->ReMap = 1 << 6;
+	// MUX Ratio
+    Device->WriteCommand( Device, 0xA8 );
+    Device->WriteCommand( Device, Device->Height - 1);
+	// Display Offset
+    Device->WriteCommand( Device, 0xA2 );
+    Device->WriteCommand( Device, 0 );
+	// Display Start Line
+    Device->WriteCommand( Device, 0xA1 );
+	Device->WriteCommand( Device, 0x00 );
+	Device->SetContrast( Device, 0x7F );
+	// set flip modes
+	Device->SetVFlip( Device, false );
+	Device->SetHFlip( Device, false );
+	// no Display Inversion
+    Device->WriteCommand( Device, 0xA6 );
+	// set Clocks
+    Device->WriteCommand( Device, 0xB3 );
+    Device->WriteCommand( Device, ( 0x08 << 4 ) | 0x00 );
+	// set Adressing Mode Horizontal
+	Private->ReMap |= (0 << 2);
+	// set monotchrome mode if required
+	if (Device->Depth == 1) Private->ReMap |= (1 << 4);
+	// write ReMap byte
+	Device->WriteCommand( Device, 0xA0 );
+	Device->WriteCommand( Device, Private->ReMap );		
+		
+	// gone with the wind
+	Device->WriteCommand( Device, 0xA4 );
+	Device->DisplayOn( Device );
+	Device->Update( Device );
+	
+	return true;
+}	
+
+static const struct GDS_Device SSD132x = {
+	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
+	.SetVFlip = SetVFlip, .SetHFlip = SetHFlip,
+	.Update = Update4, .Init = Init,
+};	
+
+struct GDS_Device* SSD132x_Detect(char *Driver, struct GDS_Device* Device) {
+	uint8_t Model;
+	
+	if (!strcasestr(Driver, "SSD1326")) Model = SSD1326;
+	else if (!strcasestr(Driver, "SSD1327")) Model = SSD1327;
+	else return NULL;
+	
+	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
+	
+	*Device = SSD132x;	
+	((struct SSD132x_Private*) Device->Private)->Model = Model;
+	
+	sscanf(Driver, "%*[^:]:%c", &Device->Depth);
+	
+	if (Model == SSD1326 && Device->Depth == 1) {
+		Device->Update = Update1;
+		Device->DrawPixelFast = DrawPixel1Fast;
+		Device->DrawBitmapCBR = DrawBitmapCBR;
+		Device->ClearWindow = ClearWindow;
+	} else {
+		Device->Depth = 4;
+	}	
+		
+	return Device;
+}

components/display/core/gds.c

@@ -21,7 +21,7 @@ static struct GDS_Device Display;
 
 static char TAG[] = "gds";
 
-struct GDS_Device*	GDS_AutoDetect( char *Driver, GDS_DetectFunc DetectFunc[] ) {
+struct GDS_Device* GDS_AutoDetect( char *Driver, GDS_DetectFunc* DetectFunc[] ) {
 	for (int i = 0; DetectFunc[i]; i++) {
 		if (DetectFunc[i](Driver, &Display)) {
 			ESP_LOGD(TAG, "Detected driver %p", &Display);
@@ -53,20 +53,69 @@ void GDS_ClearExt(struct GDS_Device* Device, bool full, ...) {
 }	
 
 void GDS_Clear( struct GDS_Device* Device, int Color ) {
+	if (Device->Depth == 1) Color = Color == GDS_COLOR_BLACK ? 0 : 0xff;
+	else if (Device->Depth == 4) Color = Color | (Color << 4);
     memset( Device->Framebuffer, Color, Device->FramebufferSize );
+	Device->Dirty = true;
 }
 
 void GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color ) {
-	// cheap optimization on boundaries
-	if (x1 == 0 && x2 == Device->Width - 1 && y1 % 8 == 0 && (y2 + 1) % 8 == 0) {
-		memset( Device->Framebuffer + (y1 / 8) * Device->Width, 0, (y2 - y1 + 1) / 8 * Device->Width );
+	// driver can provide own optimized clear window
+	if (Device->ClearWindow) {
+		Device->ClearWindow( Device, x1, y1, x2, y2, Color );
+	} else if (Device->Depth == 1) {
+		// single shot if we erase all screen
+		if (x2 - x1 == Device->Width - 1 && y2 - y1 == Device->Height - 1) {
+			memset( Device->Framebuffer, Color == GDS_COLOR_BLACK ? 0 : 0xff, Device->FramebufferSize );
+		} else {
+			uint8_t _Color = Color == GDS_COLOR_BLACK ? 0: 0xff;
+			uint8_t Width = Device->Width >> 3;
+			uint8_t *optr = Device->Framebuffer;
+			// try to do byte processing as much as possible
+			for (int r = y1; r <= y2;) {
+				int c = x1;
+				// for a row that is not on a boundary, no optimization possible
+				while (r & 0x07 && r <= y2) {
+					for (c = x1; c <= x2; c++) GDS_DrawPixelFast( Device, c, r, Color );
+					r++;
+				}
+				// go fast if we have more than 8 lines to write
+				if (r + 8 <= y2) {
+					memset(optr + Width * r + x1, _Color, x2 - x1 + 1);
+					r += 8;
+				} else while (r <= y2) {
+					for (c = x1; c <= x2; c++) GDS_DrawPixelFast( Device, c, r, Color );
+					r++;
+				}
+			}
+		}
+	} if (Device->Depth == 4) {
+		if (x2 - x1 == Device->Width - 1 && y2 - y1 == Device->Height - 1) {
+			// we assume color is 0..15
+			memset( Device->Framebuffer, Color | (Color << 4), Device->FramebufferSize );
+		} else {
+			uint8_t _Color = Color | (Color << 4);
+			uint8_t Width = Device->Width;
+			uint8_t *optr = Device->Framebuffer;
+			// try to do byte processing as much as possible
+			for (int r = y1; r <= y2; r++) {
+				int c = x1;
+				if (c & 0x01) GDS_DrawPixelFast( Device, c++, r, Color);
+				int chunk = (x2 - c + 1) >> 1;
+				memset(optr + ((r * Width + c)  >> 1), _Color, chunk);
+				if (c + chunk <= x2) GDS_DrawPixelFast( Device, x2, r, Color);
+			}
+		}	
 	} else {
 		for (int y = y1; y <= y2; y++) {
 			for (int x = x1; x <= x2; x++) {
-				Device->DrawPixelFast( Device, x, y, Color);
-			}		
-		}	
-	}	
+				GDS_DrawPixelFast( Device, x, y, Color);
+			}
+		}
+	}
+
+	// make sure diplay will do update
+	Device->Dirty = true;
 }
 
 void GDS_Update( struct GDS_Device* Device ) {

components/display/core/gds.h

@@ -4,16 +4,30 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-#define GDS_COLOR_BLACK 0
-#define GDS_COLOR_WHITE 1
-#define GDS_COLOR_XOR 2
+/* NOTE for drivers:
+ The build-in DrawPixel(Fast), DrawCBR and ClearWindow are optimized for 1 bit 
+ and 4 bits screen depth. For any other type of screen, DrawCBR and ClearWindow
+ default to use DrawPixel, which is very sub-optimal. For such other depth, you 
+ must supply the DrawPixelFast. The built-in 1 bit depth function are only for 
+ screen with vertical framing (1 byte = 8 lines). For example SSD1326 in 
+ monochrome mode is not such type of screen, SH1106 and SSD1306 are
+*/ 
+
+enum { 	GDS_COLOR_L0 = 0, GDS_COLOR_L1 = 1, GDS_COLOR_L2, GDS_COLOR_L3, GDS_COLOR_L4, GDS_COLOR_L5, GDS_COLOR_L6, GDS_COLOR_L7, 
+		GDS_COLOR_L8, GDS_COLOR_L9, GDS_COLOR_L10, GDS_COLOR_L11, GDS_COLOR_L12, GDS_COLOR_L13, GDS_COLOR_L14, GDS_COLOR_L15,
+		GDS_COLOR_MAX
+};
+		
+#define GDS_COLOR_BLACK GDS_COLOR_L0
+#define GDS_COLOR_WHITE GDS_COLOR_L1
+#define GDS_COLOR_XOR 	(GDS_COLOR_MAX + 1)
 
 struct GDS_Device;
 struct GDS_FontDef;
 
-typedef struct GDS_Device* (*GDS_DetectFunc)(char *Driver, struct GDS_Device *Device);
+typedef struct GDS_Device* GDS_DetectFunc(char *Driver, struct GDS_Device *Device);
 
-struct GDS_Device*	GDS_AutoDetect( char *Driver, GDS_DetectFunc[] );
+struct GDS_Device*	GDS_AutoDetect( char *Driver, GDS_DetectFunc* DetectFunc[] );
 
 void 	GDS_SetContrast( struct GDS_Device* Device, uint8_t Contrast );
 void 	GDS_DisplayOn( struct GDS_Device* Device );

components/display/core/gds_default_if.h

@@ -7,7 +7,7 @@ extern "C" {
 
 struct GDS_Device;
 
-bool GDS_I2CInit( int PortNumber, int SDA, int SCL );
+bool GDS_I2CInit( int PortNumber, int SDA, int SCL, int speed );
 bool GDS_I2CAttachDevice( struct GDS_Device* Device, int Width, int Height, int I2CAddress, int RSTPin );
 
 bool GDS_SPIInit( int SPI, int DC );

components/display/core/gds_draw.c

@@ -14,8 +14,8 @@
 #include <math.h>
 #include <esp_attr.h>
 
-#include "gds.h"
 #include "gds_private.h"
+#include "gds.h"
 #include "gds_draw.h"
 
 static const unsigned char BitReverseTable256[] = 
@@ -45,49 +45,11 @@ __attribute__( ( always_inline ) ) static inline void SwapInt( int* a, int* b )
     *a = Temp;
 }
 
-inline void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
-    uint32_t YBit = ( Y & 0x07 );
-    uint8_t* FBOffset = NULL;
-
-    /* 
-     * We only need to modify the Y coordinate since the pitch
-     * of the screen is the same as the width.
-     * Dividing Y by 8 gives us which row the pixel is in but not
-     * the bit position.
-     */
-    Y>>= 3;
-
-    FBOffset = Device->Framebuffer + ( ( Y * Device->Width ) + X );
-
-    if ( Color == GDS_COLOR_XOR ) {
-        *FBOffset ^= BIT( YBit );
-    } else {
-        *FBOffset = ( Color == GDS_COLOR_WHITE ) ? *FBOffset | BIT( YBit ) : *FBOffset & ~BIT( YBit );
-    }
-}
-
-inline void IRAM_ATTR GDS_DrawPixel4Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-    uint32_t YBit = ( Y & 0x07 );
-    uint8_t* FBOffset = NULL;
+// un-comment if need to be instanciated for external callers
+extern inline void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color );
+extern inline void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int X, int Y, int Color );
 
-    /* 
-     * We only need to modify the Y coordinate since the pitch
-     * of the screen is the same as the width.
-     * Dividing Y by 8 gives us which row the pixel is in but not
-     * the bit position.
-     */
-    Y>>= 3;
-
-    FBOffset = Device->Framebuffer + ( ( Y * Device->Width ) + X );
-
-    if ( Color == GDS_COLOR_XOR ) {
-        *FBOffset ^= BIT( YBit );
-    } else {
-        *FBOffset = ( Color == GDS_COLOR_WHITE ) ? *FBOffset | BIT( YBit ) : *FBOffset & ~BIT( YBit );
-    }
-}
-
-void IRAM_ATTR GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color ) {
+void GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color ) {
     int XEnd = x + Width;
 
 	Device->Dirty = true;
@@ -98,30 +60,24 @@ void IRAM_ATTR GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width
 	if (y < 0) y = 0;
 	else if (y >= Device->Height) x = Device->Height - 1;
 
-    for ( ; x < XEnd; x++ ) {
-        if ( IsPixelVisible( Device, x, y ) == true ) {
-            Device->DrawPixelFast( Device, x, y, Color );
-        } else {
-            break;
-        }
-    }
+    for ( ; x < XEnd; x++ ) GDS_DrawPixelFast( Device, x, y, Color );
 }
 
-void IRAM_ATTR GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color ) {
+void GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color ) {
     int YEnd = y + Height;
 
 	Device->Dirty = true;
+	
+	if (x < 0) x = 0;
+	if (x >= Device->Width) x = Device->Width - 1;
+	
+	if (y < 0) y = 0;
+	else if (YEnd >= Device->Height) YEnd = Device->Height - 1;
 
-    for ( ; y < YEnd; y++ ) {
-        if ( IsPixelVisible( Device, x, y ) == true ) {
-            GDS_DrawPixel( Device, x, y, Color );
-        } else {
-            break;
-        }
-    }
+    for ( ; y < YEnd; y++ ) GDS_DrawPixel( Device, x, y, Color );
 }
 
-static inline void IRAM_ATTR DrawWideLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
+static inline void DrawWideLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
     int dx = ( x1 - x0 );
     int dy = ( y1 - y0 );
     int Error = 0;
@@ -138,7 +94,7 @@ static inline void IRAM_ATTR DrawWideLine( struct GDS_Device* Device, int x0, in
 
     for ( ; x < x1; x++ ) {
         if ( IsPixelVisible( Device, x, y ) == true ) {
-            Device->DrawPixelFast( Device, x, y, Color );
+            GDS_DrawPixelFast( Device, x, y, Color );
         }
 
         if ( Error > 0 ) {
@@ -150,7 +106,7 @@ static inline void IRAM_ATTR DrawWideLine( struct GDS_Device* Device, int x0, in
     }
 }
 
-static inline void IRAM_ATTR DrawTallLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
+static inline void DrawTallLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
     int dx = ( x1 - x0 );
     int dy = ( y1 - y0 );
     int Error = 0;
@@ -167,7 +123,7 @@ static inline void IRAM_ATTR DrawTallLine( struct GDS_Device* Device, int x0, in
 
     for ( ; y < y1; y++ ) {
         if ( IsPixelVisible( Device, x, y ) == true ) {
-            Device->DrawPixelFast( Device, x, y, Color );
+            GDS_DrawPixelFast( Device, x, y, Color );
         }
 
         if ( Error > 0 ) {
@@ -179,7 +135,7 @@ static inline void IRAM_ATTR DrawTallLine( struct GDS_Device* Device, int x0, in
     }
 }
 
-void IRAM_ATTR GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
+void GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
     if ( x0 == x1 ) {
         GDS_DrawVLine( Device, x0, y0, ( y1 - y0 ), Color );
     } else if ( y0 == y1 ) {
@@ -206,7 +162,7 @@ void IRAM_ATTR GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1,
     }
 }
 
-void IRAM_ATTR GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill ) {
+void GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill ) {
     int Width = ( x2 - x1 );
     int Height = ( y2 - y1 );
 
@@ -236,57 +192,80 @@ void IRAM_ATTR GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, i
 /****************************************************************************************
  * Process graphic display data from column-oriented data (MSbit first)
  */
-void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int Height) {
+void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color ) {
 	if (!Height) Height = Device->Height;
 	if (!Width) Width = Device->Width;
-
-	// need to do row/col swap and bit-reverse
-	int Rows = Height / 8;
-	for (int r = 0; r < Rows; r++) {
-		uint8_t *optr = Device->Framebuffer + r*Device->Width, *iptr = Data + r;
-		for (int c = Width; --c >= 0;) {
-			*optr++ = BitReverseTable256[*iptr];;
-			iptr += Rows;
-		}	
-	}
-	
-	Device->Dirty = true;
-}
-
-/****************************************************************************************
- * Process graphic display data MSBit first
- * WARNING: this has not been tested yet
- */
- /*
-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
-	// same comment about bit depth
-	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) {
-			// 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++ = MSb ? BitReverseTable256[*iptr] : *iptr;
-					iptr += (y2-y1)/8 + 1;
+	Height >>= 3;
+		
+	if (Device->DrawBitmapCBR) {
+		Device->DrawBitmapCBR( Device, Data, Width, Height, Color );
+	} else if (Device->Depth == 1) {
+		// need to do row/col swap and bit-reverse
+		for (int r = 0; r < Height; r++) {
+			uint8_t *optr = Device->Framebuffer + r*Device->Width, *iptr = Data + r;
+			for (int c = Width; --c >= 0;) {
+				*optr++ = BitReverseTable256[*iptr];
+				iptr += Height;
 			}	
+		}
+	} else if (Device->Depth == 4)	{
+		uint8_t *optr = Device->Framebuffer;
+		int LineLen = Device->Width >> 1;
+		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+			uint8_t Byte = BitReverseTable256[*Data++];
+			// we need to linearize code to let compiler better optimize
+			if (c & 0x01) {
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
+			} else {
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
+				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
 			}	
-		} else {
-			// just copy the window inside the frame buffer
-			for (int r = y1/8; r <= y2/8; r++) {
-				uint8_t *optr = Display.Framebuffer + r*Display.Width + x1, *iptr = data + r*(x2-x1+1);
-				for (int c = x1; c <= x2; c++) *optr++ = *iptr++;
-			}	
+			// end of a column, move to next one
+			if (++r == Height) { c++; r = 0; optr = Device->Framebuffer + (c >> 1); }		
 		}
-	}	
-}
-*/
+	} else {
+		// don't know bitdepth, use brute-force solution
+		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+			uint8_t Byte = *Data++;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 7, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 6, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 5, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 4, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 3, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 2, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 1, (Byte & 0x01) * Color ); Byte >>= 1;
+			GDS_DrawPixelFast( Device, c, (r << 3) + 0, (Byte & 0x01) * Color ); 
+			if (++r == Height) { c++; r = 0; }			
+		}
+		/* for better understanding, here is the mundane version 
+		for (int x = 0; x < Width; x++) {
+			for (int y = 0; y < Height; y++) {
+				uint8_t Byte = *Data++;
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 0, ((Byte >> 7) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 1, ((Byte >> 6) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 2, ((Byte >> 5) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 3, ((Byte >> 4) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 4, ((Byte >> 3) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 5, ((Byte >> 2) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 6, ((Byte >> 1) & 0x01) * Color );
+				GDS_DrawPixel4Fast( Device, x, y * 8 + 7, ((Byte >> 0) & 0x01) * Color );
+			}
+		}
+		*/
+	}
+	
+	Device->Dirty = true;
+}

components/display/core/gds_draw.h

@@ -9,15 +9,17 @@
 extern "C" {
 #endif
 
-struct GDS_Device;
-
-void IRAM_ATTR GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color );
-void IRAM_ATTR GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color );
-void IRAM_ATTR GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color );
-void IRAM_ATTR GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill );
+#ifndef _GDS_PRIVATE_H_
+void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color );
+void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int X, int Y, int Color );
+#endif
+void GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color );
+void GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color );
+void GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color );
+void GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill );
 
-// draw a bitmap with source 1-bit depth organized in column and col0 = bit7 of byte 0
-void IRAM_ATTR GDS_DrawBitmapCBR( struct GDS_Device* Device, uint8_t *Data, int Width, int Height);
+// draw a bitmap with source 1-bit depth organized in column and col0 = bit7 of byte 0 
+void GDS_DrawBitmapCBR( struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color);
 
 #ifdef __cplusplus
 }

components/display/core/gds_font.c

@@ -9,10 +9,10 @@
 #include <string.h>
 #include <stdint.h>
 #include <math.h>
+#include "gds_private.h"
 #include "gds.h"
-#include "gds_draw.h"
 #include "gds_font.h"
-#include "gds_private.h"
+#include "gds_draw.h"
 #include "gds_err.h"
 
 static int RoundUpFontHeight( const struct GDS_FontDef* Font ) {

components/display/core/gds_image.c

@@ -0,0 +1,241 @@
+#include <string.h>
+#include "math.h"
+#include "esp32/rom/tjpgd.h"
+#include "esp_log.h"
+
+#include "gds.h"
+#include "gds_private.h"
+#include "gds_image.h"
+
+const char TAG[] = "ImageDec";
+
+#define SCRATCH_SIZE	3100
+
+//Data that is passed from the decoder function to the infunc/outfunc functions.
+typedef struct {
+    const unsigned char *InData;	// Pointer to jpeg data
+    int InPos;						// Current position in jpeg data
+	int Width, Height;	
+	union {
+		uint16_t *OutData;				// Decompress
+		struct {						// DirectDraw
+			struct GDS_Device * Device;
+			int XOfs, YOfs;
+			int XMin, YMin;
+			int Depth;
+		};	
+	};	
+} JpegCtx;
+
+static unsigned InHandler(JDEC *Decoder, uint8_t *Buf, unsigned Len) {
+    JpegCtx *Context = (JpegCtx*) Decoder->device;
+    if (Buf) memcpy(Buf, Context->InData +  Context->InPos, Len);
+    Context->InPos += Len;
+    return Len;
+}
+
+static unsigned OutHandler(JDEC *Decoder, void *Bitmap, JRECT *Frame) {
+	JpegCtx *Context = (JpegCtx*) Decoder->device;
+    uint8_t *Pixels = (uint8_t*) Bitmap;
+	
+    for (int y = Frame->top; y <= Frame->bottom; y++) {
+        for (int x = Frame->left; x <= Frame->right; x++) {
+            // Convert the 888 to RGB565
+            uint16_t Value = (*Pixels++ & ~0x07) << 8;
+            Value |= (*Pixels++ & ~0x03) << 3;
+            Value |= *Pixels++ >> 3;
+            Context->OutData[Context->Width * y + x] = Value;
+        }
+    }
+    return 1;
+}
+
+static unsigned OutHandlerDirect(JDEC *Decoder, void *Bitmap, JRECT *Frame) {
+	JpegCtx *Context = (JpegCtx*) Decoder->device;
+    uint8_t *Pixels = (uint8_t*) Bitmap;
+	int Shift = 8 - Context->Depth;
+	
+    for (int y = Frame->top; y <= Frame->bottom; y++) {
+		if (y < Context->YMin) continue;
+        for (int x = Frame->left; x <= Frame->right; x++) {
+			if (x < Context->XMin) continue;
+            // Convert the 888 to RGB565
+            int Value = ((Pixels[0]*11 + Pixels[1]*59 + Pixels[2]*30) / 100) >> Shift;
+			Pixels += 3;
+			// used DrawPixel and not "fast" version as X,Y may be beyond screen
+			GDS_DrawPixel( Context->Device, x + Context->XOfs, y + Context->YOfs, Value);
+        }
+    }
+    return 1;
+}
+
+//Decode the embedded image into pixel lines that can be used with the rest of the logic.
+static uint16_t* DecodeJPEG(uint8_t *Source, int *Width, int *Height, float Scale, bool SizeOnly) {
+    JDEC Decoder;
+    JpegCtx Context;
+	char *Scratch = calloc(SCRATCH_SIZE, 1);
+	
+    if (!Scratch) {
+        ESP_LOGE(TAG, "Cannot allocate workspace");
+        return NULL;
+    }
+
+	Context.OutData = NULL;
+    Context.InData = Source;
+    Context.InPos = 0;
+	        
+    //Prepare and decode the jpeg.
+    int Res = jd_prepare(&Decoder, InHandler, Scratch, SCRATCH_SIZE, (void*) &Context);
+	if (Width) *Width = Decoder.width;
+	if (Height) *Height = Decoder.height;
+	Decoder.scale = Scale;
+
+    if (Res == JDR_OK && !SizeOnly) {
+		Context.OutData = malloc(Decoder.width * Decoder.height * sizeof(uint16_t));
+		
+		// find the scaling factor
+		uint8_t N = 0, ScaleInt =  ceil(1.0 / Scale);
+		ScaleInt--; ScaleInt |= ScaleInt >> 1; ScaleInt |= ScaleInt >> 2; ScaleInt++;
+		while (ScaleInt >>= 1) N++;
+		if (N > 3) {
+			ESP_LOGW(TAG, "Image will not fit %dx%d", Decoder.width, Decoder.height);
+			N = 3;
+		}	
+		
+		// ready to decode		
+		if (Context.OutData) {
+			Context.Width = Decoder.width / (1 << N);
+			Context.Height = Decoder.height / (1 << N);
+			if (Width) *Width = Context.Width;
+			if (Height) *Height = Context.Height;
+			Res = jd_decomp(&Decoder, OutHandler, N);
+			if (Res != JDR_OK) {
+				ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", Res);
+			}	
+		} else {
+			ESP_LOGE(TAG, "Can't allocate bitmap %dx%d", Decoder.width, Decoder.height);			
+		}	
+	} else if (!SizeOnly) {
+        ESP_LOGE(TAG, "Image decoder: jd_prepare failed (%d)", Res);
+    }    
+      
+	// free scratch area
+    if (Scratch) free(Scratch);
+    return Context.OutData;
+}
+
+uint16_t* GDS_DecodeJPEG(uint8_t *Source, int *Width, int *Height, float Scale) {
+	return DecodeJPEG(Source, Width, Height, Scale, false);
+}	
+
+void GDS_GetJPEGSize(uint8_t *Source, int *Width, int *Height) {
+	DecodeJPEG(Source, Width, Height, 1, true);
+}	
+
+/****************************************************************************************
+ * Simply draw a RGB565 image
+ * monoschrome (0.2125 * color.r) + (0.7154 * color.g) + (0.0721 * color.b)
+ * grayscale (0.3 * R) + (0.59 * G) + (0.11 * B) )
+ */
+void GDS_DrawRGB16( struct GDS_Device* Device, uint16_t *Image, int x, int y, int Width, int Height, int RGB_Mode ) {
+	if (Device->DrawRGB16) {
+		Device->DrawRGB16( Device, x, y, Width, Height, RGB_Mode, Image );
+	} else {
+		int Scale = Device->Depth < 5 ? 5 - Device->Depth : 0;
+		switch(RGB_Mode) {
+		case GDS_RGB565:
+			for (int c = 0; c < Width; c++) {
+				for (int r = 0; r < Height; r++) {
+					int pixel = Image[Width*r + c];
+					pixel = ((pixel & 0x1f) * 11 + ((((pixel >> 5) & 0x3f)  * 59) >> 1) + (pixel >> 11) * 30) / 100;
+					GDS_DrawPixel( Device, c + x, r + y, pixel >> Scale);
+				}	
+			}	
+			break;
+		case GDS_RGB555:
+			for (int c = 0; c < Width; c++) {
+				for (int r = 0; r < Height; r++) {
+					int pixel = Image[Width*r + c];
+					pixel = ((pixel & 0x1f) * 11 + ((pixel >> 5) & 0x1f)  * 59 + (pixel >> 10) * 30) / 100;
+					GDS_DrawPixel( Device, c + x, r + y, pixel >> Scale);
+				}	
+			}	
+			break;
+		case GDS_RGB444:
+			for (int c = 0; c < Width; c++) {
+				for (int r = 0; r < Height; r++) {
+					int pixel = Image[Width*r + c];
+					pixel = (pixel & 0x0f) * 11 + ((pixel >> 4) & 0x0f)  * 59 + (pixel >> 8) * 30;
+					GDS_DrawPixel( Device, c + x, r + y, pixel >> (Scale - 1));
+				}	
+			}	
+			break;				
+		}
+	}	 
+}	
+
+//Decode the embedded image into pixel lines that can be used with the rest of the logic.
+bool GDS_DrawJPEG( struct GDS_Device* Device, uint8_t *Source, int x, int y, int Fit) {
+    JDEC Decoder;
+    JpegCtx Context;
+	bool Ret = false;
+	char *Scratch = calloc(SCRATCH_SIZE, 1);
+	
+    if (!Scratch) {
+        ESP_LOGE(TAG, "Cannot allocate workspace");
+        return NULL;
+    }
+
+    // Populate fields of the JpegCtx struct.
+    Context.InData = Source;
+    Context.InPos = 0;
+	Context.XOfs = x;
+	Context.YOfs = y;
+	Context.Device = Device;
+	Context.Depth = Device->Depth;
+        
+    //Prepare and decode the jpeg.
+    int Res = jd_prepare(&Decoder, InHandler, Scratch, SCRATCH_SIZE, (void*) &Context);
+	Context.Width = Decoder.width;
+	Context.Height = Decoder.height;
+	
+    if (Res == JDR_OK) {
+		uint8_t N = 0;
+		
+		// do we need to fit the image
+		if (Fit & GDS_IMAGE_FIT) {
+			float XRatio = (Device->Width - x) / (float) Decoder.width, YRatio = (Device->Height - y) / (float) Decoder.height;
+			uint8_t Ratio = XRatio < YRatio ? ceil(1/XRatio) : ceil(1/YRatio);
+			Ratio--; Ratio |= Ratio >> 1; Ratio |= Ratio >> 2; Ratio++;
+			while (Ratio >>= 1) N++;
+			if (N > 3) {
+				ESP_LOGW(TAG, "Image will not fit %dx%d", Decoder.width, Decoder.height);
+				N = 3;
+			}	
+			Context.Width /= 1 << N;
+			Context.Height /= 1 << N;
+		} 
+		
+		// then place it
+		if (Fit & GDS_IMAGE_CENTER_X) Context.XOfs = (Device->Width + x - Context.Width) / 2;
+		if (Fit & GDS_IMAGE_CENTER_Y) Context.YOfs = (Device->Height + y - Context.Height) / 2;
+		
+		Context.XMin = x - Context.XOfs;
+		Context.YMin = y - Context.YOfs;
+					
+		// do decompress & draw
+		Res = jd_decomp(&Decoder, OutHandlerDirect, N);
+		if (Res == JDR_OK) {
+			Ret = true;
+		} else {	
+			ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", Res);
+		}	
+	} else {	
+        ESP_LOGE(TAG, "Image decoder: jd_prepare failed (%d)", Res);
+    }    
+      
+	// free scratch area
+    if (Scratch) free(Scratch);
+	return Ret;
+}
+

components/display/core/gds_image.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <stdint.h>
+#include "esp_err.h"
+
+// no progressive JPEG handling
+
+struct GDS_Device;
+
+enum { GDS_RGB565, GDS_RGB555, GDS_RGB444 };
+
+#define GDS_IMAGE_TOP		0x00
+#define GDS_IMAGE_CENTER_X	0x01
+#define GDS_IMAGE_CENTER_Y	0x02
+#define GDS_IMAGE_CENTER	(GDS_IMAGE_CENTER_X | GDS_IMAGE_CENTER_Y)
+#define GDS_IMAGE_FIT		0x10
+
+// Width and Height can be NULL if you already know them (actual scaling is closest ^2)
+uint16_t* 	GDS_DecodeJPEG(uint8_t *Source, int *Width, int *Height, float Scale);
+void	 	GDS_GetJPEGSize(uint8_t *Source, int *Width, int *Height);
+void 		GDS_DrawRGB16( struct GDS_Device* Device, uint16_t *Image, int x, int y, int Width, int Height, int RGB_Mode );
+// set DisplayWidth and DisplayHeight to non-zero if you want autoscale to closest factor ^2 from 0..3
+bool 		GDS_DrawJPEG( struct GDS_Device* Device, uint8_t *Source, int x, int y, int Fit);

components/display/core/gds_private.h

@@ -1,4 +1,5 @@
-#pragma once
+#ifndef _GDS_PRIVATE_H_
+#define _GDS_PRIVATE_H_
 
 #include <stdint.h>
 #include <stdbool.h>
@@ -10,8 +11,6 @@
 #define GDS_CLIPDEBUG_WARNING 1
 #define GDS_CLIPDEBUG_ERROR 2
 
-#define SHADOW_BUFFER
-
 #if CONFIG_GDS_CLIPDEBUG == GDS_CLIPDEBUG_NONE
     /*
      * Clip silently with no console output.
@@ -41,7 +40,7 @@
 #define MAX_LINES	8
 
 #if ! defined BIT
-#define BIT( n ) ( 1 << n )
+#define BIT( n ) ( 1 << ( n ) )
 #endif
 
 struct GDS_Device;
@@ -84,7 +83,7 @@ struct GDS_Device {
     uint16_t Height;
 	uint8_t Depth;
 		
-	uint8_t* Framebuffer, *Shadowbuffer;
+	uint8_t* Framebuffer;
     uint16_t FramebufferSize;
 	bool Dirty;
 
@@ -94,25 +93,31 @@ struct GDS_Device {
     bool FontForceMonospace;
 
 	// various driver-specific method
+	// must always provide 
 	bool (*Init)( struct GDS_Device* Device);
 	void (*SetContrast)( struct GDS_Device* Device, uint8_t Contrast );
 	void (*DisplayOn)( struct GDS_Device* Device );
 	void (*DisplayOff)( struct GDS_Device* Device );
-	void (*Update)( struct GDS_Device* Device );
-	void (*DrawPixelFast)( struct GDS_Device* Device, int X, int Y, int Color );
 	void (*SetHFlip)( struct GDS_Device* Device, bool On );
 	void (*SetVFlip)( struct GDS_Device* Device, bool On );
-	    
+	void (*Update)( struct GDS_Device* Device );
+	// must provide for depth other than 1 (vertical) and 4 (may provide for optimization)
+	void (*DrawPixelFast)( struct GDS_Device* Device, int X, int Y, int Color );
+	void (*DrawBitmapCBR)(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color );
+	// may provide for optimization
+	void (*DrawRGB16)( struct GDS_Device* Device, int x, int y, int Width, int Height, int RGB_Mode, uint16_t *Image );
+	void (*ClearWindow)( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color );
+		    
 	// interface-specific methods	
     WriteCommandProc WriteCommand;
     WriteDataProc WriteData;
+
+	// 16 bytes for whatever the driver wants (should be aligned as it's 32 bits)	
+	uint32_t Private[4];
 };
 
 bool GDS_Reset( struct GDS_Device* Device );
 
-void IRAM_ATTR 	GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color );
-void IRAM_ATTR 	GDS_DrawPixel4Fast( struct GDS_Device* Device, int X, int Y, int Color );
-
 inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
     bool Result = (
         ( x >= 0 ) &&
@@ -130,17 +135,44 @@ inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
     return Result;
 }
 
-inline void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int x, int y, int Color ) {
-    if ( IsPixelVisible( Device, x, y ) == true ) {
-        Device->DrawPixelFast( Device, x, y, Color );
+inline void IRAM_ATTR GDS_DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+    uint32_t YBit = ( Y & 0x07 );
+    uint8_t* FBOffset = NULL;
+
+    /* 
+     * We only need to modify the Y coordinate since the pitch
+     * of the screen is the same as the width.
+     * Dividing Y by 8 gives us which row the pixel is in but not
+     * the bit position.
+     */
+    Y>>= 3;
+
+    FBOffset = Device->Framebuffer + ( ( Y * Device->Width ) + X );
+
+    if ( Color == GDS_COLOR_XOR ) {
+        *FBOffset ^= BIT( YBit );
+    } else {
+        *FBOffset = ( Color == GDS_COLOR_WHITE ) ? *FBOffset | BIT( YBit ) : *FBOffset & ~BIT( YBit );
     }
 }
 
-inline void IRAM_ATTR GDS_DrawPixel4( struct GDS_Device* Device, int x, int y, int Color ) {
-    if ( IsPixelVisible( Device, x, y ) == true ) {
-        Device->DrawPixelFast( Device, x, y, Color );
-    }
+inline void IRAM_ATTR GDS_DrawPixel4Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+	uint8_t* FBOffset;
+
+    FBOffset = Device->Framebuffer + ( (Y * Device->Width >> 1) + (X >> 1));
+	*FBOffset = X & 0x01 ? (*FBOffset & 0x0f) | (Color << 4) : ((*FBOffset & 0xf0) | Color);
 }
 
+inline void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
+    if (Device->DrawPixelFast) Device->DrawPixelFast( Device, X, Y, Color );
+	else if (Device->Depth == 4) GDS_DrawPixel4Fast( Device, X, Y, Color);
+	else if (Device->Depth == 1) GDS_DrawPixel1Fast( Device, X, Y, Color);
+}	
 
+inline void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int x, int y, int Color ) {
+    if ( IsPixelVisible( Device, x, y ) == true ) {
+        GDS_DrawPixelFast( Device, x, y, Color );
+    }
+}
 
+#endif

components/display/core/gds_text.c

@@ -22,10 +22,11 @@
 #include <stdint.h>
 #include <arpa/inet.h>
 #include "esp_log.h"
+
+#include "gds_private.h"
 #include "gds.h"
 #include "gds_draw.h"
 #include "gds_text.h"
-#include "gds_private.h"
 
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 
@@ -109,7 +110,7 @@ bool GDS_TextLine(struct GDS_Device* Device, int N, int Pos, int Attr, char *Tex
 		int Y_min = max(0, Device->Lines[N].Y), Y_max = max(0, Device->Lines[N].Y + Device->Lines[N].Font->Height);
 		for (int c = (Attr & GDS_TEXT_CLEAR_EOL) ? X : 0; c < Device->Width; c++) 
 			for (int y = Y_min; y < Y_max; y++)
-				Device->DrawPixelFast( Device, c, y, GDS_COLOR_BLACK );
+				GDS_DrawPixelFast( Device, c, y, GDS_COLOR_BLACK );
 	}
 		
 	GDS_FontDrawString( Device, X, Device->Lines[N].Y, Text, GDS_COLOR_WHITE );

components/display/core/ifaces/default_if_i2c.c

@@ -17,6 +17,7 @@
 #include "gds_default_if.h"
 
 static int I2CPortNumber;
+static int I2CWait;
 
 static const int GDS_I2C_COMMAND_MODE = 0x80;
 static const int GDS_I2C_DATA_MODE = 0x40;
@@ -31,9 +32,11 @@ static bool I2CDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data,
  * 
  * Returns true on successful init of the i2c bus.
  */
-bool GDS_I2CInit( int PortNumber, int SDA, int SCL ) {
+bool GDS_I2CInit( int PortNumber, int SDA, int SCL, int Speed ) {
 	I2CPortNumber = PortNumber;
 	
+	I2CWait = pdMS_TO_TICKS( Speed ? Speed / 4000 : 100 );
+	
 	if (SDA != -1 && SCL != -1) {
 		i2c_config_t Config = { 0 };
 
@@ -42,7 +45,7 @@ bool GDS_I2CInit( int PortNumber, int SDA, int SCL ) {
 		Config.sda_pullup_en = GPIO_PULLUP_ENABLE;
 		Config.scl_io_num = SCL;
 		Config.scl_pullup_en = GPIO_PULLUP_ENABLE;
-		Config.master.clk_speed = 250000;
+		Config.master.clk_speed = Speed ? Speed : 400000;
 
 		ESP_ERROR_CHECK_NONFATAL( i2c_param_config( I2CPortNumber, &Config ), return false );
 		ESP_ERROR_CHECK_NONFATAL( i2c_driver_install( I2CPortNumber, Config.mode, 0, 0, 0 ), return false );
@@ -98,7 +101,7 @@ static bool I2CDefaultWriteBytes( int Address, bool IsCommand, const uint8_t* Da
         ESP_ERROR_CHECK_NONFATAL( i2c_master_write( CommandHandle, ( uint8_t* ) Data, DataLength, true ), goto error );
         ESP_ERROR_CHECK_NONFATAL( i2c_master_stop( CommandHandle ), goto error );
 
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_cmd_begin( I2CPortNumber, CommandHandle, pdMS_TO_TICKS( 1000 ) ), goto error );
+        ESP_ERROR_CHECK_NONFATAL( i2c_master_cmd_begin( I2CPortNumber, CommandHandle, I2CWait ), goto error );
         i2c_cmd_link_delete( CommandHandle );
     }
 

components/display/display.c

@@ -58,10 +58,9 @@ static EXT_RAM_ATTR struct {
 
 static void displayer_task(void *args);
 
-struct GDS_Device *display;
-struct GDS_Device* SSD1306_Detect(char *Driver, struct GDS_Device* Device);
-struct GDS_Device* SH1106_Detect(char *Driver, struct GDS_Device* Device);
-GDS_DetectFunc drivers[] = { SH1106_Detect, SSD1306_Detect, NULL };
+struct GDS_Device *display;   
+extern GDS_DetectFunc SSD1306_Detect, SSD132x_Detect, SH1106_Detect;
+GDS_DetectFunc *drivers[] = { SH1106_Detect, SSD1306_Detect, SSD132x_Detect, NULL };
 
 /****************************************************************************************
  * 
@@ -84,7 +83,7 @@ void display_init(char *welcome) {
 		
 	if ((p = strcasestr(config, "width")) != NULL) width = atoi(strchr(p, '=') + 1);
 	if ((p = strcasestr(config, "height")) != NULL) height = atoi(strchr(p, '=') + 1);
-		
+			
 	// so far so good
 	if (display && width > 0 && height > 0) {
 		// Detect driver interface
@@ -94,7 +93,7 @@ void display_init(char *welcome) {
 			if ((p = strcasestr(config, "address")) != NULL) address = atoi(strchr(p, '=') + 1);
 		
 			init = true;
-			GDS_I2CInit( i2c_system_port, -1, -1 ) ;
+			GDS_I2CInit( i2c_system_port, -1, -1, i2c_system_speed ) ;
 			GDS_I2CAttachDevice( display, width, height, address, -1 );
 		
 			ESP_LOGI(TAG, "Display is I2C on port %u", address);
@@ -275,8 +274,9 @@ void displayer_metadata(char *artist, char *album, char *title) {
 		strncpy(string, title ? title : "", SCROLLABLE_SIZE);
 	}
 	
-	// get optional scroll speed
+	// get optional scroll speed & pause
 	if ((p = strcasestr(displayer.metadata_config, "speed")) != NULL) sscanf(p, "%*[^=]=%d", &displayer.speed);
+	if ((p = strcasestr(displayer.metadata_config, "pause")) != NULL) sscanf(p, "%*[^=]=%d", &displayer.pause);
 	
 	displayer.offset = 0;	
 	utf8_decode(displayer.string);
@@ -289,13 +289,14 @@ void displayer_metadata(char *artist, char *album, char *title) {
 /****************************************************************************************
  *
  */
-void displayer_scroll(char *string, int speed) {
+void displayer_scroll(char *string, int speed, int pause) {
 	// need a display!
 	if (!display) return;
 	
 	xSemaphoreTake(displayer.mutex, portMAX_DELAY);
 
 	if (speed) displayer.speed = speed;
+	if (pause) displayer.pause = pause;
 	displayer.offset = 0;	
 	strncpy(displayer.string, string, SCROLLABLE_SIZE);
 	displayer.string[SCROLLABLE_SIZE] = '\0';

components/display/display.h

@@ -42,7 +42,7 @@ enum displayer_time_e 	{ DISPLAYER_ELAPSED, DISPLAYER_REMAINING };
 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_scroll(char *string, int speed, int pause);
 void displayer_control(enum displayer_cmd_e cmd, ...);
 void displayer_metadata(char *artist, char *album, char *title);
 void displayer_timer(enum displayer_time_e mode, int elapsed, int duration);

components/services/accessors.c

@@ -45,9 +45,11 @@ const i2c_config_t * config_i2c_get(int * i2c_port) {
 		.sda_pullup_en = GPIO_PULLUP_ENABLE,
 		.scl_io_num = -1,
 		.scl_pullup_en = GPIO_PULLUP_ENABLE,
-		.master.clk_speed = 400000,
+		.master.clk_speed = 0,
 	};
 
+	i2c.master.clk_speed = i2c_system_speed;
+	
 	nvs_item = config_alloc_get(NVS_TYPE_STR, "i2c_config");
 	if (nvs_item) {
 		if ((p = strcasestr(nvs_item, "scl")) != NULL) i2c.scl_io_num = atoi(strchr(p, '=') + 1);
@@ -89,7 +91,7 @@ const spi_bus_config_t * config_spi_get(spi_host_device_t * spi_host) {
  * 
  */
 void parse_set_GPIO(void (*cb)(int gpio, char *value)) {
-	char *nvs_item, *p, type[4];
+	char *nvs_item, *p, type[16];
 	int gpio;
 	
 	if ((nvs_item = config_alloc_get(NVS_TYPE_STR, "set_GPIO")) == NULL) return;
@@ -97,7 +99,7 @@ void parse_set_GPIO(void (*cb)(int gpio, char *value)) {
 	p = nvs_item;
 	
 	do {
-		if (sscanf(p, "%d=%3[^,]", &gpio, type) > 0) cb(gpio, type);
+		if (sscanf(p, "%d=%15[^,]", &gpio, type) > 0) cb(gpio, type);
 		p = strchr(p, ',');
 	} while (p++);
 	

components/services/globdefs.h

@@ -24,6 +24,7 @@
 #define SPI_SYSTEM_HOST	SPI2_HOST
 
 extern int i2c_system_port;
+extern int i2c_system_speed;
 extern int spi_system_host;
 extern int spi_system_dc_gpio;
 extern bool gpio36_39_used;

components/services/led.c

@@ -164,7 +164,7 @@ void set_led_gpio(int gpio, char *value) {
 		green.gpio = gpio;
 		if ((p = strchr(value, ':')) != NULL) green.active = atoi(p + 1);
 	} else 	if (strcasestr(value, "red")) {
-		red.active = gpio;
+		red.gpio = gpio;
 		if ((p = strchr(value, ':')) != NULL) red.active = atoi(p + 1);
 	}	
 }

components/services/services.c

@@ -23,6 +23,7 @@ extern void monitor_svc_init(void);
 extern void led_svc_init(void);
 
 int i2c_system_port = I2C_SYSTEM_PORT;
+int i2c_system_speed = 400000;
 int spi_system_host = SPI_SYSTEM_HOST;
 int spi_system_dc_gpio = -1;
 

components/squeezelite-ota/squeezelite-ota.c

@@ -31,6 +31,10 @@
 #include "messaging.h"
 #include "trace.h"
 #include "esp_ota_ops.h"
+#include "display.h"
+#include "gds.h"
+#include "gds_text.h"
+#include "gds_draw.h"
 
 extern const char * get_certificate();
 
@@ -40,7 +44,6 @@ extern const char * get_certificate();
 #define OTA_CORE 1
 #endif
 
-
 static const char *TAG = "squeezelite-ota";
 esp_http_client_handle_t ota_http_client = NULL;
 #define IMAGE_HEADER_SIZE sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t) + 1
@@ -57,20 +60,27 @@ typedef enum  {
 	OTA_TYPE_BUFFER,
 	OTA_TYPE_INVALID
 } ota_type_t;
+
 static struct {
 	uint32_t actual_image_len;
 	uint32_t total_image_len;
 	uint32_t remain_image_len;
 	ota_type_t ota_type;
 	char * ota_write_data;
+	char * bin_data;
 	bool bOTAStarted;
 	size_t buffer_size;
 	uint8_t lastpct;
 	uint8_t newpct;
 	struct timeval OTA_start;
 	bool bOTAThreadStarted;
-
+    const esp_partition_t *configured;
+    const esp_partition_t *running;
+    const esp_partition_t * update_partition;
+    const esp_partition_t* last_invalid_app ;
+    const esp_partition_t * ota_partition;
 } ota_status;
+
 struct timeval tv;
 static esp_http_client_config_t ota_config;
 
@@ -85,7 +95,67 @@ uint8_t  ota_get_pct_complete(){
 	return ota_status.total_image_len==0?0:
 			(uint8_t)((float)ota_status.actual_image_len/(float)ota_status.total_image_len*100.0f);
 }
+typedef struct  {
+	int x1,y1,x2,y2,width,height;
+} rect_t;
+typedef struct _progress {
+	int border_thickness;
+	int sides_margin;
+	int vertical_margin;
+	int bar_tot_height;
+	int bar_fill_height;
+	rect_t border;
+	rect_t filler;
+} progress_t;
+
+static progress_t * loc_displayer_get_progress_dft(){
+	int start_coord_offset=0;
+	static progress_t def={
+		.border_thickness = 2,
+		.sides_margin = 2,
+		.bar_tot_height = 7,
+		};
+	def.bar_fill_height= def.bar_tot_height-(def.border_thickness*2);
+	def.border.x1=start_coord_offset+def.sides_margin;
+	def.border.x2=GDS_GetWidth(display)-def.sides_margin;
+	// progress bar will be drawn at the bottom of the display
+	def.border.y2= GDS_GetHeight(display)-def.border_thickness;
+	def.border.y1= def.border.y2-def.bar_tot_height;
+	def.border.width=def.border.x2-def.border.x1;
+	def.border.height=def.border.y2-def.border.y1;
+	def.filler.x1= def.border.x1+def.border_thickness;
+	def.filler.x2= def.border.x2-def.border_thickness;
+	def.filler.y1= def.border.y1+def.border_thickness;
+	def.filler.y2= def.border.y2-def.border_thickness;
+	def.filler.width=def.filler.x2-def.filler.x1;
+	def.filler.height=def.filler.y2-def.filler.y1;
+	assert(def.filler.width>0);
+	assert(def.filler.height>0);
+	assert(def.border.width>0);
+	assert(def.border.height>0);
+	assert(def.border.width>def.filler.width);
+	assert(def.border.height>def.filler.height);
+	return &def;
 
+}
+static void loc_displayer_progressbar(uint8_t pct){
+	static progress_t * progress_coordinates;
+	if(!progress_coordinates) progress_coordinates = loc_displayer_get_progress_dft();
+	int filler_x=progress_coordinates->filler.x1+(int)((float)progress_coordinates->filler.width*(float)pct/(float)100);
+
+	ESP_LOGI(TAG,"Drawing %d,%d,%d,%d",progress_coordinates->border.x1,progress_coordinates->border.y1,progress_coordinates->border.x2,progress_coordinates->border.y2);
+	GDS_DrawBox(display,progress_coordinates->border.x1,progress_coordinates->border.y1,progress_coordinates->border.x2,progress_coordinates->border.y2,GDS_COLOR_WHITE,false);
+	ESP_LOGI(TAG,"Drawing %d,%d,%d,%d",progress_coordinates->filler.x1,progress_coordinates->filler.y1,filler_x,progress_coordinates->filler.y2);
+	if(filler_x > progress_coordinates->filler.x1){
+		GDS_DrawBox(display,progress_coordinates->filler.x1,progress_coordinates->filler.y1,filler_x,progress_coordinates->filler.y2,GDS_COLOR_WHITE,true);
+	}
+	else {
+		// Clear the inner box
+		GDS_DrawBox(display,progress_coordinates->filler.x1,progress_coordinates->filler.y1,progress_coordinates->filler.x2,progress_coordinates->filler.y2,GDS_COLOR_BLACK,true);
+	}
+	ESP_LOGI(TAG,"Updating Display");
+	GDS_Update(display);
+}
 void sendMessaging(messaging_types type,const char * fmt, ...){
     va_list args;
     cJSON * msg = cJSON_CreateObject();
@@ -110,7 +180,9 @@ void sendMessaging(messaging_types type,const char * fmt, ...){
     	ESP_LOGW(TAG, "Sending empty string message");
     }
     va_end(args);
-
+    if(type!=MESSAGING_INFO){
+    	GDS_TextLine(display, 2, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, msg_str);
+    }
 
     cJSON_AddStringToObject(msg,"ota_dsc",str_or_unknown(msg_str));
     free(msg_str);
@@ -121,7 +193,19 @@ void sendMessaging(messaging_types type,const char * fmt, ...){
 	cJSON_free(msg);
     _printMemStats();
 }
-
+//esp_err_t decode_alloc_ota_message(single_message_t * message, char * ota_dsc, uint8_t * ota_pct ){
+//	if(!message || !message->message) return ESP_ERR_INVALID_ARG;
+//	cJSON * json = cJSON_Parse(message->message);
+//	if(!json) return ESP_FAIL;
+//	if(ota_dsc) {
+//		ota_dsc = strdup(cJSON_GetObjectItem(json, "ota_dsc")?cJSON_GetStringValue(cJSON_GetObjectItem(json, "ota_dsc")):"");
+//	}
+//	if(ota_pct){
+//		*ota_pct = cJSON_GetObjectItem(json, "ota_pct")?cJSON_GetObjectItem(json, "ota_pct")->valueint:0;
+//	}
+//	cJSON_free(json);
+//	return ESP_OK;
+//}
 
 static void __attribute__((noreturn)) task_fatal_error(void)
 {
@@ -200,6 +284,7 @@ esp_err_t _http_event_handler(esp_http_client_event_t *evt)
 esp_err_t init_config(ota_thread_parms_t * p_ota_thread_parms){
 	memset(&ota_config, 0x00, sizeof(ota_config));
 	sendMessaging(MESSAGING_INFO,"Initializing...");
+	loc_displayer_progressbar(0);
 	ota_status.ota_type= OTA_TYPE_INVALID;
 	if(p_ota_thread_parms->url !=NULL && strlen(p_ota_thread_parms->url)>0 ){
 		ota_status.ota_type= OTA_TYPE_HTTP;
@@ -212,30 +297,25 @@ esp_err_t init_config(ota_thread_parms_t * p_ota_thread_parms){
 		ESP_LOGE(TAG,"HTTP OTA called without a url or a binary buffer");
 		return ESP_ERR_INVALID_ARG;
 	}
+
 	ota_status.buffer_size = BUFFSIZE;
+	ota_status.ota_write_data = heap_caps_malloc(ota_status.buffer_size+1 , (MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
+	if(ota_status.ota_write_data== NULL){
+			ESP_LOGE(TAG,"Error allocating the ota buffer");
+			return ESP_ERR_NO_MEM;
+		}
 	switch (ota_status.ota_type) {
 	case OTA_TYPE_HTTP:
 		ota_config.cert_pem =get_certificate();
 		ota_config.event_handler = _http_event_handler;
-		ota_config.buffer_size = ota_status.buffer_size;
 		ota_config.disable_auto_redirect=true;
 		ota_config.skip_cert_common_name_check = false;
 		ota_config.url = strdup(p_ota_thread_parms->url);
 		ota_config.max_redirection_count = 3;
-
-
-		ota_status.ota_write_data = heap_caps_malloc(ota_status.buffer_size+1 , (MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
-
-		if(ota_status.ota_write_data== NULL){
-			ESP_LOGE(TAG,"Error allocating the ota buffer");
-			return ESP_ERR_NO_MEM;
-		}
-
 		break;
 	case OTA_TYPE_BUFFER:
-		ota_status.ota_write_data = p_ota_thread_parms->bin;
+		ota_status.bin_data = p_ota_thread_parms->bin;
 		ota_status.total_image_len = p_ota_thread_parms->length;
-
 		break;
 	default:
 		return ESP_FAIL;
@@ -268,7 +348,7 @@ esp_partition_t * _get_ota_partition(esp_partition_subtype_t subtype){
 
 
 
-esp_err_t _erase_last_boot_app_partition(esp_partition_t *ota_partition)
+esp_err_t _erase_last_boot_app_partition(const esp_partition_t *ota_partition)
 {
 	uint16_t num_passes=0;
 	uint16_t remain_size=0;
@@ -301,16 +381,19 @@ esp_err_t _erase_last_boot_app_partition(esp_partition_t *ota_partition)
 		err=esp_partition_erase_range(ota_partition, i*single_pass_size, single_pass_size);
 		if(err!=ESP_OK) return err;
 		if(i%2) {
+			loc_displayer_progressbar((int)(((float)i/(float)num_passes)*100.0f));
 			sendMessaging(MESSAGING_INFO,"Erasing flash (%u/%u)",i,num_passes);
 		}
 		vTaskDelay(100/ portTICK_PERIOD_MS);  // wait here for a short amount of time.  This will help with reducing WDT errors
 	}
 	if(remain_size>0){
 		err=esp_partition_erase_range(ota_partition, ota_partition->size-remain_size, remain_size);
+
 		if(err!=ESP_OK) return err;
 	}
 	sendMessaging(MESSAGING_INFO,"Erasing flash complete.");
-
+	loc_displayer_progressbar(100);
+	vTaskDelay(200/ portTICK_PERIOD_MS);
 	return ESP_OK;
 }
 
@@ -399,15 +482,15 @@ static esp_err_t _http_connect(esp_http_client_handle_t http_client)
 }
 void ota_task_cleanup(const char * message, ...){
 	ota_status.bOTAThreadStarted=false;
+	loc_displayer_progressbar(0);
 	if(message!=NULL){
 	    va_list args;
 	    va_start(args, message);
 		sendMessaging(MESSAGING_ERROR,message, args);
 	    va_end(args);
 	}
-	if(ota_status.ota_type == OTA_TYPE_HTTP){
-		FREE_RESET(ota_status.ota_write_data);
-	}
+	FREE_RESET(ota_status.ota_write_data);
+	FREE_RESET(ota_status.bin_data);
 	if(ota_http_client!=NULL) {
 		esp_http_client_cleanup(ota_http_client);
 		ota_http_client=NULL;
@@ -415,22 +498,119 @@ void ota_task_cleanup(const char * message, ...){
 	ota_status.bOTAStarted = false;
 	task_fatal_error();
 }
+esp_err_t ota_buffer_all(){
+	int data_read=0;
+	esp_err_t err=ESP_OK;
+	if (ota_status.ota_type == OTA_TYPE_HTTP){
+		GDS_TextLine(display, 2, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "Downloading file");
+	    ota_http_client = esp_http_client_init(&ota_config);
+	    if (ota_http_client == NULL) {
+	    	sendMessaging(MESSAGING_ERROR,"Error: Failed to initialize HTTP connection.");
+	        return ESP_FAIL;
+	    }
+	    _printMemStats();
+	    // Open the http connection and follow any redirection
+	    err = _http_connect(ota_http_client);
+	    if (err != ESP_OK) {
+	    	sendMessaging(MESSAGING_ERROR,"Error: HTTP Start read failed. (%s)",esp_err_to_name(err));
+	       return err;
+	    }
+	    if(ota_status.total_image_len<=0){
+	    	sendMessaging(MESSAGING_ERROR,"Error: Invalid image length");
+	    	return ESP_FAIL;
+	    }
+	    ota_status.bin_data= malloc(ota_status.total_image_len);
+	    if(ota_status.bin_data==NULL){
+			sendMessaging(MESSAGING_ERROR,"Error: buffer alloc error");
+			return ESP_FAIL;
+   	    }
+		data_read = esp_http_client_read(ota_http_client, ota_status.bin_data, ota_status.total_image_len);
+		if(data_read != ota_status.total_image_len){
+			sendMessaging(MESSAGING_ERROR,"Error: Binary incomplete");
+			return ESP_FAIL;
+		}
+	}
+	else {
+		gettimeofday(&ota_status.OTA_start, NULL);
+	}
+	ota_status.remain_image_len=ota_status.total_image_len;
+
+	return err;
+}
+int ota_buffer_read(){
+	int data_read=0;
+	if(ota_status.remain_image_len >ota_status.buffer_size){
+		data_read = ota_status.buffer_size;
+	} else {
+		data_read = ota_status.remain_image_len;
+	}
+	memcpy(ota_status.ota_write_data, &ota_status.bin_data[ota_status.actual_image_len], data_read);
+
+	ota_status.actual_image_len += data_read;
+	ota_status.remain_image_len -= data_read;
+	return data_read;
+}
+esp_err_t ota_header_check(){
+	esp_app_desc_t new_app_info;
+    esp_app_desc_t running_app_info;
+
+    ota_status.configured = esp_ota_get_boot_partition();
+    ota_status.running = esp_ota_get_running_partition();
+    ota_status.update_partition = esp_ota_get_next_update_partition(NULL);
+    ota_status.last_invalid_app= esp_ota_get_last_invalid_partition();
+    ota_status.ota_partition = _get_ota_partition(ESP_PARTITION_SUBTYPE_APP_OTA_0);
+
+    ESP_LOGI(TAG, "Running partition [%s] type %d subtype %d (offset 0x%08x)", ota_status.running->label, ota_status.running->type, ota_status.running->subtype, ota_status.running->address);
+    if (ota_status.total_image_len > ota_status.ota_partition->size){
+    	ota_task_cleanup("Error: Image size too large to fit in partition.");
+        return ESP_FAIL;
+	}
+	if(ota_status.ota_partition == NULL){
+		ESP_LOGE(TAG,"Unable to locate OTA application partition. ");
+        ota_task_cleanup("Error: OTA partition not found");
+        return ESP_FAIL;
+	}
+    if (ota_status.configured != ota_status.running) {
+        ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", ota_status.configured->address, ota_status.running->address);
+        ESP_LOGW(TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
+    }
+    ESP_LOGI(TAG, "Next ota update partition is: [%s] subtype %d at offset 0x%x",
+    		ota_status.update_partition->label, ota_status.update_partition->subtype, ota_status.update_partition->address);
+
+    if (ota_status.total_image_len >= IMAGE_HEADER_SIZE) {
+		// check current version with downloading
+		memcpy(&new_app_info, &ota_status.bin_data[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
+		ESP_LOGI(TAG, "New firmware version: %s", new_app_info.version);
+		if (esp_ota_get_partition_description(ota_status.running, &running_app_info) == ESP_OK) {
+			ESP_LOGI(TAG, "Running recovery version: %s", running_app_info.version);
+		}
+
+		esp_app_desc_t invalid_app_info;
+		if (esp_ota_get_partition_description(ota_status.last_invalid_app, &invalid_app_info) == ESP_OK) {
+			ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
+		}
+
+		if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
+			ESP_LOGW(TAG, "Current running version is the same as a new.");
+		}
+		return ESP_OK;
+    }
+    else{
+    	ota_task_cleanup("Error: Binary file too small");
+    }
+	 return ESP_FAIL;
+}
+
 void ota_task(void *pvParameter)
 {
 	esp_err_t err = ESP_OK;
-	size_t buffer_size = BUFFSIZE;
+    int data_read = 0;
+	GDS_TextSetFont(display,2,&Font_droid_sans_fallback_15x17,-2);
+	GDS_ClearExt(display, true);
+	GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "Firmware update");
+	GDS_TextLine(display, 2, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "Initializing");
+	loc_displayer_progressbar(0);
 	ESP_LOGD(TAG, "HTTP ota Thread started");
-    const esp_partition_t *configured = esp_ota_get_boot_partition();
-    const esp_partition_t *running = esp_ota_get_running_partition();
-    const esp_partition_t * update_partition = esp_ota_get_next_update_partition(NULL);
-    ESP_LOGI(TAG, "esp_ota_get_next_update_partition returned : partition [%s] subtype %d at offset 0x%x",
-    			update_partition->label, update_partition->subtype, update_partition->address);
-
-    if (configured != running) {
-        ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", configured->address, running->address);
-        ESP_LOGW(TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
-    }
-    ESP_LOGI(TAG, "Running partition [%s] type %d subtype %d (offset 0x%08x)", running->label, running->type, running->subtype, running->address);
     _printMemStats();
 
 
@@ -441,131 +621,66 @@ void ota_task(void *pvParameter)
 		return;
 	}
 
-	/* Locate and erase ota application partition */
-	ESP_LOGW(TAG,"****************  Expecting WATCHDOG errors below during flash erase. This is OK and not to worry about **************** ");
-	sendMessaging(MESSAGING_INFO,"Erasing OTA partition");
-	esp_partition_t *ota_partition = _get_ota_partition(ESP_PARTITION_SUBTYPE_APP_OTA_0);
-	if(ota_partition == NULL){
-		ESP_LOGE(TAG,"Unable to locate OTA application partition. ");
-        ota_task_cleanup("Error: OTA application partition not found. (%s)",esp_err_to_name(err));
-        return;
-	}
-	if(ota_status.ota_type == OTA_TYPE_BUFFER){
-		if(ota_status.total_image_len > ota_partition->size){
-			ota_task_cleanup("Error: Image size too large to fit in partition.");
-			return;
-		}
-	}
 	_printMemStats();
-	err=_erase_last_boot_app_partition(ota_partition);
+	ota_status.bOTAStarted = true;
+	sendMessaging(MESSAGING_INFO,"Starting OTA...");
+	err=ota_buffer_all();
 	if(err!=ESP_OK){
-		ota_task_cleanup("Error: Unable to erase last APP partition. (%s)",esp_err_to_name(err));
+		ota_task_cleanup(NULL);
 		return;
 	}
 
-	_printMemStats();
-	ota_status.bOTAStarted = true;
-	sendMessaging(MESSAGING_INFO,"Starting OTA...");
-	if (ota_status.ota_type == OTA_TYPE_HTTP){
-	    ota_http_client = esp_http_client_init(&ota_config);
-	    if (ota_http_client == NULL) {
-	        ota_task_cleanup("Error: Failed to initialize HTTP connection.");
-	        return;
-	    }
-	    _printMemStats();
-	    // Open the http connection and follow any redirection
-	    err = _http_connect(ota_http_client);
-	    if (err != ESP_OK) {
-	       ota_task_cleanup("Error: HTTP Start read failed. (%s)",esp_err_to_name(err));
-	       return;
-	    }
+
+	if(ota_header_check()!=ESP_OK){
+		ota_task_cleanup(NULL);
+		return;
 	}
-	else {
-		gettimeofday(&ota_status.OTA_start, NULL);
+
+	/* Locate and erase ota application partition */
+	ESP_LOGW(TAG,"****************  Expecting WATCHDOG errors below during flash erase. This is OK and not to worry about **************** ");
+	GDS_TextLine(display, 2, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "Formatting partition");
+	sendMessaging(MESSAGING_INFO,"Formatting OTA partition");
+	_printMemStats();
+	err=_erase_last_boot_app_partition(ota_status.ota_partition);
+	if(err!=ESP_OK){
+		ota_task_cleanup("Error: Unable to erase last APP partition. (%s)",esp_err_to_name(err));
+		return;
 	}
+	loc_displayer_progressbar(0);
 	_printMemStats();
 
+
+	// Call OTA Begin with a small partition size - this minimizes the time spent in erasing partition,
+	// which was already done above
     esp_ota_handle_t update_handle = 0 ;
-    /*deal with all receive packet*/
-    bool image_header_was_checked = false;
-    int data_read = 0;
-    if (ota_status.ota_type == OTA_TYPE_HTTP && ota_status.total_image_len > ota_partition->size){
-    	ota_task_cleanup("Error: Image size too large to fit in partition.");
-        return;
+	err = esp_ota_begin(ota_status.ota_partition, 512, &update_handle);
+	if (err != ESP_OK) {
+		ota_task_cleanup("esp_ota_begin failed (%s)", esp_err_to_name(err));
+		return;
 	}
+	ESP_LOGD(TAG, "esp_ota_begin succeeded");
+	GDS_TextLine(display, 2, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "Writing image...");
+    while (ota_status.remain_image_len>0) {
 
-    while (1) {
-    	ota_status.remain_image_len =ota_status.total_image_len -ota_status.actual_image_len;
-
-        if (ota_status.ota_type == OTA_TYPE_HTTP){
-
-        	data_read = esp_http_client_read(ota_http_client, ota_status.ota_write_data, ota_status.buffer_size);
-        }
-        else {
-        	if(ota_status.remain_image_len >buffer_size){
-        		data_read = buffer_size;
-        	} else {
-        		data_read = ota_status.remain_image_len;
-        	}
-        }
-        if (data_read < 0) {
+    	data_read = ota_buffer_read();
+        if (data_read <= 0) {
             ota_task_cleanup("Error: Data read error");
             return;
         } else if (data_read > 0) {
-        	if (image_header_was_checked == false) {
-                esp_app_desc_t new_app_info;
-                if (data_read >= IMAGE_HEADER_SIZE) {
-                    // check current version with downloading
-                    memcpy(&new_app_info, &ota_status.ota_write_data[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
-                    ESP_LOGI(TAG, "New firmware version: %s", new_app_info.version);
-
-                    esp_app_desc_t running_app_info;
-                    if (esp_ota_get_partition_description(running, &running_app_info) == ESP_OK) {
-                        ESP_LOGI(TAG, "Running recovery version: %s", running_app_info.version);
-                    }
-
-                    const esp_partition_t* last_invalid_app = esp_ota_get_last_invalid_partition();
-                    esp_app_desc_t invalid_app_info;
-                    if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK) {
-                        ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
-                    }
-
-                    if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
-                        ESP_LOGW(TAG, "Current running version is the same as a new.");
-                    }
-
-                    image_header_was_checked = true;
-                    // Call OTA Begin with a small partition size - this drives the erase operation which was already done;
-                    err = esp_ota_begin(ota_partition, 512, &update_handle);
-                    if (err != ESP_OK) {
-                        ota_task_cleanup("esp_ota_begin failed (%s)", esp_err_to_name(err));
-                        return;
-                    }
-					ESP_LOGD(TAG, "esp_ota_begin succeeded");
-                }
-                else {
-					ota_task_cleanup("Error: Increase ota http buffer.");
-					return;
-				}
-            }
-
             err = esp_ota_write( update_handle, (const void *)ota_status.ota_write_data, data_read);
             if (err != ESP_OK) {
                 ota_task_cleanup("Error: OTA Partition write failure. (%s)",esp_err_to_name(err));
                 return;
             }
-            ota_status.actual_image_len += data_read;
-            if(ota_status.ota_type == OTA_TYPE_BUFFER){
-            	// position the ota buffer in the next buffer chunk
-            	ota_status.ota_write_data+= data_read;
-            }
             ESP_LOGD(TAG, "Written image length %d", ota_status.actual_image_len);
+
 			if(ota_get_pct_complete()%5 == 0) ota_status.newpct = ota_get_pct_complete();
 			if(ota_status.lastpct!=ota_status.newpct ) {
+				loc_displayer_progressbar(ota_status.newpct);
 				gettimeofday(&tv, NULL);
 				uint32_t elapsed_ms= (tv.tv_sec-ota_status.OTA_start.tv_sec )*1000+(tv.tv_usec-ota_status.OTA_start.tv_usec)/1000;
 				ESP_LOGI(TAG,"OTA progress : %d/%d (%d pct), %d KB/s", ota_status.actual_image_len, ota_status.total_image_len, ota_status.newpct, elapsed_ms>0?ota_status.actual_image_len*1000/elapsed_ms/1024:0);
-				sendMessaging(MESSAGING_INFO,ota_status.ota_type == OTA_TYPE_HTTP?"Downloading & writing update.":"Writing binary file.");
+				sendMessaging(MESSAGING_INFO,"Writing binary file.");
 				ota_status.lastpct=ota_status.newpct;
 			}
 			taskYIELD();
@@ -582,18 +697,20 @@ void ota_task(void *pvParameter)
         return;
     }
     _printMemStats();
-
+    loc_displayer_progressbar(100);
     err = esp_ota_end(update_handle);
     if (err != ESP_OK) {
         ota_task_cleanup("Error: %s",esp_err_to_name(err));
         return;
      }
     _printMemStats();
-    err = esp_ota_set_boot_partition(ota_partition);
+    err = esp_ota_set_boot_partition(ota_status.ota_partition);
     if (err == ESP_OK) {
     	ESP_LOGI(TAG,"OTA Process completed successfully!");
     	sendMessaging(MESSAGING_INFO,"Success!");
-    	vTaskDelay(1000/ portTICK_PERIOD_MS);  // wait here to give the UI a chance to refresh
+    	GDS_TextLine(display, 2, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "Success!");
+    	vTaskDelay(1500/ portTICK_PERIOD_MS);  // wait here to give the UI a chance to refresh
+    	GDS_Clear(display,GDS_COLOR_BLACK);
         esp_restart();
     } else {
         ota_task_cleanup("Error: Unable to update boot partition [%s]",esp_err_to_name(err));

components/squeezelite-ota/squeezelite-ota.h

@@ -11,6 +11,7 @@
 #include "esp_ota_ops.h"
 #include "sys/param.h"
 
+
 #if RECOVERY_APPLICATION
 #define CODE_RAM_LOCATION
 #define RECOVERY_IRAM_FUNCTION IRAM_ATTR
@@ -38,4 +39,3 @@
 
 esp_err_t start_ota(const char * bin_url, char * bin_buffer, uint32_t length);
 
-

components/squeezelite/a1s/ac101.c

@@ -71,7 +71,7 @@ static int i2c_port;
  * init
  */
 static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config) {	 
-	esp_err_t res;
+	esp_err_t res = ESP_OK;
 	
 	i2c_port = i2c_port_num;
 
@@ -144,8 +144,8 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config) {
 	i2s_pin_config_t i2s_pin_config = (i2s_pin_config_t) { 	.bck_io_num = CONFIG_I2S_BCK_IO, .ws_io_num = CONFIG_I2S_WS_IO, 
 															.data_out_num = CONFIG_I2S_DO_IO, .data_in_num = CONFIG_I2S_DI_IO
 								};
-	i2s_driver_install(i2s_num, i2s_config, 0, NULL);
-	i2s_set_pin(i2s_num, &i2s_pin_config);
+	res |= i2s_driver_install(i2s_num, i2s_config, 0, NULL);
+	res |= i2s_set_pin(i2s_num, &i2s_pin_config);
 	
 	// enable earphone & speaker
 	i2c_write_reg(SPKOUT_CTRL, 0x0220);
@@ -156,9 +156,9 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config) {
 	ac101_set_spk_volume(100);
 	ac101_set_earph_volume(100);
 	
-	ESP_LOGI(TAG, "DAC using I2S bck:%u, ws:%u, do:%u", i2s_pin_config.bck_io_num, i2s_pin_config.ws_io_num, i2s_pin_config.data_out_num);
+	ESP_LOGI(TAG, "DAC using I2S bck:%d, ws:%d, do:%d", i2s_pin_config.bck_io_num, i2s_pin_config.ws_io_num, i2s_pin_config.data_out_num);
 
-	return true;
+	return (res == ESP_OK);
 }	
 
 /****************************************************************************************

components/squeezelite/display.c

@@ -115,7 +115,7 @@ static struct scroller_s {
 	u16_t mode;	
 	s16_t by;
 	// scroller management & sharing between grfg and scrolling task
-	bool active, first;
+	bool active, first, overflow;
 	int scrolled;
 	struct {
 		u8_t *frame;
@@ -233,8 +233,8 @@ bool sb_display_init(void) {
 	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.scroll.max = (displayer.width * displayer.height / 8) * 10;
+	// size scroller (width + current screen)
+	scroller.scroll.max = (displayer.width * displayer.height / 8) * (15 + 1);
 	scroller.scroll.frame = malloc(scroller.scroll.max);
 	scroller.back.frame = malloc(displayer.width * displayer.height / 8);
 	scroller.frame = malloc(displayer.width * displayer.height / 8);
@@ -500,8 +500,9 @@ static void grfe_handler( u8_t *data, int len) {
 			displayer.dirty = false;
 		}	
 	
-		// draw new frame
-		GDS_DrawBitmapCBR(display, data + sizeof(struct grfe_packet), displayer.width, displayer.height);
+		// draw new frame, it might be less than full screen (small visu)
+		int width = ((len - sizeof(struct grfe_packet)) * 8) / displayer.height;
+		GDS_DrawBitmapCBR(display, data + sizeof(struct grfe_packet), width, displayer.height, GDS_COLOR_WHITE);
 		GDS_Update(display);
 	}	
 	
@@ -558,10 +559,11 @@ static void grfs_handler(u8_t *data, int len) {
 		scroller.mode = htons(pkt->mode);
 		scroller.scroll.width = htons(pkt->width);
 		scroller.first = true;
+		scroller.overflow = false;
 		
 		// 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;
@@ -575,12 +577,14 @@ static void grfs_handler(u8_t *data, int len) {
 	}	
 
 	// copy scroll frame data (no semaphore needed)
-	if (scroller.scroll.size + size < scroller.scroll.max) {
+	if (scroller.scroll.size + size < scroller.scroll.max && !scroller.overflow) {
 		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);
+		LOG_INFO("scroller current size %u (w:%u)", scroller.scroll.size, scroller.scroll.width);
 	} else {
-		LOG_INFO("scroller too larger %u/%u", scroller.scroll.size + size, scroller.scroll.max);
+		LOG_INFO("scroller too large %u/%u (w:%u)", scroller.scroll.size + size, scroller.scroll.max, scroller.scroll.width);
+		scroller.scroll.width = scroller.scroll.size / (displayer.height / 8) - scroller.back.width;
+		scroller.overflow = true;
 	}	
 }
 
@@ -598,13 +602,13 @@ static void grfg_handler(u8_t *data, int len) {
 	scroller.width = htons(pkt->width);
 	memcpy(scroller.back.frame, data + sizeof(struct grfg_packet), len - sizeof(struct grfg_packet));
 		
-	// update display asynchronously (frames are oganized by columns)
+	// update display asynchronously (frames are organized 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) {
-		GDS_DrawBitmapCBR(display, scroller.frame, scroller.back.width, displayer.height);
+		GDS_DrawBitmapCBR(display, scroller.frame, scroller.back.width, displayer.height, GDS_COLOR_WHITE);
 		GDS_Update(display);
 	}	
 		
@@ -636,7 +640,7 @@ static void visu_update(void) {
 	// 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_export.running) {
 					
 		if (visu.mode == VISU_VUMETER) {
 			s16_t *iptr = visu_export.buffer;
@@ -704,15 +708,20 @@ static void visu_update(void) {
 	visu_export.level = 0;
 	pthread_mutex_unlock(&visu_export.mutex);
 
-	GDS_ClearExt(display, false, false, visu.col, visu.row, visu.col + visu.width - 1, visu.row + visu.height - 1);
-	
+	// don't refresh screen if all max are 0 (we were are somewhat idle)
+	int clear = 0;
+	for (int i = visu.n; --i >= 0;) clear = max(clear, visu.bars[i].max);
+	if (clear) GDS_ClearExt(display, false, false, visu.col, visu.row, visu.col + visu.width - 1, visu.row + visu.height - 1);
+
+	// there is much more optimization to be done here, like not redrawing bars unless needed
 	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--;
-			
+		else if (!clear) continue;
+		
 		for (int j = 0; j <= visu.bars[i].current; j += 2) 
 			GDS_DrawLine(display, x1, y1 - j, x1 + visu.bar_width - 1, y1 - j, GDS_COLOR_WHITE);
 			
@@ -773,6 +782,9 @@ static void visu_handler( u8_t *data, int len) {
 			visu.border =  htonl(pkt->border);
 			bars = htonl(pkt->bars);
 			visu.spectrum_scale = htonl(pkt->spectrum_scale) / 100.;
+			
+			// might have a race condition with scroller message, so update width in case
+			if (scroller.active) scroller.back.width = displayer.width - visu.width;
 		} else {
 			// full screen visu, try to use bottom screen if available
 			visu.width = displayer.width;
@@ -850,12 +862,12 @@ static void displayer_task(void *args) {
 			// by default go for the long sleep, will change below if required
 			scroller.wake = LONG_WAKE;
 			
-			// do we have more to scroll (scroll.width is the last column from which we havea  full zone)
+			// do we have more to scroll (scroll.width is the last column from which we have a 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) GDS_DrawBitmapCBR(display, scroller.frame, scroller.width, displayer.height);	
+				if (displayer.owned) GDS_DrawBitmapCBR(display, scroller.frame, scroller.width, displayer.height, GDS_COLOR_WHITE);	
 				
 				// short sleep & don't need background update
 				scroller.wake = scroller.speed;

components/squeezelite/output_i2s.c

@@ -252,9 +252,9 @@ void output_init_i2s(log_level level, char *device, unsigned output_buf_size, ch
 		// finally let DAC driver initialize I2C and I2S
 		if (dac_tas57xx.init(I2C_PORT, CONFIG_I2S_NUM, &i2s_config)) adac = &dac_tas57xx;
 		else if (dac_a1s.init(I2C_PORT, CONFIG_I2S_NUM, &i2s_config)) adac = &dac_a1s;
-		else {
-			dac_external.init(I2C_PORT, CONFIG_I2S_NUM, &i2s_config);
-			adac = &dac_external;
+		else if (!dac_external.init(I2C_PORT, CONFIG_I2S_NUM, &i2s_config)) {
+			LOG_WARN("DAC not configured and SPDIF not enabled, I2S will not continue");
+			return;
 		}
 	}	
 

components/squeezelite/tas57xx/dac_57xx.c

@@ -27,7 +27,9 @@
 #include "driver/gpio.h"
 #include "adac.h"
 
-#define VOLUME_GPIO	14
+// this is the only hard-wired thing
+#define VOLUME_GPIO	14	
+
 #define TAS575x 0x98
 #define TAS578x	0x90
 
@@ -79,7 +81,7 @@ static int tas57_detect(void);
  */
 static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)	{	 
 	i2c_port = i2c_port_num;
-	
+		
 	// configure i2c
 	i2c_config_t i2c_config = {
 			.mode = I2C_MODE_MASTER,
@@ -104,11 +106,6 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)	{
 	
 	LOG_INFO("TAS57xx DAC using I2C sda:%u, scl:%u", i2c_config.sda_io_num, i2c_config.scl_io_num);
 	
-	// init volume & mute
-	gpio_pad_select_gpio(VOLUME_GPIO);
-	gpio_set_direction(VOLUME_GPIO, GPIO_MODE_OUTPUT);
-	gpio_set_level(VOLUME_GPIO, 0);
-
 	i2c_cmd_handle_t i2c_cmd = i2c_cmd_link_create();
 	
 	for (int i = 0; tas57xx_init_sequence[i].reg != 0xff; i++) {
@@ -121,22 +118,26 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)	{
 	}
 
 	i2c_master_stop(i2c_cmd);	
-	esp_err_t ret = i2c_master_cmd_begin(i2c_port, i2c_cmd, 500 / portTICK_RATE_MS);
+	esp_err_t res = i2c_master_cmd_begin(i2c_port, i2c_cmd, 500 / portTICK_RATE_MS);
     i2c_cmd_link_delete(i2c_cmd);
 
 	// configure I2S pins & install driver	
 	i2s_pin_config_t i2s_pin_config = (i2s_pin_config_t) { 	.bck_io_num = CONFIG_I2S_BCK_IO, .ws_io_num = CONFIG_I2S_WS_IO, 
 														.data_out_num = CONFIG_I2S_DO_IO, .data_in_num = CONFIG_I2S_DI_IO,
 								};
-	i2s_driver_install(i2s_num, i2s_config, 0, NULL);
-	i2s_set_pin(i2s_num, &i2s_pin_config);
-	LOG_INFO("DAC using I2S bck:%u, ws:%u, do:%u", i2s_pin_config.bck_io_num, i2s_pin_config.ws_io_num, i2s_pin_config.data_out_num);
+	res |= i2s_driver_install(i2s_num, i2s_config, 0, NULL);
+	res |= i2s_set_pin(i2s_num, &i2s_pin_config);
+	LOG_INFO("DAC using I2S bck:%d, ws:%d, do:%d", i2s_pin_config.bck_io_num, i2s_pin_config.ws_io_num, i2s_pin_config.data_out_num);
 	
-	if (ret != ESP_OK) {
-		LOG_ERROR("could not intialize TAS57xx %d", ret);
-		return false;
-	} else {
+	if (res == ESP_OK) {
+		// init volume & mute
+		gpio_pad_select_gpio(VOLUME_GPIO);
+		gpio_set_direction(VOLUME_GPIO, GPIO_MODE_OUTPUT);
+		gpio_set_level(VOLUME_GPIO, 0);
 		return true;
+	} else {
+		LOG_ERROR("could not intialize TAS57xx %d", res);
+		return false;
 	}	
 }	
 

components/telnet/telnet.c

@@ -47,7 +47,7 @@
 #define TELNET_STACK_SIZE 8048
 #define TELNET_RX_BUF 1024
 
-const static char tag[] = "telnet";
+const static char TAG[] = "telnet";
 static int uart_fd=0;
 RingbufHandle_t buf_handle;
 //static SemaphoreHandle_t xSemaphore = NULL;
@@ -56,6 +56,7 @@ static size_t log_buf_size=2000;      //32-bit aligned size
 static bool bIsEnabled=false;
 static int partnerSocket=0;
 static telnet_t *tnHandle;
+extern bool bypass_wifi_manager;
 
 /************************************
  * Forward declarations
@@ -77,16 +78,23 @@ struct telnetUserData {
 };
 
 bool is_serial_suppressed(){
-	return !bIsEnabled || !bMirrorToUART ;
+	return bIsEnabled?!bMirrorToUART:false ;
 }
 void init_telnet(){
 	char *val= get_nvs_value_alloc(NVS_TYPE_STR, "telnet_enable");
 	if (!val || strlen(val) == 0 || !strcasestr("YXD",val) ) {
-		ESP_LOGI(tag,"Telnet support disabled");
+		ESP_LOGI(TAG,"Telnet support disabled");
 		if(val) free(val);
 		return;
 	}
-	bMirrorToUART = strcasestr("D",val)!=NULL;
+	// if wifi manager is bypassed, there will possibly be no wifi available
+	//
+	bMirrorToUART = (strcasestr("D",val)!=NULL);
+	if(!bMirrorToUART && bypass_wifi_manager){
+		// This isn't supposed to happen, as telnet won't start if wifi manager isn't
+		// started. So this is a safeguard only.
+		ESP_LOGW(TAG,"Wifi manager is not active.  Forcing console on Serial output.");
+	}
 
 	FREE_AND_NULL(val);
 	val=get_nvs_value_alloc(NVS_TYPE_STR, "telnet_block");
@@ -110,11 +118,11 @@ void init_telnet(){
 	uint8_t *buffer_storage = (uint8_t *)heap_caps_malloc(sizeof(uint8_t)*log_buf_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT );
 	buf_handle = xRingbufferCreateStatic(log_buf_size, RINGBUF_TYPE_BYTEBUF, buffer_storage, buffer_struct);
 	if (buf_handle == NULL) {
-		ESP_LOGE(tag,"Failed to create ring buffer for telnet!");
+		ESP_LOGE(TAG,"Failed to create ring buffer for telnet!");
 		return;
 	}
 
-	ESP_LOGI(tag, "***Redirecting log output to telnet");
+	ESP_LOGI(TAG, "***Redirecting log output to telnet");
 	const esp_vfs_t vfs = {
 			.flags = ESP_VFS_FLAG_DEFAULT,
 			.write = &stdout_write,
@@ -152,14 +160,14 @@ static void telnet_task(void *data) {
 
 	int rc = bind(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
 	if (rc < 0) {
-		ESP_LOGE(tag, "bind: %d (%s)", errno, strerror(errno));
+		ESP_LOGE(TAG, "bind: %d (%s)", errno, strerror(errno));
 		close(serverSocket);
 		return;
 	}
 
 	rc = listen(serverSocket, 5);
 	if (rc < 0) {
-		ESP_LOGE(tag, "listen: %d (%s)", errno, strerror(errno));
+		ESP_LOGE(TAG, "listen: %d (%s)", errno, strerror(errno));
 		close(serverSocket);
 		return;
 	}
@@ -168,14 +176,14 @@ static void telnet_task(void *data) {
 		socklen_t len = sizeof(serverAddr);
 		rc = accept(serverSocket, (struct sockaddr *)&serverAddr, &len);
 		if (rc < 0 ){
-			ESP_LOGE(tag, "accept: %d (%s)", errno, strerror(errno));
+			ESP_LOGE(TAG, "accept: %d (%s)", errno, strerror(errno));
 			return;
 		}
 		else {
 			partnerSocket = rc;
-			ESP_LOGD(tag, "We have a new client connection!");
+			ESP_LOGD(TAG, "We have a new client connection!");
 			handle_telnet_conn();
-			ESP_LOGD(tag, "Telnet connection terminated");
+			ESP_LOGD(TAG, "Telnet connection terminated");
 		}
 	}
 	close(serverSocket);

main/console.c

@@ -26,7 +26,12 @@
 #include "console.h"
 #include "wifi_manager.h"
 #include "telnet.h"
-
+#include "gds.h"
+#include "gds_default_if.h"
+#include "gds_draw.h"
+#include "gds_text.h"
+#include "gds_font.h"
+#include "display.h"
 #include "cmd_squeezelite.h"
 #include "config.h"
 pthread_t thread_console;
@@ -186,6 +191,7 @@ void console_start() {
 	if(!is_serial_suppressed()){
 		printf("\n"
 	#if RECOVERY_APPLICATION
+
 				"****************************************************************\n"
 				"RECOVERY APPLICATION\n"
 				"This mode is used to flash Squeezelite into the OTA partition\n"
@@ -202,7 +208,12 @@ void console_start() {
 	#endif
 				"\n"
 				"\n");
+#if RECOVERY_APPLICATION
+		GDS_ClearExt(display, true);
+		GDS_SetFont(display, &Font_droid_sans_fallback_15x17 );
+		GDS_TextPos(display, GDS_FONT_MEDIUM, GDS_TEXT_CENTERED, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, "RECOVERY");
 
+#endif
 		/* Figure out if the terminal supports escape sequences */
 		int probe_status = linenoiseProbe();
 		if (probe_status) { /* zero indicates success */
@@ -239,6 +250,7 @@ void console_start() {
 #if !RECOVERY_APPLICATION
 		// process autoexec locally, as we're not going to start the console thread
 	process_autoexec();
+
 #endif
 	}
 }

main/esp_app_main.c

@@ -154,7 +154,7 @@ esp_err_t update_certificates(){
 	if ( (esp_err= nvs_get_str(handle, certs_version, NULL, &len)) == ESP_OK) {
 		str=(char *)malloc(len);
 		if ( (esp_err = nvs_get_str(handle,  certs_version, str, &len)) == ESP_OK) {
-			printf("String associated with key '%s' is %s \n", certs_version, str);
+			ESP_LOGI(TAG,"String associated with key '%s' is %s", certs_version, str);
 		}
 	}
 	if(str!=NULL){
@@ -341,10 +341,7 @@ void register_default_nvs(){
 	
 	ESP_LOGD(TAG,"Done setting default values in nvs.");
 }
-void displayInitCallback(TimerHandle_t pxTimer){
-	ESP_LOGD(TAG,"Initializing display");
-	display_init("SqueezeESP32");
-}
+
 void app_main()
 {
 	char * fwurl = NULL;
@@ -360,17 +357,15 @@ void app_main()
 	wifi_event_group = xEventGroupCreate();
 	ESP_LOGD(TAG,"Clearing CONNECTED_BIT from wifi group");
 	xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
-	
 
 	ESP_LOGI(TAG,"Registering default values");
 	register_default_nvs();
 
-	ESP_LOGD(TAG,"Configuring services");
+	ESP_LOGI(TAG,"Configuring services");
 	services_init();
-	// initialize display in a timer thread to prevent locking up
-	// the main init sequence
-	TimerHandle_t display_init = xTimerCreate(    "DisplInit", 100,pdFALSE,NULL,displayInitCallback);
-	xTimerStart(display_init, portMAX_DELAY);
+
+	ESP_LOGI(TAG,"Initializing display");
+	display_init("SqueezeESP32");
 #if !RECOVERY_APPLICATION
 	ESP_LOGI(TAG,"Checking if certificates need to be updated");
 	update_certificates();
@@ -404,10 +399,12 @@ void app_main()
 	led_blink(LED_GREEN, 250, 250);
 
 	if(bypass_wifi_manager){
-		ESP_LOGW(TAG,"\n\nwifi manager is disabled. Please use wifi commands to connect to your wifi access point.\n\n");
+		ESP_LOGW(TAG,"*******************************************************************************************");
+		ESP_LOGW(TAG,"* wifi manager is disabled. Please use wifi commands to connect to your wifi access point.");
+		ESP_LOGW(TAG,"*******************************************************************************************");
 	}
 	else {
-		ESP_LOGW(TAG,"\n\nwifi manager is ENABLED. Starting...\n\n");
+		ESP_LOGI(TAG,"Starting Wifi Manager");
 		wifi_manager_start();
 		wifi_manager_set_callback(EVENT_STA_GOT_IP, &cb_connection_got_ip);
 		wifi_manager_set_callback(EVENT_STA_DISCONNECTED, &cb_connection_sta_disconnected);