warning-free compile (prepare archiving) - release

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 _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 );
 
@@ -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) _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 );
+		while (c <= x2) _DrawPixel1Fast( Device, c++, r, Color );
 	}
 }
 
@@ -320,7 +320,7 @@ static const struct GDS_Device SSD132x = {
 struct GDS_Device* SSD132x_Detect(char *Driver, struct GDS_Device* Device) {
 	uint8_t Model;
 	int Depth;
-	
+		
 	if (strcasestr(Driver, "SSD1326")) Model = SSD1326;
 	else if (strcasestr(Driver, "SSD1327")) Model = SSD1327;
 	else return NULL;
@@ -328,13 +328,14 @@ struct GDS_Device* SSD132x_Detect(char *Driver, struct GDS_Device* Device) {
 	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
 	
 	*Device = SSD132x;	
-	((struct PrivateSpace*) Device->Private)->Model = Model;
+	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
+	Private->Model = Model;
 		
 	sscanf(Driver, "%*[^:]:%u", &Depth);
 		
 	if (Model == SSD1326 && Depth == 1) {
 		Device->Update = Update1;
-		Device->DrawPixelFast = DrawPixel1Fast;
+		Device->DrawPixelFast = _DrawPixel1Fast;
 		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 _DrawPixel( 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 );
+			_DrawPixel( 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 = _DrawPixel,
 	.Update = Update, .Init = Init,
 	.Mode = GDS_MONO, .Depth = 1,
 	.Alloc = GDS_ALLOC_NONE,

components/display/ST77xx.c

@@ -282,8 +282,9 @@ struct GDS_Device* ST77xx_Detect(char *Driver, struct GDS_Device* Device) {
 	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
 		
 	*Device = ST77xx;	
-	((struct PrivateSpace*) Device->Private)->Model = Model;
 	sscanf(Driver, "%*[^:]:%u", &Depth);
+	struct PrivateSpace* Private = (struct PrivateSpace*) Device->Private;
+	Private->Model = Model;
 	
 	if (Depth == 18) {
 		Device->Mode = GDS_RGB666;

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,15 +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 );
-
 // 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_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

@@ -136,7 +136,7 @@ struct GDS_Device {
 bool GDS_Reset( struct GDS_Device* Device );
 bool GDS_Init( struct GDS_Device* Device );
 
-inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
+static inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
     bool Result = (
         ( x >= 0 ) &&
         ( x < Device->Width ) &&
@@ -153,7 +153,7 @@ inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
     return Result;
 }
 
-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 @@ inline void IRAM_ATTR GDS_DrawPixel1Fast( struct GDS_Device* Device, int X, int
     }
 }
 
-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));
 }
 
-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
-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 
-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 
-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;
 }
 
-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 );	
 }	
 
-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/raop/raop.c

@@ -89,7 +89,13 @@ extern struct mdnsd* glmDNSServer;
 extern log_level	raop_loglevel;
 static log_level 	*loglevel = &raop_loglevel;
 
+#ifdef WIN32
 static void*	rtsp_thread(void *arg);
+static void* 	search_remote(void *args);
+#else
+static void		rtsp_thread(void *arg);
+static void 	search_remote(void *args);
+#endif
 static void		cleanup_rtsp(raop_ctx_t *ctx, bool abort);
 static bool 	handle_rtsp(raop_ctx_t *ctx, int sock);
 
@@ -97,7 +103,7 @@ static char*	rsa_apply(unsigned char *input, int inlen, int *outlen, int mode);
 static int  	base64_pad(char *src, char **padded);
 static int 		base64_encode(const void *data, int size, char **str);
 static int 		base64_decode(const char *str, void *data);
-static void* 	search_remote(void *args);
+
 
 extern char private_key[];
 
@@ -352,7 +358,11 @@ bool raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
 	}
 
 	free(command);
+	closesocket(sock);
 	
+	return true;
+}
+
 /*----------------------------------------------------------------------------*/
 #ifdef WIN32
 static void *rtsp_thread(void *arg) {
@@ -397,9 +407,9 @@ static void *rtsp_thread(void *arg) {
 			sock = -1;
 		}
 	}
+	
+	if (sock != -1) closesocket(sock);
 
-	if (sock != -1) closesocket(sock);
-
 #ifndef WIN32
 	xTaskNotifyGive(ctx->joiner);
 	vTaskSuspend(NULL);
@@ -708,7 +718,7 @@ static void* search_remote(void *args) {
 
 	query_mDNS(ctx->active_remote.handle, "_dacp._tcp.local", 0, 0, &search_remote_cb, (void*) ctx);
 
-	return NULL;
+	return NULL;
 }
 
 #else
@@ -741,8 +751,6 @@ static void* search_remote(void *args) {
 			}
 		}
 
-		mdns_query_results_free(results);
-	}
 		mdns_query_results_free(results);
 	}
 

components/raop/rtp.c

@@ -158,8 +158,12 @@ static void 	buffer_reset(abuf_t *audio_buffer);
 static void 	buffer_release(abuf_t *audio_buffer);
 static void 	buffer_reset(abuf_t *audio_buffer);
 static void 	buffer_push_packet(rtp_t *ctx);
-static bool 	rtp_request_resend(rtp_t *ctx, seq_t first, seq_t last);
 static bool 	rtp_request_resend(rtp_t *ctx, seq_t first, seq_t last);
+static bool 	rtp_request_timing(rtp_t *ctx);
+static int	  	seq_order(seq_t a, seq_t b);
+#ifdef WIN32
+static void 	*rtp_thread_func(void *arg);
+#else
 static void 	rtp_thread_func(void *arg);
 #endif	
 
@@ -565,7 +569,11 @@ static void buffer_push_packet(rtp_t *ctx) {
 	}
 
 }
+
 
+/*---------------------------------------------------------------------------*/
+#ifdef WIN32
+static void *rtp_thread_func(void *arg) {
 #else	
 static void rtp_thread_func(void *arg) {
 #endif	
@@ -620,8 +628,9 @@ static void *rtp_thread_func(void *arg) {
 			unsigned rtptime;
 
 			// re-sent packet
-			case 0x56: {
-				pktp += 4;
+			case 0x56: {
+				pktp += 4;
+				plen -= 4;
 			}	
 			// fall through
 			
@@ -695,7 +704,6 @@ static void *rtp_thread_func(void *arg) {
 
 				break;
 			}
-
 
 			// NTP timing packet
 			case 0x53: {
@@ -712,8 +720,8 @@ static void *rtp_thread_func(void *arg) {
 				}
 
 				/*
+				  The expected elapsed remote time should be exactly the same as
 				  elapsed local time between the two request, corrected by the
-				  elapsed local time between the two request, corrected by the
 				  drifting
 				u64_t expected = ctx->timing.remote + MS2NTP(reference - ctx->timing.local);
 				*/
@@ -740,9 +748,9 @@ static void *rtp_thread_func(void *arg) {
 	free(packet);
 	LOG_INFO("[%p]: terminating", ctx);
 
-#ifndef WIN32
-	xTaskNotifyGive(ctx->joiner);
+#ifndef WIN32
 	xTaskNotifyGive(ctx->joiner);
+	vTaskSuspend(NULL);
 #else	
 	return NULL;
 #endif

components/squeezelite/ac101/ac101.c

@@ -63,7 +63,6 @@ static void ac101_start(ac_module_t mode);
 static void ac101_stop(void);
 static void ac101_set_earph_volume(uint8_t volume);
 static void ac101_set_spk_volume(uint8_t volume);
-static int ac101_get_spk_volume(void);
 	
 static int i2c_port;
 
@@ -268,13 +267,6 @@ void set_sample_rate(int rate) {
 	i2c_write_reg(I2S_SR_CTRL, rate);
 }
 
-/****************************************************************************************
- * Get normalized (0..100) speaker volume
- */
-static int ac101_get_spk_volume(void) {
-	return ((i2c_read_reg(SPKOUT_CTRL) & 0x1f) * 100) / 0x1f;
-}
-
 /****************************************************************************************
  * Set normalized (0..100) volume
  */
@@ -285,13 +277,6 @@ static void ac101_set_spk_volume(uint8_t volume) {
 	i2c_write_reg(SPKOUT_CTRL, value);
 }
 
-/****************************************************************************************
- * Get normalized (0..100) earphone volume
- */
-static int ac101_get_earph_volume(void) {
-	return (((i2c_read_reg(HPOUT_CTRL) >> 4) & 0x3f) * 100) / 0x3f;
-}
-
 /****************************************************************************************
  * Set normalized (0..100) earphone volume
  */
@@ -302,6 +287,21 @@ static void ac101_set_earph_volume(uint8_t volume) {
 	i2c_write_reg(HPOUT_CTRL, value);
 }
 
+#if 0
+/****************************************************************************************
+ * Get normalized (0..100) speaker volume
+ */
+static int ac101_get_spk_volume(void) {
+	return ((i2c_read_reg(SPKOUT_CTRL) & 0x1f) * 100) / 0x1f;
+}
+
+/****************************************************************************************
+ * Get normalized (0..100) earphone volume
+ */
+static int ac101_get_earph_volume(void) {
+	return (((i2c_read_reg(HPOUT_CTRL) >> 4) & 0x3f) * 100) / 0x3f;
+}
+
 /****************************************************************************************
  * 
  */
@@ -330,6 +330,27 @@ static void ac101_set_output_mixer_gain(ac_output_mixer_gain_t gain,ac_output_mi
 	i2c_write_reg(OMIXER_BST1_CTRL,regval);
 }
 
+/****************************************************************************************
+ * 
+ */
+static void ac101_deinit(void) {
+	i2c_write_reg(CHIP_AUDIO_RS, 0x123);		//soft reset
+}
+
+/****************************************************************************************
+ * Don't know when this one is supposed to be called
+ */
+static void ac101_i2s_config_clock(ac_i2s_clock_t *cfg) {
+	uint16_t regval=0;
+	regval = i2c_read_reg(I2S1LCK_CTRL);
+	regval &= 0xe03f;
+	regval |= (cfg->bclk_div << 9);
+	regval |= (cfg->lclk_div << 6);
+	i2c_write_reg(I2S1LCK_CTRL, regval);
+}
+
+#endif
+
 /****************************************************************************************
  * 
  */
@@ -362,21 +383,3 @@ static void ac101_stop(void) {
 	i2c_write_reg(PLL_CTRL2, value);
 }
 
-/****************************************************************************************
- * 
- */
-static void ac101_deinit(void) {
-	i2c_write_reg(CHIP_AUDIO_RS, 0x123);		//soft reset
-}
-
-/****************************************************************************************
- * Don't know when this one is supposed to be called
- */
-static void ac101_i2s_config_clock(ac_i2s_clock_t *cfg) {
-	uint16_t regval=0;
-	regval = i2c_read_reg(I2S1LCK_CTRL);
-	regval &= 0xe03f;
-	regval |= (cfg->bclk_div << 9);
-	regval |= (cfg->lclk_div << 6);
-	i2c_write_reg(I2S1LCK_CTRL, regval);
-}

components/squeezelite/buffer.c

@@ -21,7 +21,9 @@
 
 // fifo bufffers 
 
+#ifndef _GNU_SOURCE
 #define _GNU_SOURCE
+#endif
 
 #include "squeezelite.h"
 

components/squeezelite/output_i2s.c

@@ -102,7 +102,7 @@ DECLARE_ALL_MIN_MAX;
 static int _i2s_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR,
 								s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr);
 static void *output_thread_i2s(void *arg);
-static void *output_thread_i2s_stats(void *arg);
+static void output_thread_i2s_stats(void *arg);
 static void spdif_convert(ISAMPLE_T *src, size_t frames, u32_t *dst, size_t *count);
 static void (*jack_handler_chain)(bool inserted);
 
@@ -502,13 +502,13 @@ static void *output_thread_i2s(void *arg) {
 		// this does not work well as set_sample_rates resets the fifos (and it's too early)
 		if (i2s_config.sample_rate != output.current_sample_rate) {
 			LOG_INFO("changing sampling rate %u to %u", i2s_config.sample_rate, output.current_sample_rate);
-			/* 
-			if (synced)
+			if (synced) {
+			/* 				
 				//  can sleep for a buffer_queue - 1 and then eat a buffer (discard) if we are synced
 				usleep(((DMA_BUF_COUNT - 1) * DMA_BUF_LEN * BYTES_PER_FRAME * 1000) / 44100 * 1000);
 				discard = DMA_BUF_COUNT * DMA_BUF_LEN * BYTES_PER_FRAME;
+			*/		
 			}	
-			*/
 			i2s_config.sample_rate = output.current_sample_rate;
 			i2s_set_sample_rates(CONFIG_I2S_NUM, spdif ? i2s_config.sample_rate * 2 : i2s_config.sample_rate);
 			i2s_zero_dma_buffer(CONFIG_I2S_NUM);
@@ -552,7 +552,7 @@ static void *output_thread_i2s(void *arg) {
 /****************************************************************************************
  * Stats output thread
  */
-static void *output_thread_i2s_stats(void *arg) {
+static void output_thread_i2s_stats(void *arg) {
 	while (1) {
 		// no need to lock
 		output_state state = output.state;
@@ -579,7 +579,6 @@ static void *output_thread_i2s_stats(void *arg) {
 		}
 		vTaskDelay( pdMS_TO_TICKS( STATS_PERIOD_MS ) );
 	}
-	return NULL;
 }
 
 /****************************************************************************************

components/squeezelite/stream.c

@@ -21,7 +21,9 @@
 
 // stream thread
 
+#ifndef _GNU_SOURCE
 #define _GNU_SOURCE
+#endif
 
 #include "squeezelite.h"
 

main/cmd_wifi.c

@@ -37,7 +37,7 @@ extern bool bypass_wifi_manager;
 
 extern EventGroupHandle_t wifi_event_group;
 extern const int CONNECTED_BIT;
-static const char * TAG = "cmd_wifi";
+//static const char * TAG = "cmd_wifi";
 /** Arguments used by 'join' function */
 static struct {
     struct arg_int *timeout;
@@ -123,9 +123,8 @@ static bool wifi_join(const char *ssid, const char *pass, int timeout_ms)
     return (bits & CONNECTED_BIT) != 0;
 }
 
-
-static int set_auto_connect(int argc, char **argv)
-{
+//static int set_auto_connect(int argc, char **argv)
+//{
 //    int nerrors = arg_parse(argc, argv, (void **) &join_args);
 //    if (nerrors != 0) {
 //        arg_print_errors(stderr, join_args.end, argv[0]);
@@ -147,8 +146,9 @@ static int set_auto_connect(int argc, char **argv)
 //        return 1;
 //    }
 //    ESP_LOGI(__func__, "Connected");
-    return 0;
-}
+//    return 0;
+//}
+
 static int connect(int argc, char **argv)
 {
     int nerrors = arg_parse(argc, argv, (void **) &join_args);