Add multiple display support to image decoding.

4 files changed, 67 insertions, 66 deletions

diff --git a/src/gdisp/image.c b/src/gdisp/image.c
index 1e9ac3d6..62af0aeb 100644
--- a/src/gdisp/image.c
+++ b/src/gdisp/image.c
@@ -23,7 +23,8 @@ typedef struct gdispImageHandlers {
 	gdispImageError	(*open)(gdispImage *img);			/* The open function */
 	void			(*close)(gdispImage *img);			/* The close function */
 	gdispImageError	(*cache)(gdispImage *img);			/* The cache function */
-	gdispImageError	(*draw)(gdispImage *img,
+	gdispImageError	(*draw)(GDisplay *g,
+							gdispImage *img,
 							coord_t x, coord_t y,
 							coord_t cx, coord_t cy,
 							coord_t sx, coord_t sy);	/* The draw function */
@@ -33,27 +34,27 @@ typedef struct gdispImageHandlers {
 static gdispImageHandlers ImageHandlers[] = {
 	#if GDISP_NEED_IMAGE_NATIVE
 		{	gdispImageOpen_NATIVE,	gdispImageClose_NATIVE,
-			gdispImageCache_NATIVE,	gdispImageDraw_NATIVE,	gdispImageNext_NATIVE,
+			gdispImageCache_NATIVE,	gdispGImageDraw_NATIVE,	gdispImageNext_NATIVE,
 		},
 	#endif
 	#if GDISP_NEED_IMAGE_GIF
 		{	gdispImageOpen_GIF,		gdispImageClose_GIF,
-			gdispImageCache_GIF,	gdispImageDraw_GIF,		gdispImageNext_GIF,
+			gdispImageCache_GIF,	gdispGImageDraw_GIF,	gdispImageNext_GIF,
 		},
 	#endif
 	#if GDISP_NEED_IMAGE_BMP
 		{	gdispImageOpen_BMP,		gdispImageClose_BMP,
-			gdispImageCache_BMP,	gdispImageDraw_BMP,		gdispImageNext_BMP,
+			gdispImageCache_BMP,	gdispGImageDraw_BMP,	gdispImageNext_BMP,
 		},
 	#endif
 	#if GDISP_NEED_IMAGE_JPG
 		{	gdispImageOpen_JPG,		gdispImageClose_JPG,
-			gdispImageCache_JPG,	gdispImageDraw_JPG,		gdispImageNext_JPG,
+			gdispImageCache_JPG,	gdispGImageDraw_JPG,	gdispImageNext_JPG,
 		},
 	#endif
 	#if GDISP_NEED_IMAGE_PNG
 		{	gdispImageOpen_PNG,		gdispImageClose_PNG,
-			gdispImageCache_PNG,	gdispImageDraw_PNG,		gdispImageNext_PNG,
+			gdispImageCache_PNG,	gdispGImageDraw_PNG,	gdispImageNext_PNG,
 		},
 	#endif
 };
@@ -205,9 +206,9 @@ gdispImageError gdispImageCache(gdispImage *img) {
 	return img->fns->cache(img);
 }
 
-gdispImageError gdispImageDraw(gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
+gdispImageError gdispGImageDraw(GDisplay *g, gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
 	if (!img->fns) return GDISP_IMAGE_ERR_BADFORMAT;
-	return img->fns->draw(img, x, y, cx, cy, sx, sy);
+	return img->fns->draw(g, img, x, y, cx, cy, sx, sy);
 }
 
 delaytime_t gdispImageNext(gdispImage *img) {
diff --git a/src/gdisp/image_bmp.c b/src/gdisp/image_bmp.c
index e23d0fb1..158d6edc 100644
--- a/src/gdisp/image_bmp.c
+++ b/src/gdisp/image_bmp.c
@@ -828,7 +828,7 @@ gdispImageError gdispImageCache_BMP(gdispImage *img) {
 	return GDISP_IMAGE_ERR_OK;
 }
 
-gdispImageError gdispImageDraw_BMP(gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
+gdispImageError gdispGImageDraw_BMP(GDisplay *g, gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
 	gdispImagePrivate *	priv;
 	coord_t				mx, my;
 	coord_t				pos, len, st;
@@ -842,7 +842,7 @@ gdispImageError gdispImageDraw_BMP(gdispImage *img, coord_t x, coord_t y, coord_
 
 	/* Draw from the image cache - if it exists */
 	if (priv->frame0cache) {
-		gdispBlitAreaEx(x, y, cx, cy, sx, sy, img->width, priv->frame0cache);
+		gdispGBlitArea(g, x, y, cx, cy, sx, sy, img->width, priv->frame0cache);
 		return GDISP_IMAGE_ERR_OK;
 	}
 
@@ -864,9 +864,9 @@ gdispImageError gdispImageDraw_BMP(gdispImage *img, coord_t x, coord_t y, coord_
 					len = pos-st;
 					if (mx+st+len > sx+cx) len = sx+cx-mx-st;
 					if (len == 1)
-						gdispDrawPixel(x+mx+st-sx, y+my-sy, priv->buf[st]);
+						gdispGDrawPixel(g, x+mx+st-sx, y+my-sy, priv->buf[st]);
 					else
-						gdispBlitAreaEx(x+mx+st-sx, y+my-sy, len, 1, st, 0, pos, priv->buf);
+						gdispGBlitArea(g, x+mx+st-sx, y+my-sy, len, 1, st, 0, pos, priv->buf);
 				}
 				mx += pos;
 			}
@@ -882,9 +882,9 @@ gdispImageError gdispImageDraw_BMP(gdispImage *img, coord_t x, coord_t y, coord_
 					len = pos-st;
 					if (mx+st+len > sx+cx) len = sx+cx-mx-st;
 					if (len == 1)
-						gdispDrawPixel(x+mx+st-sx, y+my-sy, priv->buf[st]);
+						gdispGDrawPixel(g, x+mx+st-sx, y+my-sy, priv->buf[st]);
 					else
-						gdispBlitAreaEx(x+mx+st-sx, y+my-sy, len, 1, st, 0, pos, priv->buf);
+						gdispGBlitArea(g, x+mx+st-sx, y+my-sy, len, 1, st, 0, pos, priv->buf);
 				}
 				mx += pos;
 			}
diff --git a/src/gdisp/image_gif.c b/src/gdisp/image_gif.c
index d067bd0f..1ff72ff0 100644
--- a/src/gdisp/image_gif.c
+++ b/src/gdisp/image_gif.c
@@ -820,7 +820,7 @@ baddatacleanup:
 	return GDISP_IMAGE_ERR_BADDATA;
 }
 
-gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
+gdispImageError gdispGImageDraw_GIF(GDisplay *g, gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
 	gdispImagePrivate *	priv;
 	imgdecode *			decode;
 	uint8_t *			q = 0;
@@ -847,9 +847,9 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 			// The spec says to restore the backgound color (priv->bgcolor) but in practice if there is transparency
 			//	image decoders tend to assume that a restore to the transparent color is required instead
 			if (((priv->dispose.flags & GIFL_TRANSPARENT) /*&& priv->dispose.paltrans == priv->bgcolor*/) || priv->bgcolor >= priv->palsize)
-				gdispFillArea(x+mx-sx, y+my-sy, fx-mx, fy-my, img->bgcolor);
+				gdispGFillArea(g, x+mx-sx, y+my-sy, fx-mx, fy-my, img->bgcolor);
 			else
-				gdispFillArea(x+mx-sx, y+my-sy, fx-mx, fy-my, priv->palette[priv->bgcolor]);
+				gdispGFillArea(g, x+mx-sx, y+my-sy, fx-mx, fy-my, priv->palette[priv->bgcolor]);
 		}
 	}
 
@@ -881,23 +881,23 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 					// We have a transparent pixel - dump the buffer to the display
 					switch(gcnt) {
 					case 0:																							break;
-					case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-					default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+					case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+					default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 					}
 					continue;
 				}
 				priv->buf[gcnt++] = cache->palette[col];
 				if (gcnt >= BLIT_BUFFER_SIZE) {
 					// We have run out of buffer - dump it to the display
-					gdispBlitAreaEx(x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
+					gdispGBlitArea(g, x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
 					gcnt = 0;
 				}
 			}
 			// We have finished the line - dump the buffer to the display
 			switch(gcnt) {
-			case 0:																				break;
-			case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
-			default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
+			case 0:																					break;
+			case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
+			default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
 			}
 		}
 
@@ -935,15 +935,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 						// We have a transparent pixel - dump the buffer to the display
 						switch(gcnt) {
 						case 0:																							break;
-						case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-						default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+						case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+						default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 						}
 						continue;
 					}
 					priv->buf[gcnt++] = decode->palette[col];
 					if (gcnt >= BLIT_BUFFER_SIZE) {
 						// We have run out of buffer - dump it to the display
-						gdispBlitAreaEx(x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
+						gdispGBlitArea(g, x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
 						gcnt = 0;
 					}
 					continue;
@@ -951,15 +951,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 				// We have finished the visible area - dump the buffer to the display
 				switch(gcnt) {
 				case 0:																							break;
-				case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-				default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+				case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+				default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 				}
 			}
 			// We have finished the line - dump the buffer to the display
 			switch(gcnt) {
-			case 0:																				break;
-			case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
-			default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
+			case 0:																					break;
+			case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
+			default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
 			}
 		}
 		// Every 8th row starting at row 4
@@ -981,15 +981,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 						// We have a transparent pixel - dump the buffer to the display
 						switch(gcnt) {
 						case 0:																							break;
-						case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-						default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+						case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+						default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 						}
 						continue;
 					}
 					priv->buf[gcnt++] = decode->palette[col];
 					if (gcnt >= BLIT_BUFFER_SIZE) {
 						// We have run out of buffer - dump it to the display
-						gdispBlitAreaEx(x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
+						gdispGBlitArea(g, x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
 						gcnt = 0;
 					}
 					continue;
@@ -997,15 +997,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 				// We have finished the visible area - dump the buffer to the display
 				switch(gcnt) {
 				case 0:																							break;
-				case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-				default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+				case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+				default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 				}
 			}
 			// We have finished the line - dump the buffer to the display
 			switch(gcnt) {
-			case 0:																				break;
-			case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
-			default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
+			case 0:																					break;
+			case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
+			default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
 			}
 		}
 		// Every 4th row starting at row 2
@@ -1027,15 +1027,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 						// We have a transparent pixel - dump the buffer to the display
 						switch(gcnt) {
 						case 0:																							break;
-						case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-						default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+						case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+						default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 						}
 						continue;
 					}
 					priv->buf[gcnt++] = decode->palette[col];
 					if (gcnt >= BLIT_BUFFER_SIZE) {
 						// We have run out of buffer - dump it to the display
-						gdispBlitAreaEx(x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
+						gdispGBlitArea(g, x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
 						gcnt = 0;
 					}
 					continue;
@@ -1043,15 +1043,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 				// We have finished the visible area - dump the buffer to the display
 				switch(gcnt) {
 				case 0:																							break;
-				case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-				default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+				case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+				default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 				}
 			}
 			// We have finished the line - dump the buffer to the display
 			switch(gcnt) {
-			case 0:																				break;
-			case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
-			default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
+			case 0:																					break;
+			case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
+			default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
 			}
 		}
 		// Every 2nd row starting at row 1
@@ -1073,15 +1073,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 						// We have a transparent pixel - dump the buffer to the display
 						switch(gcnt) {
 						case 0:																							break;
-						case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-						default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+						case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+						default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 						}
 						continue;
 					}
 					priv->buf[gcnt++] = decode->palette[col];
 					if (gcnt >= BLIT_BUFFER_SIZE) {
 						// We have run out of buffer - dump it to the display
-						gdispBlitAreaEx(x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
+						gdispGBlitArea(g, x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
 						gcnt = 0;
 					}
 					continue;
@@ -1089,15 +1089,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 				// We have finished the visible area - dump the buffer to the display
 				switch(gcnt) {
 				case 0:																							break;
-				case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-				default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+				case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+				default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 				}
 			}
 			// We have finished the line - dump the buffer to the display
 			switch(gcnt) {
-			case 0:																				break;
-			case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
-			default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
+			case 0:																					break;
+			case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
+			default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
 			}
 		}
 	} else {
@@ -1120,15 +1120,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 						// We have a transparent pixel - dump the buffer to the display
 						switch(gcnt) {
 						case 0:																							break;
-						case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-						default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+						case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+						default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 						}
 						continue;
 					}
 					priv->buf[gcnt++] = decode->palette[col];
 					if (gcnt >= BLIT_BUFFER_SIZE) {
 						// We have run out of buffer - dump it to the display
-						gdispBlitAreaEx(x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
+						gdispGBlitArea(g, x+mx-sx-gcnt+1, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);
 						gcnt = 0;
 					}
 					continue;
@@ -1136,15 +1136,15 @@ gdispImageError gdispImageDraw_GIF(gdispImage *img, coord_t x, coord_t y, coord_
 				// We have finished the visible area - dump the buffer to the display
 				switch(gcnt) {
 				case 0:																							break;
-				case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;						break;
-				default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
+				case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]); gcnt = 0;					break;
+				default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf); gcnt = 0;	break;
 				}
 			}
 			// We have finished the line - dump the buffer to the display
 			switch(gcnt) {
-			case 0:																				break;
-			case 1:		gdispDrawPixel(x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
-			default:	gdispBlitAreaEx(x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
+			case 0:																					break;
+			case 1:		gdispGDrawPixel(g, x+mx-sx-gcnt, y+my-sy, priv->buf[0]);					break;
+			default:	gdispGBlitArea(g, x+mx-sx-gcnt, y+my-sy, gcnt, 1, 0, 0, gcnt, priv->buf);	break;
 			}
 		}
 	}
diff --git a/src/gdisp/image_native.c b/src/gdisp/image_native.c
index 24aed81f..72ae8b61 100644
--- a/src/gdisp/image_native.c
+++ b/src/gdisp/image_native.c
@@ -91,7 +91,7 @@ gdispImageError gdispImageCache_NATIVE(gdispImage *img) {
 	return GDISP_IMAGE_ERR_OK;
 }
 
-gdispImageError gdispImageDraw_NATIVE(gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
+gdispImageError gdispImageGDraw_NATIVE(GDisplay *g, gdispImage *img, coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t sx, coord_t sy) {
 	coord_t		mx, mcx;
 	size_t		pos, len;
 
@@ -102,7 +102,7 @@ gdispImageError gdispImageDraw_NATIVE(gdispImage *img, coord_t x, coord_t y, coo
 
 	/* Draw from the image cache - if it exists */
 	if (img->priv->frame0cache) {
-		gdispBlitAreaEx(x, y, cx, cy, sx, sy, img->width, img->priv->frame0cache);
+		gdispGBlitArea(g, x, y, cx, cy, sx, sy, img->width, img->priv->frame0cache);
 		return GDISP_IMAGE_ERR_OK;
 	}
 
@@ -125,7 +125,7 @@ gdispImageError gdispImageDraw_NATIVE(gdispImage *img, coord_t x, coord_t y, coo
 				return GDISP_IMAGE_ERR_BADDATA;
 
 			/* Blit the chunk of data */
-			gdispBlitAreaEx(mx, y, len, 1, 0, 0, len, img->priv->buf);
+			gdispGBlitArea(g, mx, y, len, 1, 0, 0, len, img->priv->buf);
 		}
 
 		/* Get the position for the start of the next line */