path: root/halext/src/gdisp_emulation.c

/*
    ChibiOS/RT - Copyright (C) 2012
                 Joel Bodenmann aka Tectu <joel@unormal.org>

    This file is part of ChibiOS-LCD-Driver.

    ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    ChibiOS-LCD-Driver is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*
	Emulation routines included into gdisp_lld.c
*/

/*
	Even though this is a software emulation of a low level driver
	most validation doesn't need to happen here as eventually
	we call a real low level driver routine and if validation is
	required - it will do it.
*/
#include "ch.h"
#include "hal.h"
#include "gdisp.h"

#if HAL_USE_GDISP || defined(__DOXYGEN__)

#ifdef UNUSED
#elif defined(__GNUC__)
# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
#elif defined(__LCLINT__)
# define UNUSED(x) /*@unused@*/ x
#else
# define UNUSED(x) x
#endif

#if !GDISP_HARDWARE_POWERCONTROL
	void gdisp_lld_setpowermode(gdisp_powermode_t UNUSED(powerMode)) {
	}
#endif

#if !GDISP_HARDWARE_ORIENTATION
	void gdisp_lld_setorientation(gdisp_orientation_t UNUSED(newOrientation)) {
	}
#endif

#if !GDISP_HARDWARE_CLEARS 
	void gdisp_lld_clear(color_t color) {
		gdisp_lld_fillarea(0, 0, GDISP.Width, GDISP.Height, color);
	}
#endif

#if !GDISP_HARDWARE_LINES 
	void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
		int16_t dy, dx;
		int16_t addx, addy;
		int16_t P, diff, i;

		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL
		// speed improvement if vertical or horizontal
		if (x0 == x1) {
			if (y1 > y0)
				gdisp_lld_fillarea(x0, y0, 1, y1-y0+1, color);
			else
				gdisp_lld_fillarea(x0, y1, 1, y0-y1+1, color);
			return;
		}
		if (y0 == y1) {
			if (x1 > x0)
				gdisp_lld_fillarea(x0, y0, x1-x0+1, 1, color);
			else
				gdisp_lld_fillarea(x0, y1, x0-x1+1, 1, color);
			return;
		}
		#endif

		if (x1 >= x0) {
			dx = x1 - x0;
			addx = 1;
		} else {
			dx = x0 - x1;
			addx = -1;
		}
		if (y1 >= y0) {
			dy = y1 - y0;
			addy = 1;
		} else {
			dy = y0 - y1;
			addy = -1;
		}

		if (dx >= dy) {
			dy *= 2;
			P = dy - dx;
			diff = P - dx;

			for(i=0; i<=dx; ++i) {
				gdisp_lld_drawpixel(x0, y0, color);
				if (P < 0) {
					P  += dy;
					x0 += addx;
				} else {
					P  += diff;
					x0 += addx;
					y0 += addy;
				}
			}
		} else {
			dx *= 2;
			P = dx - dy;
			diff = P - dy;

			for(i=0; i<=dy; ++i) {
				gdisp_lld_drawpixel(x0, y0, color);
				if (P < 0) {
					P  += dx;
					y0 += addy;
				} else {
					P  += diff;
					x0 += addx;
					y0 += addy;
				}
			}
		}
	}
#endif

#if !GDISP_HARDWARE_FILLS
	void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
		#if GDISP_HARDWARE_SCROLL
			gdisp_lld_verticalscroll(x, y, cx, cy, cy, color);
		#elif GDISP_HARDWARE_LINES
			coord_t x1, y1;
			
			x1 = x + cx - 1;
			y1 = y + cy;
			for(; y < y1; y++)
				gdisp_lld_drawline(x, y, x1, y, color);
		#else
			coord_t x0, x1, y1;
			
			x0 = x;
			x1 = x + cx;
			y1 = y + cy;
			for(; y < y1; y++)
				for(x = x0; x < x1; x++)
					gdisp_lld_drawpixel(x, y, color);
		#endif
	}
#endif

#if !GDISP_HARDWARE_BITFILLS
	void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {
			coord_t x0, x1, y1;
			
			x0 = x;
			x1 = x + cx;
			y1 = y + cy;
			for(; y < y1; y++)
				for(x = x0; x < x1; x++)
					gdisp_lld_drawpixel(x, y, *buffer++);
	}
#endif

#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES
	void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color) {
		int16_t a, b, P;

		a = 0;
		b = radius;
		P = 1 - radius;

		do {
			gdisp_lld_drawpixel(a+x, b+y, color);
			gdisp_lld_drawpixel(b+x, a+y, color);
			gdisp_lld_drawpixel(x-a, b+y, color);
			gdisp_lld_drawpixel(x-b, a+y, color);
			gdisp_lld_drawpixel(b+x, y-a, color);
			gdisp_lld_drawpixel(a+x, y-b, color);
			gdisp_lld_drawpixel(x-a, y-b, color);
			gdisp_lld_drawpixel(x-b, y-a, color);
			if (P < 0)
				P += 3 + 2*a++;
			else
				P += 5 + 2*(a++ - b--);
		} while(a <= b);
	}
#endif

#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS
	void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color) {
		int16_t a, b, P;
		
		a = 0;
		b = radius;
		P = 1 - radius;

		do {
			gdisp_lld_drawline(x-a, y+b, x+a, y+b, color);
			gdisp_lld_drawline(x-a, y-b, x+a, y-b, color);
			gdisp_lld_drawline(x-b, y+a, x+b, y+a, color);
			gdisp_lld_drawline(x-b, y-a, x+b, y-a, color);
			if (P < 0)
				P += 3 + 2*a++;
			else
				P += 5 + 2*(a++ - b--);
		} while(a <= b);
	}
#endif

#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES
	void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
		long a2 = a*a, b2 = b*b;
		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

		do {
			gdisp_lld_drawpixel(x+dx, y+dy, color); /* I. Quadrant */
			gdisp_lld_drawpixel(x-dx, y+dy, color); /* II. Quadrant */
			gdisp_lld_drawpixel(x-dx, y-dy, color); /* III. Quadrant */
			gdisp_lld_drawpixel(x+dx, y-dy, color); /* IV. Quadrant */

			e2 = 2*err;
			if(e2 <  (2*dx+1)*b2) {
				dx++;
				err += (2*dx+1)*b2;
			}
			if(e2 > -(2*dy-1)*a2) {
				dy--;
				err -= (2*dy-1)*a2;
			}
		} while(dy >= 0); 

		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
			gdisp_lld_drawpixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
			gdisp_lld_drawpixel(x-dx, y, color);
	   }   
	}
#endif

#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS
	void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
		long a2 = a*a, b2 = b*b;
		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

		do {
			gdisp_lld_drawline(x-dx,y+dy,x+dx,y+dy, color);
			gdisp_lld_drawline(x-dx,y-dy,x+dx,y-dy, color);

			e2 = 2*err;
			if(e2 <  (2*dx+1)*b2) {
				dx++;
				err += (2*dx+1)*b2;
			}
			if(e2 > -(2*dy-1)*a2) {
				dy--;
				err -= (2*dy-1)*a2;
			}
		} while(dy >= 0); 

		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
			gdisp_lld_drawpixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
			gdisp_lld_drawpixel(x-dx, y, color);
	   }   
	}
#endif

#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
	#include "gdisp_fonts.h"
#endif

#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
	void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color) {
		const fontcolumn_t	*ptr;
		fontcolumn_t		column;
		coord_t				width, height, xscale, yscale;
		coord_t				i, j, xs, ys;

		/* Check we actually have something to print */
		width = _getCharWidth(font, c);
		if (!width) return;
		
		xscale = font->xscale;
		yscale = font->yscale;
		height = font->height * yscale;
		width *= xscale;

		ptr = _getCharData(font, c);

		/* Loop through the data and display. The font data is LSBit first, down the column */
		for(i=0; i < width; i+=xscale) {
			/* Get the font bitmap data for the column */
			column = *ptr++;
			
			/* Draw each pixel */
			for(j=0; j < height; j+=yscale, column >>= 1) {
				if (column & 0x01) {
					for(xs=0; xs < xscale; xs++)
						for(ys=0; ys < yscale; ys++)
							gdisp_lld_drawpixel(x+i+xs, y+j+ys, color);
				}
			}
		}
	}
#endif

#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS
	void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
		coord_t			width, height;
		coord_t			xscale, yscale;
		
		/* Check we actually have something to print */
		width = _getCharWidth(font, c);
		if (!width) return;

		xscale = font->xscale;
		yscale = font->yscale;
		height = font->height * yscale;
		width *= xscale;

		/* Method 1: Use background fill and then draw the text */
		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW
			
			/* Fill the area */
			gdisp_lld_fillarea(x, y, width, height, bgcolor);
			
			/* Draw the text */
			gdisp_lld_drawchar(x, y, c, font, color);

		/* Method 2: Create a single column bitmap and then blit it */
		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN
		{
			const fontcolumn_t	*ptr;
			fontcolumn_t		column;
			coord_t				i, j, xs, ys;

			/* Working buffer for fast non-transparent text rendering [patch by Badger]
				This needs to be larger than the largest character we can print.
				Assume the max is double sized by one column.
			*/
			static pixel_t		buf[sizeof(fontcolumn_t)*8*2];

			#if GDISP_NEED_VALIDATION
				/* Check our buffer is big enough */
				if (height > sizeof(buf)/sizeof(buf[0]))	return;
			#endif

			ptr = _getCharData(font, c);

			/* Loop through the data and display. The font data is LSBit first, down the column */
			for(i = 0; i < width; i+=xscale) {
				/* Get the font bitmap data for the column */
				column = *ptr++;
				
				/* Draw each pixel */
				for(j = 0; j < height; j+=yscale, column >>= 1) {
					if (column & 0x01) {
						for(ys=0; ys < yscale; ys++)
							gdispPackPixels(buf, 1, j+ys, 0, color);
					} else {
						for(ys=0; ys < yscale; ys++)
							gdispPackPixels(buf, 1, j+ys, 0, bgcolor);
					}
				}

				for(xs=0; xs < xscale; xs++)
					gdisp_lld_blitarea(x+i+xs, y, 1, height, buf);
			}
		}

		/* Method 3: Create a character bitmap and then blit it */
		#elif GDISP_HARDWARE_BITFILLS
		{
			const fontcolumn_t	*ptr;
			fontcolumn_t		column;
			coord_t				i, j, xs, ys;
			
			/* Working buffer for fast non-transparent text rendering [patch by Badger]
				This needs to be larger than the largest character we can print.
				Assume the max is double sized.
			*/
			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)*2];

			#if GDISP_NEED_VALIDATION
				/* Check our buffer is big enough */
				if (width * height > sizeof(buf)/sizeof(buf[0]))	return;
			#endif

			ptr = _getCharData(font, c);

			/* Loop through the data and display. The font data is LSBit first, down the column */
			for(i = 0; i < width; i+=xscale) {
				/* Get the font bitmap data for the column */
				column = *ptr++;
				
				/* Draw each pixel */
				for(j = 0; j < height; j+=yscale, column >>= 1) {
					if (column & 0x01) {
						for(xs=0; xs < xscale; xs++)
							for(ys=0; ys < yscale; ys++)
								gdispPackPixels(buf, width, i+xs, j+ys, color);
					} else {
						for(xs=0; xs < xscale; xs++)
							for(ys=0; ys < yscale; ys++)
								gdispPackPixels(buf, width, i+xs, j+ys, bgcolor);
					}
				}
			}

			/* [Patch by Badger] Write all in one stroke */
			gdisp_lld_blitarea(x, y, width, height, buf);
		}

		/* Method 4: Draw pixel by pixel */
		#else
		{
			const fontcolumn_t	*ptr;
			fontcolumn_t		column;
			coord_t				i, j, xs, ys;

			ptr = _getCharData(font, c);

			/* Loop through the data and display. The font data is LSBit first, down the column */
			for(i = 0; i < width; i+=xscale) {
				/* Get the font bitmap data for the column */
				column = *ptr++;
				
				/* Draw each pixel */
				for(j = 0; j < height; j+=yscale, column >>= 1) {
					if (column & 0x01) {
						for(xs=0; xs < xscale; xs++)
							for(ys=0; ys < yscale; ys++)
								gdisp_lld_drawpixel(x+i, y+j, color);
					} else {
						for(xs=0; xs < xscale; xs++)
							for(ys=0; ys < yscale; ys++)
								gdisp_lld_drawpixel(x+i, y+j, bgcolor);
					}
				}
			}
		}
		#endif
	}
#endif


#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL
	void gdisp_lld_control(int UNUSED(what), void *UNUSED(value)) {
		/* Ignore everything */
	}
#endif

#endif  /* HAL_USE_GDISP */