clean display inline

components/display/SSD132x.c

@@ -168,7 +168,7 @@ static void Update1( struct GDS_Device* Device ) {
 }
 
 // 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 ) {
+static void IRAM_ATTR DrawPixel1FastLocal( 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 );
 
@@ -188,12 +188,12 @@ static void ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int
 	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 );
+		while (c & 0x07 && c <= x2) DrawPixel1FastLocal( 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 );
+		while (c <= x2) DrawPixel1FastLocal( Device, c++, r, Color );
 	}
 }
 
@@ -334,7 +334,7 @@ struct GDS_Device* SSD132x_Detect(char *Driver, struct GDS_Device* Device) {
 		
 	if (Model == SSD1326 && Depth == 1) {
 		Device->Update = Update1;
-		Device->DrawPixelFast = DrawPixel1Fast;
+		Device->DrawPixelFast = DrawPixel1FastLocal;
 		Device->DrawBitmapCBR = DrawBitmapCBR;
 		Device->ClearWindow = ClearWindow;
 		Device->Depth = 1;		

components/display/SSD1675.c

@@ -118,7 +118,7 @@ static void Update( struct GDS_Device* Device ) {
 }
 
 // remember that for these ELD drivers W and H are "inverted"
-static void IRAM_ATTR DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixelLocal( struct GDS_Device* Device, int X, int Y, int Color ) {
     uint32_t YBit = ( Y & 0x07 );
     Y>>= 3;
 
@@ -129,7 +129,7 @@ static void IRAM_ATTR DrawPixelFast( struct GDS_Device* Device, int X, int Y, in
 static void ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color ) {
 	for (int r = y1; r <= y2; r++) {
 		for (int c = x1; c <= x2; c++) {
-			DrawPixelFast( Device, c, r, Color );
+			DrawPixelLocal( Device, c, r, Color );
 		}	
 	}
 }
@@ -228,7 +228,7 @@ static bool Init( struct GDS_Device* Device ) {
 
 static const struct GDS_Device SSD1675 = {
 	.DrawBitmapCBR = DrawBitmapCBR, .ClearWindow = ClearWindow,
-	.DrawPixelFast = DrawPixelFast,
+	.DrawPixelFast = DrawPixelLocal,
 	.Update = Update, .Init = Init,
 	.Mode = GDS_MONO, .Depth = 1,
 	.Alloc = GDS_ALLOC_NONE,

components/display/core/gds.c

@@ -103,7 +103,7 @@ void GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int 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 );
+					for (c = x1; c <= x2; c++) DrawPixelFast( Device, c, r, Color );
 					r++;
 				}
 				// go fast if we have more than 8 lines to write
@@ -111,7 +111,7 @@ void GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int 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 );
+					for (c = x1; c <= x2; c++) DrawPixelFast( Device, c, r, Color );
 					r++;
 				}
 			}
@@ -127,10 +127,10 @@ void GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2,
 			// 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);
+				if (c & 0x01) 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);
+				if (c + chunk <= x2) DrawPixelFast( Device, x2, r, Color);
 			}
 		}	
 	} else if (Device->Depth == 8) {
@@ -142,7 +142,7 @@ void GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2,
 	} else {
 		for (int y = y1; y <= y2; y++) {
 			for (int x = x1; x <= x2; x++) {
-				GDS_DrawPixelFast( Device, x, y, Color);
+				DrawPixelFast( Device, x, y, Color);
 			}
 		}
 	}

components/display/core/gds_draw.c

@@ -5,7 +5,6 @@
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
-
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
@@ -45,9 +44,13 @@ __attribute__( ( always_inline ) ) static inline void SwapInt( int* a, int* b )
     *a = Temp;
 }
 
-// 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 );
+void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
+	DrawPixelFast( Device, X, Y, Color );
+}
+
+void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int X, int Y, int Color ) {
+	DrawPixel( Device, X, Y, Color );
+}
 
 void GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color ) {
     int XEnd = x + Width;
@@ -60,7 +63,7 @@ void GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Colo
 	if (y < 0) y = 0;
 	else if (y >= Device->Height) y = Device->Height - 1;
 
-    for ( ; x < XEnd; x++ ) GDS_DrawPixelFast( Device, x, y, Color );
+    for ( ; x < XEnd; x++ ) DrawPixelFast( Device, x, y, Color );
 }
 
 void GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color ) {
@@ -74,7 +77,7 @@ void GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Col
 	if (y < 0) y = 0;
 	else if (YEnd >= Device->Height) YEnd = Device->Height - 1;
 
-    for ( ; y < YEnd; y++ ) GDS_DrawPixel( Device, x, y, Color );
+    for ( ; y < YEnd; y++ ) DrawPixel( Device, x, y, Color );
 }
 
 static inline void DrawWideLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
@@ -94,7 +97,7 @@ static inline void DrawWideLine( struct GDS_Device* Device, int x0, int y0, int
 
     for ( ; x < x1; x++ ) {
         if ( IsPixelVisible( Device, x, y ) == true ) {
-            GDS_DrawPixelFast( Device, x, y, Color );
+            DrawPixelFast( Device, x, y, Color );
         }
 
         if ( Error > 0 ) {
@@ -123,7 +126,7 @@ static inline void DrawTallLine( struct GDS_Device* Device, int x0, int y0, int
 
     for ( ; y < y1; y++ ) {
         if ( IsPixelVisible( Device, x, y ) == true ) {
-            GDS_DrawPixelFast( Device, x, y, Color );
+            DrawPixelFast( Device, x, y, Color );
         }
 
         if ( Error > 0 ) {
@@ -317,32 +320,32 @@ void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int
 		// 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 ); 
+			DrawPixelFast( Device, c, (r << 3) + 7, (Byte & 0x01) * Color ); Byte >>= 1;
+			DrawPixelFast( Device, c, (r << 3) + 6, (Byte & 0x01) * Color ); Byte >>= 1;
+			DrawPixelFast( Device, c, (r << 3) + 5, (Byte & 0x01) * Color ); Byte >>= 1;
+			DrawPixelFast( Device, c, (r << 3) + 4, (Byte & 0x01) * Color ); Byte >>= 1;
+			DrawPixelFast( Device, c, (r << 3) + 3, (Byte & 0x01) * Color ); Byte >>= 1;
+			DrawPixelFast( Device, c, (r << 3) + 2, (Byte & 0x01) * Color ); Byte >>= 1;
+			DrawPixelFast( Device, c, (r << 3) + 1, (Byte & 0x01) * Color ); Byte >>= 1;
+			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 );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 0, ((Byte >> 7) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 1, ((Byte >> 6) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 2, ((Byte >> 5) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 3, ((Byte >> 4) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 4, ((Byte >> 3) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 5, ((Byte >> 2) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 6, ((Byte >> 1) & 0x01) * Color );
+				GDSDrawPixel4Fast( Device, x, y * 8 + 7, ((Byte >> 0) & 0x01) * Color );
 			}
 		}
 		*/
 	}
 	
 	Device->Dirty = true;
-}
+}

components/display/core/gds_draw.h

@@ -17,16 +17,12 @@
 extern "C" {
 #endif
 
-#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 );
-void IRAM_ATTR GDS_DrawPixelExt( struct GDS_Device* Device, int X, int Y, int Color );
-void IRAM_ATTR GDS_DrawPixelFastExt( struct GDS_Device* Device, int X, int Y, int Color );
 // 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);
 

components/display/core/gds_draw_ext.c

@@ -1,22 +0,0 @@
-/**
- * Copyright (c) 2017-2018 Tara Keeling
- *				 2020 Philippe G.
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "gds_private.h"
-#include "gds.h"
-#include "gds_draw.h"
-
-void IRAM_ATTR GDS_DrawPixelExt( struct GDS_Device* Device, int X, int Y, int Color ){
-	if ( IsPixelVisible( Device, X, Y ) == true ) {
-	        GDS_DrawPixelFast( Device, X, Y, Color );
-	    }
-}
-void IRAM_ATTR GDS_DrawPixelFastExt( 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);
-}

components/display/core/gds_font.c

@@ -89,7 +89,7 @@ void GDS_FontDrawChar( struct GDS_Device* Device, char Character, int x, int y,
                 YBit = ( i + OffsetY ) & 0x07;
 
                 if ( GlyphData[ YByte ] & BIT( YBit ) ) {
-                    GDS_DrawPixel( Device, x, y, Color );
+                    DrawPixel( Device, x, y, Color );
                 }            
             }
 

components/display/core/gds_image.c

@@ -133,7 +133,7 @@ static unsigned OutHandler(JDEC *Decoder, void *Bitmap, JRECT *Frame) {
 		if (y < Context->YMin) continue;															\
 		for (int x = Frame->left; x <= Frame->right; x++) {											\
 			if (x < Context->XMin) continue;														\
-			GDS_DrawPixel( Context->Device, x + Context->XOfs, y + Context->YOfs, F(Pixels) >> S);	\
+			DrawPixel( Context->Device, x + Context->XOfs, y + Context->YOfs, F(Pixels) >> S);	\
 			Pixels += 3;																			\
 		}																							\
 	}
@@ -274,13 +274,13 @@ static inline int ToSelf(uint8_t **Pixel) {
 	if (Scale > 0) {														\
 		for (int r = 0; r < Height; r++) {									\
 			for (int c = 0; c < Width; c++) {								\
-				GDS_DrawPixel( Device, c + x, r + y, F(S) >> Scale);		\
+				DrawPixel( Device, c + x, r + y, F(S) >> Scale);		\
 			}																\
 		}																	\
 	} else {																\
 		for (int r = 0; r < Height; r++) {									\
 			for (int c = 0; c < Width; c++) {								\
-				GDS_DrawPixel( Device, c + x, r + y, F(S) << -Scale);	\
+				DrawPixel( Device, c + x, r + y, F(S) << -Scale);	\
 			}																\
 		}																	\
 	}									
@@ -289,7 +289,7 @@ static inline int ToSelf(uint8_t **Pixel) {
 	T *S = (T*) Image;									\
 	for (int r = 0; r < Height; r++) {					\
 		for (int c = 0; c < Width; c++) {				\
-			GDS_DrawPixel(Device, c + x, r + y, *S++);	\
+			DrawPixel(Device, c + x, r + y, *S++);	\
 		}												\
 	}																	
 	
@@ -298,7 +298,7 @@ static inline int ToSelf(uint8_t **Pixel) {
 	for (int r = 0; r < Height; r++) {								\
 		for (int c = 0; c < Width; c++) {							\
 			uint32_t v = *S++; v |= *S++ << 8; v |= *S++ << 16;		\
-			GDS_DrawPixel(Device, c + x, r + y, v);					\
+			DrawPixel(Device, c + x, r + y, v);					\
 		}															\
 	}	
 

components/display/core/gds_private.h

@@ -153,7 +153,7 @@ static inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
     return Result;
 }
 
-static inline void IRAM_ATTR GDS_DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
     uint32_t YBit = ( Y & 0x07 );
     uint8_t* FBOffset;
 
@@ -174,48 +174,48 @@ static inline void IRAM_ATTR GDS_DrawPixel1Fast( struct GDS_Device* Device, int
     }
 }
 
-static inline void IRAM_ATTR GDS_DrawPixel4Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixel4Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
 	uint8_t* FBOffset = Device->Framebuffer + ( (Y * Device->Width >> 1) + (X >> 1));
 	*FBOffset = X & 0x01 ? (*FBOffset & 0x0f) | ((Color & 0x0f) << 4) : ((*FBOffset & 0xf0) | (Color & 0x0f));
 }
 
-static inline void IRAM_ATTR GDS_DrawPixel8Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixel8Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
 	Device->Framebuffer[Y * Device->Width + X] = Color;
 }
 
 // assumes that Color is 16 bits R..RG..GB..B from MSB to LSB and FB wants 1st serialized byte to start with R
-static inline void IRAM_ATTR GDS_DrawPixel16Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixel16Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
 	uint16_t* FBOffset = (uint16_t*) Device->Framebuffer + Y * Device->Width + X;
 	*FBOffset = __builtin_bswap16(Color);
 }
 
 // assumes that Color is 18 bits RGB from MSB to LSB RRRRRRGGGGGGBBBBBB, so byte[0] is B 
 // FB is 3-bytes packets and starts with R for serialization so 0,1,2 ... = xxRRRRRR xxGGGGGG xxBBBBBB 
-static inline void IRAM_ATTR GDS_DrawPixel18Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixel18Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
 	uint8_t* FBOffset = Device->Framebuffer + (Y * Device->Width + X) * 3;
 	*FBOffset++ = Color >> 12; *FBOffset++ = (Color >> 6) & 0x3f; *FBOffset = Color & 0x3f;
 }
 
 // assumes that Color is 24 bits RGB from MSB to LSB RRRRRRRRGGGGGGGGBBBBBBBB, so byte[0] is B 
 // FB is 3-bytes packets and starts with R for serialization so 0,1,2 ... = RRRRRRRR GGGGGGGG BBBBBBBB 
-static inline void IRAM_ATTR GDS_DrawPixel24Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void DrawPixel24Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
 	uint8_t* FBOffset = Device->Framebuffer + (Y * Device->Width + X) * 3;
 	*FBOffset++ = Color >> 16; *FBOffset++ = Color >> 8; *FBOffset = Color;
 }
 
-static inline void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
+static inline void IRAM_ATTR 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 );
-	else if (Device->Depth == 16) GDS_DrawPixel16Fast( Device, X, Y, Color );	
-	else if (Device->Depth == 24 && Device->Mode == GDS_RGB666) GDS_DrawPixel18Fast( Device, X, Y, Color );	
-	else if (Device->Depth == 24 && Device->Mode == GDS_RGB888) GDS_DrawPixel24Fast( Device, X, Y, Color );	
-	else if (Device->Depth == 8) GDS_DrawPixel8Fast( Device, X, Y, Color );	
+	else if (Device->Depth == 4) DrawPixel4Fast( Device, X, Y, Color );
+	else if (Device->Depth == 1) DrawPixel1Fast( Device, X, Y, Color );
+	else if (Device->Depth == 16) DrawPixel16Fast( Device, X, Y, Color );	
+	else if (Device->Depth == 24 && Device->Mode == GDS_RGB666) DrawPixel18Fast( Device, X, Y, Color );	
+	else if (Device->Depth == 24 && Device->Mode == GDS_RGB888) DrawPixel24Fast( Device, X, Y, Color );	
+	else if (Device->Depth == 8) DrawPixel8Fast( Device, X, Y, Color );	
 }	
 
-static inline void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int x, int y, int Color ) {
+static inline void IRAM_ATTR DrawPixel( struct GDS_Device* Device, int x, int y, int Color ) {
     if ( IsPixelVisible( Device, x, y ) == true ) {
-        GDS_DrawPixelFast( Device, x, y, Color );
+        DrawPixelFast( Device, x, y, Color );
     }
 }
 

components/display/core/gds_text.c

@@ -99,7 +99,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++)
-				GDS_DrawPixelFast( Device, c, y, GDS_COLOR_BLACK );
+				DrawPixelFast( Device, c, y, GDS_COLOR_BLACK );
 	}
 		
 	GDS_FontDrawString( Device, X, Device->Lines[N].Y, Text, GDS_COLOR_WHITE );

components/squeezelite/display.c

@@ -588,13 +588,13 @@ void draw_VU(struct GDS_Device * display, const uint8_t *data, int level, int x,
 		if (visu.rotate) {
 			for (int r = 0; r < width; r++) {
 				for (int c = VU_HEIGHT; --c >= 0;) {
-					GDS_DrawPixelFastExt(display, c + x, r + y, *data++ >> scale);
+					GDS_DrawPixelFast(display, c + x, r + y, *data++ >> scale);
 				}	
 			}	
 		} else {
 			for (int r = 0; r < width; r++) {
 				for (int c = 0; c < VU_HEIGHT; c++) {
-				GDS_DrawPixelFastExt(display, r + x, c + y, *data++ >> scale);
+					GDS_DrawPixelFast(display, r + x, c + y, *data++ >> scale);
 				}	
 			}			
 		}	
@@ -603,13 +603,13 @@ void draw_VU(struct GDS_Device * display, const uint8_t *data, int level, int x,
 		if (visu.rotate) {
 			for (int r = 0; r < width; r++) {
 				for (int c = VU_HEIGHT; --c >= 0;) {
-					GDS_DrawPixelFastExt(display, c + x, r + y, grayMap[*data++]);
+					GDS_DrawPixelFast(display, c + x, r + y, grayMap[*data++]);
 				}	
 			}	
 		} else {
 			for (int r = 0; r < width; r++) {
 				for (int c = 0; c < VU_HEIGHT; c++) {
-				GDS_DrawPixelFastExt(display, r + x, c + y, grayMap[*data++]);
+					GDS_DrawPixelFast(display, r + x, c + y, grayMap[*data++]);
 				}	
 			}			
 		}