add lcd display code for Tripledragon, mostly from tuxbox

git-svn-id: file:///home/bas/coolstream_public_svn/THIRDPARTY/applications/neutrino-experimental@964 e54a6e83-5905-42d5-8d5c-058d10e6a962

src/lcddisplay/Makefile.am

@@ -0,0 +1,7 @@
+noinst_LIBRARIES = liblcddisplay.a
+
+liblcddisplay_a_SOURCES = lcddisplay.cpp fontrenderer.cpp
+
+AM_CXXFLAGS = \
+	@FREETYPE_CFLAGS@ \
+	@PNG_CFLAGS@

src/lcddisplay/fontrenderer.cpp

@@ -0,0 +1,387 @@
+/*
+        $Header$        
+
+	LCD-Daemon  -   DBoxII-Project
+
+	Copyright (C) 2001 Steffen Hehn 'McClean'
+	Copyright (C) 2003 thegoodguy
+		baseroutines by tmbinc
+
+
+	License: GPL
+
+	This program 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 2 of the License, or
+	(at your option) any later version.
+
+	This program 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, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <config.h>
+
+#include "fontrenderer.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+/* tested with freetype 2.3.9, and 2.1.4 */
+#if FREETYPE_MAJOR >= 2 && FREETYPE_MINOR >= 3
+#define FT_NEW_CACHE_API
+#endif
+
+FT_Error LcdFontRenderClass::myFTC_Face_Requester(FTC_FaceID  face_id,
+                            FT_Library  library,
+                            FT_Pointer  request_data,
+                            FT_Face*    aface)
+{
+	return ((LcdFontRenderClass*)request_data)->FTC_Face_Requester(face_id, aface);
+}
+
+
+LcdFontRenderClass::LcdFontRenderClass(CLCDDisplay * fb)
+{
+	framebuffer = fb;
+	printf("[LCDFONT] initializing core...");
+	fflush(stdout);
+	if (FT_Init_FreeType(&library))
+	{
+		printf("failed.\n");
+		return;
+	}
+	printf("\n");
+	font=0;
+	pthread_mutex_init(&render_mutex, NULL);
+}
+
+LcdFontRenderClass::~LcdFontRenderClass()
+{
+	FTC_Manager_Done(cacheManager);
+	FT_Done_FreeType(library);
+}
+
+void LcdFontRenderClass::InitFontCache()
+{
+	printf("[LCDFONT] Intializing font cache...");
+	fflush(stdout);
+	if (FTC_Manager_New(library, 3, 0, 0, myFTC_Face_Requester, this, &cacheManager))
+	{
+		printf(" manager failed!\n");
+		return;
+	}
+	if (!cacheManager)
+	{
+		printf(" error.\n");
+		return;
+	}
+	if (FTC_SBitCache_New(cacheManager, &sbitsCache))
+	{
+		printf(" sbit failed!\n");
+		return;
+	}
+	if (FTC_ImageCache_New(cacheManager, &imageCache))
+	{
+		printf(" imagecache failed!\n");
+	}
+	printf("\n");
+}
+
+FT_Error LcdFontRenderClass::FTC_Face_Requester(FTC_FaceID  face_id,
+                            FT_Face*    aface)
+{
+	fontListEntry *font=(fontListEntry *)face_id;
+	if (!font)
+		return -1;
+	printf("[LCDFONT] FTC_Face_Requester (%s/%s)\n", font->family, font->style);
+
+	int error;
+	if ((error=FT_New_Face(library, font->filename, 0, aface)))
+	{
+		printf(" failed: %i\n", error);
+		return error;
+	}
+	return 0;
+}                                                                                                                                
+
+FTC_FaceID LcdFontRenderClass::getFaceID(const char *family, const char *style)
+{
+	for (fontListEntry *f=font; f; f=f->next)
+	{
+		if ((!strcmp(f->family, family)) && (!strcmp(f->style, style)))
+			return (FTC_FaceID)f;
+	}
+	for (fontListEntry *f=font; f; f=f->next)
+	{
+		if (!strcmp(f->family, family))
+			return (FTC_FaceID)f;
+	}
+	return 0;
+}
+
+#ifdef FT_NEW_CACHE_API
+FT_Error LcdFontRenderClass::getGlyphBitmap(FTC_ImageType font, FT_ULong glyph_index, FTC_SBit *sbit)
+{
+	return FTC_SBitCache_Lookup(sbitsCache, font, glyph_index, sbit, NULL);
+}
+#else
+FT_Error LcdFontRenderClass::getGlyphBitmap(FTC_Image_Desc *font, FT_ULong glyph_index, FTC_SBit *sbit)
+{
+	return FTC_SBit_Cache_Lookup(sbitsCache, font, glyph_index, sbit);
+}
+#endif
+
+const char * LcdFontRenderClass::AddFont(const char * const filename)
+{
+	printf("[LCDFONT] adding font %s...", filename);
+	fflush(stdout);
+	int error;
+	fontListEntry *n=new fontListEntry;
+
+	FT_Face face;
+	if ((error=FT_New_Face(library, filename, 0, &face)))
+	{
+		printf(" failed: %i\n", error);
+		delete n;
+		return NULL;
+	}
+	n->filename = strdup(filename);
+	n->family   = strdup(face->family_name);
+	n->style    = strdup(face->style_name);
+	FT_Done_Face(face);
+
+	n->next=font;
+	printf("OK (%s/%s)\n", n->family, n->style);
+	font=n;
+	return n->style;
+}
+
+LcdFontRenderClass::fontListEntry::~fontListEntry()
+{
+	free(filename);
+	free(family);
+	free(style);
+}
+
+LcdFont *LcdFontRenderClass::getFont(const char *family, const char *style, int size)
+{
+	FTC_FaceID id=getFaceID(family, style);
+	if (!id)
+		return 0;
+	return new LcdFont(framebuffer, this, id, size);
+}
+
+LcdFont::LcdFont(CLCDDisplay * fb, LcdFontRenderClass *render, FTC_FaceID faceid, int isize)
+{
+	framebuffer=fb;
+	renderer=render;
+#ifdef FT_NEW_CACHE_API
+	font.face_id=faceid;
+	font.width  = isize;
+	font.height = isize;
+	font.flags  = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_MONOCHROME;
+#else
+	font.font.face_id=faceid;
+	font.font.pix_width  = isize;
+	font.font.pix_height = isize;
+	font.image_type = ftc_image_mono;
+	font.image_type |= ftc_image_flag_autohinted;
+#endif
+}
+
+FT_Error LcdFont::getGlyphBitmap(FT_ULong glyph_index, FTC_SBit *sbit)
+{
+	return renderer->getGlyphBitmap(&font, glyph_index, sbit);
+}
+
+int UTF8ToUnicode(const char * &text, const bool utf8_encoded) // returns -1 on error
+{
+	int unicode_value;
+	
+	if (utf8_encoded && ((((unsigned char)(*text)) & 0x80) != 0))
+	{
+		int remaining_unicode_length;
+		if ((((unsigned char)(*text)) & 0xf8) == 0xf0)
+		{
+			unicode_value = ((unsigned char)(*text)) & 0x07;
+			remaining_unicode_length = 3;
+		}
+		else if ((((unsigned char)(*text)) & 0xf0) == 0xe0)
+		{
+			unicode_value = ((unsigned char)(*text)) & 0x0f;
+			remaining_unicode_length = 2;
+		}
+		else if ((((unsigned char)(*text)) & 0xe0) == 0xc0)
+		{
+			unicode_value = ((unsigned char)(*text)) & 0x1f;
+			remaining_unicode_length = 1;
+		}
+		else                     // cf.: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
+			return -1;       // corrupted character or a character with > 4 bytes utf-8 representation
+		
+		for (int i = 0; i < remaining_unicode_length; i++)
+		{
+			text++;
+			if (((*text) & 0xc0) != 0x80)
+			{
+				remaining_unicode_length = -1;
+				return -1;          // incomplete or corrupted character
+			}
+			unicode_value <<= 6;
+			unicode_value |= ((unsigned char)(*text)) & 0x3f;
+		}
+		if (remaining_unicode_length == -1)
+			return -1;                  // incomplete or corrupted character
+	}
+	else
+		unicode_value = (unsigned char)(*text);
+
+	return unicode_value;
+}
+
+void LcdFont::RenderString(int x, int y, const int width, const char * text, const int color, const int selected, const bool utf8_encoded)
+{
+	int err;
+	pthread_mutex_lock(&renderer->render_mutex);
+
+#ifdef FT_NEW_CACHE_API
+	FTC_ScalerRec scaler;
+
+	scaler.face_id = font.face_id;
+	scaler.width   = font.width;
+	scaler.height  = font.height;
+	scaler.pixel   = true;
+
+	if ((err = FTC_Manager_LookupSize(renderer->cacheManager, &scaler, &size)) != 0)
+#else
+	if ((err=FTC_Manager_Lookup_Size(renderer->cacheManager, &font.font, &face, &size))!=0)
+#endif
+	{ 
+		printf("FTC_Manager_Lookup_Size failed! (%d)\n",err);
+		pthread_mutex_unlock(&renderer->render_mutex);
+		return;
+	}
+	int left=x, step_y=(size->metrics.height >> 6 )*3/4 + 4;
+
+	int pos =0;
+	for (; *text; text++)
+	{
+		pos++;
+		FTC_SBit glyph;
+		//if ((x + size->metrics.x_ppem > (left+width)) || (*text=='\n'))
+		if (x + size->metrics.x_ppem > (left+width))
+		{ //width clip
+			break;
+		}
+		if (*text=='\n')
+		{
+		  x  = left;
+		  y += step_y;
+		}
+
+		int unicode_value = UTF8ToUnicode(text, utf8_encoded);
+
+		if (unicode_value == -1)
+			break;
+
+#ifdef FT_NEW_CACHE_API
+		int index = FT_Get_Char_Index(size->face, unicode_value);
+#else
+		int index = FT_Get_Char_Index(face, unicode_value);
+#endif
+
+		if (!index)
+		  continue;
+		if (getGlyphBitmap(index, &glyph))
+		{
+		  printf("failed to get glyph bitmap.\n");
+		  continue;
+		}
+    
+		int rx=x+glyph->left;
+		int ry=y-glyph->top;
+		if(pos==selected)
+		{
+			framebuffer->draw_fill_rect(x-2,y-glyph->height-2, x+glyph->width+2, y+2, CLCDDisplay::PIXEL_INV );
+		}
+		
+		for (int ay=0; ay<glyph->height; ay++)
+		{
+			int ax=0;
+			int w=glyph->width;
+			int xpos = rx;
+			for (; ax<w; ax++)
+			{
+				unsigned char c = glyph->buffer[ay*abs(glyph->pitch)+(ax>>3)];
+				if((c>>(7-(ax&7)))&1)
+				framebuffer->draw_point(xpos,ry, color);
+				xpos ++;
+			}
+		ry++;
+		}
+
+		x+=glyph->xadvance+1;
+	}
+	pthread_mutex_unlock(&renderer->render_mutex);
+}
+
+int LcdFont::getRenderWidth(const char * text, const bool utf8_encoded)
+{
+	pthread_mutex_lock(&renderer->render_mutex);
+	FT_Error err;
+#ifdef FT_NEW_CACHE_API
+	FTC_ScalerRec scaler;
+	scaler.face_id = font.face_id;
+	scaler.width   = font.width;
+	scaler.height  = font.height;
+	scaler.pixel   = true;
+
+	err = FTC_Manager_LookupSize(renderer->cacheManager, &scaler, &size);
+#else
+	err = FTC_Manager_Lookup_Size(renderer->cacheManager, &font.font, &face, &size);
+#endif
+	if (err != 0)
+	{ 
+		printf("FTC_Manager_Lookup_Size failed! (0x%x)\n", err);
+		pthread_mutex_unlock(&renderer->render_mutex);
+		return -1;
+	}
+	int x=0;
+	for (; *text; text++)
+	{
+		FTC_SBit glyph;
+
+		int unicode_value = UTF8ToUnicode(text, utf8_encoded);
+
+		if (unicode_value == -1)
+			break;
+
+#ifdef FT_NEW_CACHE_API
+		int index = FT_Get_Char_Index(size->face, unicode_value);
+#else
+		int index=FT_Get_Char_Index(face, unicode_value);
+#endif
+
+		if (!index)
+			continue;
+		if (getGlyphBitmap(index, &glyph))
+		{
+			printf("failed to get glyph bitmap.\n");
+			continue;
+		}
+    
+		x+=glyph->xadvance+1;
+	}
+	pthread_mutex_unlock(&renderer->render_mutex);
+	return x;
+}
+

src/lcddisplay/fontrenderer.h

@@ -0,0 +1,115 @@
+/*
+        $Header$
+
+	LCD-Daemon  -   DBoxII-Project
+
+	Copyright (C) 2001 Steffen Hehn 'McClean'
+		baseroutines by tmbinc
+	Homepage: http://dbox.cyberphoria.org/
+
+
+
+	License: GPL
+
+	This program 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 2 of the License, or
+	(at your option) any later version.
+
+	This program 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, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __LCDFONTRENDERER__
+#define __LCDFONTRENDERER__
+
+#include "lcddisplay.h"
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_CACHE_H
+#include FT_CACHE_IMAGE_H
+#include FT_CACHE_SMALL_BITMAPS_H
+
+#include <asm/types.h>
+
+
+
+class LcdFontRenderClass;
+class LcdFont
+{
+        CLCDDisplay             *framebuffer;
+#if FREETYPE_MAJOR >= 2 && FREETYPE_MINOR >= 3
+        FTC_ImageTypeRec        font;
+#else
+        FTC_Image_Desc  font;
+        FT_Face                 face;
+#endif
+        LcdFontRenderClass *renderer;
+        FT_Size                 size;
+
+        FT_Error getGlyphBitmap(FT_ULong glyph_index, FTC_SBit *sbit);
+
+        public:
+                void RenderString(int x, int y, int width, const char *text, int color, int selected=0, const bool utf8_encoded = false);
+
+                int getRenderWidth(const char *text, const bool utf8_encoded = false);
+
+                LcdFont(CLCDDisplay *fb, LcdFontRenderClass *render, FTC_FaceID faceid, int isize);
+                ~LcdFont(){}
+};
+
+
+class LcdFontRenderClass
+{ 
+	CLCDDisplay *framebuffer;
+
+	struct fontListEntry
+	{
+		char *filename, *style, *family;
+		fontListEntry *next;
+		~fontListEntry();
+	} *font;
+
+	FT_Library		library;
+	FTC_Manager		cacheManager;        /* the cache manager               */
+	FTC_ImageCache	imageCache;          /* the glyph image cache           */
+	FTC_SBitCache	sbitsCache;          /* the glyph small bitmaps cache   */
+
+	FTC_FaceID getFaceID(const char *family, const char *style);
+#if FREETYPE_MAJOR >= 2 && FREETYPE_MINOR >= 3
+	FT_Error getGlyphBitmap(FTC_ImageType font, FT_ULong glyph_index, FTC_SBit *sbit);
+#else
+	FT_Error getGlyphBitmap(FTC_Image_Desc *font, FT_ULong glyph_index, FTC_SBit *sbit);
+#endif
+
+	public:
+		pthread_mutex_t render_mutex;
+		const char * AddFont(const char * const filename);
+		void InitFontCache();
+
+		FT_Error FTC_Face_Requester(FTC_FaceID  face_id,
+                              FT_Face*    aface);
+
+
+		static FT_Error myFTC_Face_Requester(FTC_FaceID  face_id,
+                            FT_Library  library,
+                            FT_Pointer  request_data,
+                            FT_Face*    aface);
+
+		//FT_Face getFace(const char *family, const char *style);
+		LcdFont *getFont(const char *family, const char *style, int size);
+		LcdFontRenderClass(CLCDDisplay *fb);
+		~LcdFontRenderClass();
+
+
+	friend class LcdFont;
+};
+
+#endif /* __LCDFONTRENDERER__ */

src/lcddisplay/lcddisplay.cpp

@@ -0,0 +1,501 @@
+/*
+	LCD-Daemon  -   DBoxII-Project
+
+	Copyright (C) 2001 Steffen Hehn 'McClean'
+        baseroutines by Shadow_
+	Homepage: http://dbox.cyberphoria.org/
+
+
+
+	License: GPL
+
+	This program 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 2 of the License, or
+	(at your option) any later version.
+
+	This program 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, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <config.h>
+#include "lcddisplay.h"
+
+#include <png.h>
+
+#include <stdint.h> /* uint8_t */
+#include <fcntl.h>
+#include <cstdio>
+#include <cstdlib>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+
+CLCDDisplay::CLCDDisplay()
+{
+	paused=0;
+	available = false;
+#ifndef HAVE_GENERIC_HARDWARE
+	//open device
+	if ((fd = open(LCD_DEVICE, O_RDWR)) < 0)
+	{
+		perror("LCD (" LCD_DEVICE ")");
+		return;
+	}
+
+	//clear the display
+	if ( ioctl(fd,LCD_IOCTL_CLEAR) < 0)
+	{
+		perror("clear failed");
+		return;
+	}
+	
+	//graphic (binary) mode 
+#ifdef HAVE_TRIPLEDRAGON
+	if (ioctl(fd, IOC_LCD_WRMODE, LCD_MODE_BIN) < 0)
+#else
+	int i=LCD_MODE_BIN;
+	if ( ioctl(fd,LCD_IOCTL_ASC_MODE,&i) < 0 )
+#endif
+	{
+		perror("graphic mode failed");
+		return;
+	}
+
+	available = true;
+#endif
+	iconBasePath = "";
+}
+
+bool CLCDDisplay::isAvailable()
+{
+	return available;
+}
+
+CLCDDisplay::~CLCDDisplay()
+{
+	close(fd);
+}
+
+void CLCDDisplay::pause()
+{
+	paused = 1;
+}
+
+void CLCDDisplay::resume()
+{
+#ifndef HAVE_GENERIC_HARDWARE
+	//clear the display
+	if ( ioctl(fd,LCD_IOCTL_CLEAR) < 0)
+	{
+		perror("clear failed");
+		return;
+	}
+	
+	//graphic (binary) mode 
+#ifdef HAVE_TRIPLEDRAGON
+	if (ioctl(fd, IOC_LCD_WRMODE, LCD_MODE_BIN) < 0)
+#else
+	int i=LCD_MODE_BIN;
+	if ( ioctl(fd,LCD_IOCTL_ASC_MODE,&i) < 0 )
+#endif
+	{
+		perror("graphic mode failed");
+		return;
+	}
+#endif
+	paused = 0;
+}
+
+#ifdef HAVE_TRIPLEDRAGON
+void CLCDDisplay::convert_data()
+{
+	int x, y, xx, xp, yp;
+	unsigned char pix, bit;
+
+	/* 128x64 (8bpp) membuffer -> 16*64 (1bpp) lcdbuffer */
+	/* TODO: extend skins to 128x64 */
+
+	/* the strange offset handling comes from a bug (probably) in the
+	   TD LCD driver: the MSB (0x80) of the first byte (lcd[0]) written to
+	   the device actually appears on the lower right, 8 pixels up, so we
+	   must shift the whole buffer one pixel to the right. This is wrong for
+	   the column 127 (rightmost), which is shifted up 8 lines.
+	 */
+	for (y = 0; y < LCD_LINES; y++) {
+		for (x = 0; x < LCD_STRIDE; x++) {
+			pix = 0;
+			bit = 0x80;
+
+			for (xx = x * 8; xx < x * 8 + 8; xx++, bit >>= 1) {
+				xp = xx - 1;		/* shift the whole buffer one pixel to the right */
+				yp = y;
+				if (xp < 0) {		/* rightmost column (column 127) */
+					xp += LCD_COLS;	/* wraparound */
+					yp -= 8;	/* shift down 8 lines */
+					if (yp < 0)	/* wraparound */
+						yp += LCD_LINES;
+				}
+				if (raw[yp][xp] == 1)
+					pix |= bit;
+			}
+/* I was chasing this one for quite some time, so check it for now */
+#if 1
+		if (y * LCD_STRIDE + x > LCD_BUFFER_SIZE)
+			fprintf(stderr, "%s: y (%d) * LCD_STRIDE (%d) + x (%d) (== %d) > LCD_BUFFER_SIZE (%d)\n",
+				__FUNCTION__, y, LCD_STRIDE, x, y*LCD_STRIDE+x, LCD_BUFFER_SIZE);
+		else
+#endif
+			lcd[y * LCD_STRIDE + x] = pix;
+		}
+	}
+
+#if 0
+/* alternative solution, just ignore the rightmost column (which would be the
+   MSB of the first byte */
+	for (y=0; y<64; y++){
+		for (x=0; x<(128/8); x++){
+			int pix=0, start = 0;
+			unsigned char bit = 0x80;
+			int offset=(y*128)+x*8;
+			if (x == 0) {	/* first column, skip MSB */
+				start = 1;
+				bit = 0x40;
+			} else
+				offset--;
+			for (yy=start; yy<8; yy++, bit >>=1) {
+				pix|=(_buffer[offset++]>=108)?bit:0;
+			}
+			raw[y*16+x]=pix;
+		}
+	}
+#endif
+}
+#else
+void CLCDDisplay::convert_data ()
+{
+#ifndef HAVE_GENERIC_HARDWARE
+	unsigned int x, y, z;
+	char tmp;
+
+	for (x = 0; x < LCD_COLS; x++)
+	{   
+		for (y = 0; y < LCD_ROWS; y++)
+		{
+			tmp = 0;
+
+			for (z = 0; z < 8; z++)
+				if (raw[y * 8 + z][x] == 1)
+					tmp |= (1 << z);
+
+			lcd[y][x] = tmp;
+		}
+	}
+#endif
+}
+#endif
+
+void CLCDDisplay::update()
+{
+#ifndef HAVE_GENERIC_HARDWARE
+	convert_data();
+	if(paused || !available)
+		return;
+	else
+		if ( write(fd, lcd, LCD_BUFFER_SIZE) < 0) {
+			perror("lcdd: CLCDDisplay::update(): write()");
+		}
+#endif
+}
+
+void CLCDDisplay::draw_point(const int x, const int y, const int state)
+{
+	if ((x < 0) || (x >= LCD_COLS) || (y < 0) || (y >= (LCD_ROWS * 8)))
+		return;
+
+	if (state == LCD_PIXEL_INV)
+		raw[y][x] ^= 1;
+	else
+		raw[y][x] = state;
+}
+
+
+/*
+ * draw_line
+ * 
+ * args:
+ * x1    StartCol
+ * y1    StartRow
+ * x2    EndCol
+ * y1    EndRow
+ * state LCD_PIXEL_OFF/LCD_PIXEL_ON/LCD_PIXEL_INV
+ * 
+ */
+void CLCDDisplay::draw_line(const int x1, const int y1, const int x2, const int y2, const int state)  
+{
+	int dx = abs (x1 - x2);
+	int dy = abs (y1 - y2);
+	int x;
+	int y;
+	int End;
+	int step;
+
+	if ( dx > dy )
+	{
+		int	p = 2 * dy - dx;
+		int	twoDy = 2 * dy;
+		int	twoDyDx = 2 * (dy-dx);
+
+		if ( x1 > x2 )
+		{
+			x = x2;
+			y = y2;
+			End = x1;
+			step = y1 < y2 ? -1 : 1;
+		}
+		else
+		{
+			x = x1;
+			y = y1;
+			End = x2;
+			step = y2 < y1 ? -1 : 1;
+		}
+
+		draw_point(x, y, state);
+
+		while( x < End )
+		{
+			x++;
+			if ( p < 0 )
+				p += twoDy;
+			else
+			{
+				y += step;
+				p += twoDyDx;
+			}
+			draw_point(x, y, state);
+		}
+	}
+	else
+	{
+		int	p = 2 * dx - dy;
+		int	twoDx = 2 * dx;
+		int	twoDxDy = 2 * (dx-dy);
+
+		if ( y1 > y2 )
+		{
+			x = x2;
+			y = y2;
+			End = y1;
+			step = x1 < x2 ? -1 : 1;
+		}
+		else
+		{
+			x = x1;
+			y = y1;
+			End = y2;
+			step = x2 < x1 ? -1 : 1;
+		}
+
+		draw_point(x, y, state);
+
+		while( y < End )
+		{
+			y++;
+			if ( p < 0 )
+				p += twoDx;
+			else
+			{
+				x += step;
+				p += twoDxDy;
+			}
+			draw_point(x, y, state);
+		}
+	}
+}
+
+
+void CLCDDisplay::draw_fill_rect (int left,int top,int right,int bottom,int state) {
+	int x,y;
+	for(x = left + 1;x < right;x++) {  
+		for(y = top + 1;y < bottom;y++) {
+			draw_point(x,y,state);
+		}
+	}
+}
+
+
+void CLCDDisplay::draw_rectangle (int left,int top, int right, int bottom, int linestate,int fillstate)
+{
+	// coordinate checking in draw_pixel (-> you can draw lines only
+	// partly on screen)
+
+	draw_line(left,top,right,top,linestate);
+	draw_line(left,top,left,bottom,linestate);
+	draw_line(right,top,right,bottom,linestate);
+	draw_line(left,bottom,right,bottom,linestate);
+	draw_fill_rect(left,top,right,bottom,fillstate);  
+}  
+
+
+void CLCDDisplay::draw_polygon(int num_vertices, int *vertices, int state) 
+{
+
+	// coordinate checking in draw_pixel (-> you can draw polygons only
+	// partly on screen)
+
+	int i;
+	for(i=0;i<num_vertices-1;i++) {
+		draw_line(vertices[(i<<1)+0],
+			vertices[(i<<1)+1],
+			vertices[(i<<1)+2],
+			vertices[(i<<1)+3],
+			state);
+	}
+   
+	draw_line(vertices[0],
+		vertices[1],
+		vertices[(num_vertices<<1)-2],
+		vertices[(num_vertices<<1)-1],
+		state);
+}
+
+
+struct rawHeader
+{
+	uint8_t width_lo;
+	uint8_t width_hi;
+	uint8_t height_lo;
+	uint8_t height_hi;
+	uint8_t transp;
+} __attribute__ ((packed));
+
+bool CLCDDisplay::paintIcon(std::string filename, int x, int y, bool invert)
+{
+	struct rawHeader header;
+	uint16_t         stride;
+	uint16_t         height;
+	unsigned char *  pixpos;
+
+	int _fd;
+	filename = iconBasePath + filename;
+
+	_fd = open(filename.c_str(), O_RDONLY );
+	
+	if (_fd==-1)
+	{
+		printf("\nerror while loading icon: %s\n\n", filename.c_str() );
+		return false;
+	}
+
+	read(_fd, &header, sizeof(struct rawHeader));
+
+	stride = ((header.width_hi << 8) | header.width_lo) >> 1;
+	height = (header.height_hi << 8) | header.height_lo;
+
+	unsigned char pixbuf[200];
+	while (height-- > 0)
+	{
+		read(fd, &pixbuf, stride);
+		pixpos = (unsigned char*) &pixbuf;
+		for (int count2 = 0; count2 < stride; count2++)
+		{
+			unsigned char compressed = *pixpos;
+
+			draw_point(x + (count2 << 1)    , y, ((((compressed & 0xf0) >> 4) != header.transp) ^ invert) ? PIXEL_ON : PIXEL_OFF);
+			draw_point(x + (count2 << 1) + 1, y, (( (compressed & 0x0f)       != header.transp) ^ invert) ? PIXEL_ON : PIXEL_OFF);
+
+			pixpos++;
+		}
+		y++;
+	}
+	
+	close(_fd);
+	return true;
+}
+
+void CLCDDisplay::dump_screen(raw_display_t *screen) {
+	memcpy(screen, raw, sizeof(raw_display_t));
+}
+
+void CLCDDisplay::load_screen(const raw_display_t * const screen) {
+	memcpy(raw, screen, sizeof(raw_display_t));
+}
+
+bool CLCDDisplay::load_png(const char * const filename)
+{
+	png_structp  png_ptr;
+	png_infop    info_ptr;
+	unsigned int i;
+	unsigned int pass;
+	unsigned int number_passes;
+	int          bit_depth;
+	int          color_type;
+	int          interlace_type;
+	png_uint_32  width;
+	png_uint_32  height;
+	png_byte *   fbptr;
+	FILE *       fh;
+	bool         ret_value = false;
+
+	if ((fh = fopen(filename, "rb")))
+	{
+		if ((png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)))
+		{
+			if (!(info_ptr = png_create_info_struct(png_ptr)))
+				png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+			else
+			{
+				if (!(setjmp(png_ptr->jmpbuf)))
+				{
+					png_init_io(png_ptr,fh);
+					
+					png_read_info(png_ptr, info_ptr);
+					png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
+					
+					if (
+						(color_type == PNG_COLOR_TYPE_PALETTE) &&
+						(bit_depth  == 1                     ) &&
+						(width      <= LCD_COLS              ) &&
+						(height     == (LCD_ROWS * 8))
+						)
+					{
+						png_set_packing(png_ptr); /* expand to 1 byte blocks */
+						
+						number_passes = png_set_interlace_handling(png_ptr);
+						png_read_update_info(png_ptr,info_ptr);
+						
+						if (width == png_get_rowbytes(png_ptr, info_ptr))
+						{
+							ret_value = true;
+							
+							for (pass = 0; pass < number_passes; pass++)
+							{
+								fbptr = (png_byte *)raw;
+								for (i = 0; i < height; i++, fbptr += LCD_COLS)
+								{
+									png_read_row(png_ptr, fbptr, NULL);
+									/* if the PNG is smaller, than the display width... */
+									if (width < LCD_COLS)	/* clear the area right of the PNG */
+										memset(fbptr + width, 0, LCD_COLS - width);
+								}
+							}
+							png_read_end(png_ptr, info_ptr);
+						}
+					}
+				}
+				png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+			}
+		}
+		fclose(fh);
+	}
+	return ret_value;
+}

src/lcddisplay/lcddisplay.h

@@ -26,7 +26,38 @@
 	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
+#ifdef HAVE_GENERIC_HARDWARE
+// dummy
+#define LCD_ROWS	8
+#define LCD_COLS	120
+#define LCD_PIXEL_OFF	0
+#define LCD_PIXEL_ON	1
+#define LCD_PIXEL_INV	2
+
+#else
+#ifndef HAVE_TRIPLEDRAGON
+/* dreambox is actually compatible to dbox2 wrt. lcd */
 #include <dbox/lcd-ks0713.h>
+#define LCD_DEVICE	"/dev/dbox/lcd0"
+#else
+#include <tdpanel/lcdstuff.h>
+#include <tddevices.h>
+#define LCD_LINES	64
+#define LCD_ROWS	(LCD_LINES / 8) // compatibility with stupid DBOX LCD driver
+#define LCD_COLS	128
+#define LCD_STRIDE	(LCD_COLS / 8)
+#define LCD_BUFFER_SIZE	(LCD_LINES * LCD_STRIDE)
+#define LCD_PIXEL_OFF	0
+#define LCD_PIXEL_ON	1
+#define LCD_PIXEL_INV	2
+#define LCD_DEVICE	"/dev/" DEVICE_NAME_LCD
+#define LCD_MODE_ASC	0
+#define LCD_MODE_BIN	2
+// ioctls
+#define LCD_IOCTL_ASC_MODE	IOC_LCD_WRMODE
+#define LCD_IOCTL_CLEAR		IOC_LCD_CLEAR
+#endif
+#endif
 
 #include <string>
 
@@ -36,7 +67,11 @@ class CLCDDisplay
 {
  private:
 	raw_display_t raw;
+#ifdef HAVE_TRIPLEDRAGON
+	unsigned char lcd[LCD_BUFFER_SIZE];
+#else
 	unsigned char lcd[LCD_ROWS][LCD_COLS];
+#endif
 	int           fd, paused;
 	std::string   iconBasePath;
 	bool          available;