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


Origin commit data
------------------
Branch: ni/coolstream
Commit: 66dd0b0174
Author: Stefan Seyfried <seife@tuxbox-git.slipkontur.de>
Date: 2010-12-25 (Sat, 25 Dec 2010)



------------------
This commit was generated by Migit

configure.ac

@@ -90,6 +90,7 @@ lib/libtriple/Makefile
 lib/libtuxtxt/Makefile
 lib/libdvbsub/Makefile
 lib/libupnpclient/Makefile
+src/lcddisplay/Makefile
 src/nhttpd/Makefile
 src/nhttpd/web/Makefile
 src/nhttpd/web/images/Makefile

src/Makefile.am

@@ -20,6 +20,7 @@ if BOXTYPE_COOL
 INCLUDES += -I$(top_srcdir)/lib/libcoolstream
 endif
 if BOXTYPE_TRIPLE
+SUBDIRS += lcddisplay
 INCLUDES += -I$(top_srcdir)/lib/libtriple
 endif
 
@@ -82,6 +83,7 @@ endif
 if BOXTYPE_TRIPLE
 neutrino_LDADD += \
 	$(top_builddir)/lib/libtriple/libtriple.a \
-	@DIRECTFB_LIBS@
+	@DIRECTFB_LIBS@ \
+	$(top_builddir)/src/lcddisplay/liblcddisplay.a
 endif
 

src/driver/Makefile.am

@@ -37,10 +37,16 @@ libneutrino_driver_a_SOURCES = \
 if BOXTYPE_COOL
 libneutrino_driver_a_SOURCES += \
 	vfd.cpp
+
 INCLUDES += \
 	-I$(top_srcdir)/lib/libcoolstream
 endif
 if BOXTYPE_TRIPLE
+libneutrino_driver_a_SOURCES += \
+	newclock.cpp \
+	lcdfontrenderer.cpp \
+	lcdd.cpp
+
 INCLUDES += \
 	-I$(top_srcdir)/lib/libtriple
 endif

src/driver/audiodec/vis.cpp

@@ -19,8 +19,12 @@
 
 #include <global.h>
 #include <neutrino.h>
+#if HAVE_COOL_HARDWARE
 #include <driver/vfd.h>
-
+#endif
+#if HAVE_TRIPLEDRAGON
+#include <driver/lcdd.h>
+#endif
 #include "int_fft.c"
 typedef signed short gint16;
 typedef int gint;

src/driver/lcdd.h

@@ -0,0 +1,256 @@
+/*
+	$Id$
+
+	LCD-Daemon  -   DBoxII-Project
+
+	Copyright (C) 2001 Steffen Hehn 'McClean'
+	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 __lcdd__
+#define __lcdd__
+
+#ifndef LCD_UPDATE
+#define LCD_UPDATE 1
+#endif
+
+#define LCDDIR_VAR "/var/share/tuxbox/neutrino/lcdd"
+
+typedef enum
+{
+	VFD_ICON_BAR8       = 0x00000004,
+	VFD_ICON_BAR7       = 0x00000008,
+	VFD_ICON_BAR6       = 0x00000010,
+	VFD_ICON_BAR5       = 0x00000020,
+	VFD_ICON_BAR4       = 0x00000040,
+	VFD_ICON_BAR3       = 0x00000080,
+	VFD_ICON_BAR2       = 0x00000100,
+	VFD_ICON_BAR1       = 0x00000200,
+	VFD_ICON_FRAME      = 0x00000400,
+	VFD_ICON_HDD        = 0x00000800,
+	VFD_ICON_MUTE       = 0x00001000,
+	VFD_ICON_DOLBY      = 0x00002000,
+	VFD_ICON_POWER      = 0x00004000,
+	VFD_ICON_TIMESHIFT  = 0x00008000,
+	VFD_ICON_SIGNAL     = 0x00010000,
+	VFD_ICON_TV         = 0x00020000,
+	VFD_ICON_RADIO      = 0x00040000,
+	VFD_ICON_HD         = 0x01000001,
+	VFD_ICON_1080P      = 0x02000001,
+	VFD_ICON_1080I      = 0x03000001,
+	VFD_ICON_720P       = 0x04000001,
+	VFD_ICON_480P       = 0x05000001,
+	VFD_ICON_480I       = 0x06000001,
+	VFD_ICON_USB        = 0x07000001,
+	VFD_ICON_MP3        = 0x08000001,
+	VFD_ICON_PLAY       = 0x09000001,
+	VFD_ICON_COL1       = 0x09000002,
+	VFD_ICON_PAUSE      = 0x0A000001,
+	VFD_ICON_CAM1       = 0x0B000001,
+	VFD_ICON_COL2       = 0x0B000002,
+	VFD_ICON_CAM2       = 0x0C000001
+} vfd_icon;
+
+#ifdef LCD_UPDATE
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+// TODO Why is USE_FILE_OFFSET64 not defined, if file.h is included here????
+#ifndef __USE_FILE_OFFSET64
+#define __USE_FILE_OFFSET64 1
+#endif
+#include "driver/file.h"
+#endif // LCD_UPDATE
+
+#include <configfile.h>
+#include <pthread.h>
+
+#include <lcddisplay/fontrenderer.h>
+
+
+class CLCDPainter;
+class LcdFontRenderClass;
+class CLCD
+{
+	public:
+
+		enum MODES
+		{
+			MODE_TVRADIO,
+			MODE_SCART,
+			MODE_SHUTDOWN,
+			MODE_STANDBY,
+			MODE_MENU_UTF8,
+			MODE_AUDIO,
+			MODE_MOVIE
+#ifdef LCD_UPDATE
+		,	MODE_FILEBROWSER,
+			MODE_PROGRESSBAR,
+			MODE_PROGRESSBAR2,
+			MODE_INFOBOX
+#endif // LCD_UPDATE
+		};
+		enum AUDIOMODES
+		{
+			AUDIO_MODE_PLAY,
+			AUDIO_MODE_STOP,
+			AUDIO_MODE_FF,
+			AUDIO_MODE_PAUSE,
+			AUDIO_MODE_REV
+		};
+
+
+	private:
+
+		class FontsDef
+		{
+			public:
+				LcdFont *channelname;
+				LcdFont *time; 
+				LcdFont *menutitle;
+				LcdFont *menu;
+		};
+
+		CLCDDisplay			display;
+		LcdFontRenderClass		*fontRenderer;
+		FontsDef			fonts;
+
+#define LCD_NUMBER_OF_BACKGROUNDS 5
+		raw_display_t                   background[LCD_NUMBER_OF_BACKGROUNDS];
+
+		MODES				mode;
+		AUDIOMODES			movie_playmode;
+
+		std::string			servicename;
+		std::string			epg_title;
+		std::string			movie_big;
+		std::string			movie_small;
+		std::string			menutitle;
+		char				volume;
+		unsigned char			percentOver;
+		bool				muted;
+		bool				showclock;
+		bool				movie_centered;
+		bool				movie_is_ac3;
+		CConfigFile			configfile;
+		pthread_t			thrTime;
+		int                             last_toggle_state_power;
+		int				clearClock;
+		unsigned int                    timeout_cnt;
+
+		void count_down();
+
+		CLCD();
+
+		static void* TimeThread(void*);
+		bool lcdInit(const char * fontfile1, const char * fontname1, 
+		             const char * fontfile2=NULL, const char * fontname2=NULL,
+		             const char * fontfile3=NULL, const char * fontname3=NULL);
+		void setlcdparameter(int dimm, int contrast, int power, int inverse, int bias);
+		void displayUpdate();
+		void showTextScreen(const std::string & big, const std::string & small, int showmode, bool perform_wakeup, bool centered = false);
+
+	public:
+		bool has_lcd;
+		void wake_up();
+		void setled(void) { return; };
+		void setlcdparameter(void);
+
+		static CLCD* getInstance();
+		void init(const char * fontfile, const char * fontname,
+		          const char * fontfile2=NULL, const char * fontname2=NULL,
+		          const char * fontfile3=NULL, const char * fontname3=NULL); 
+
+		void setMode(const MODES m, const char * const title = "");
+		MODES getMode() { return mode; };
+
+		void showServicename(const std::string name, const bool perform_wakeup = true); // UTF-8
+		void setEPGTitle(const std::string title);
+		void setMovieInfo(const AUDIOMODES playmode, const std::string big, const std::string small, const bool centered = false);
+		void setMovieAudio(const bool is_ac3);
+		std::string getMenutitle() { return menutitle; };
+		void showTime();
+		/** blocks for duration seconds */
+		void showRCLock(int duration = 2);
+		void showVolume(const char vol, const bool perform_update = true);
+		void showPercentOver(const unsigned char perc, const bool perform_update = true, const MODES m = MODE_TVRADIO);
+		void showMenuText(const int position, const char * text, const int highlight = -1, const bool utf_encoded = false);
+		void showAudioTrack(const std::string & artist, const std::string & title, const std::string & album);
+		void showAudioPlayMode(AUDIOMODES m=AUDIO_MODE_PLAY);
+		void showAudioProgress(const char perc, bool isMuted);
+		void setBrightness(int);
+		int getBrightness();
+
+		void setBrightnessStandby(int);
+		int getBrightnessStandby();
+
+		void setContrast(int);
+		int getContrast();
+
+		void setPower(int);
+		int getPower();
+
+		void togglePower(void);
+
+		void setInverse(int);
+		int getInverse();
+
+		void setAutoDimm(int);
+		int getAutoDimm();
+		void setBrightnessDeepStandby(int) { return ; };
+		int getBrightnessDeepStandby() { return 0; };
+
+		void setMuted(bool);
+
+		void resume();
+		void pause();
+
+		void Lock();
+		void Unlock();
+		void Clear();
+		void ShowIcon(vfd_icon icon, bool show);
+		void ShowText(const char *s) { showServicename(std::string(s)); };
+#ifdef LCD_UPDATE
+	private:
+		CFileList* m_fileList;
+		int m_fileListPos;
+		std::string m_fileListHeader;
+
+		std::string m_infoBoxText;
+		std::string m_infoBoxTitle;
+		int m_infoBoxTimer;   // for later use
+		bool m_infoBoxAutoNewline;
+		
+		bool m_progressShowEscape;
+		std::string  m_progressHeaderGlobal;
+		std::string  m_progressHeaderLocal;
+		int m_progressGlobal;
+		int m_progressLocal;
+	public:
+		void showFilelist(int flist_pos = -1,CFileList* flist = NULL,const char * const mainDir=NULL);
+		void showInfoBox(const char * const title = NULL,const char * const text = NULL,int autoNewline = -1,int timer = -1);
+		void showProgressBar(int global = -1,const char * const text = NULL,int show_escape = -1,int timer = -1);
+		void showProgressBar2(int local = -1,const char * const text_local = NULL,int global = -1,const char * const text_global = NULL,int show_escape = -1);
+#endif // LCD_UPDATE
+};
+
+
+#endif

src/driver/lcdfontrenderer.cpp

@@ -0,0 +1,302 @@
+/*
+        $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 <lcddisplay/fontrenderer.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <driver/encoding.h>
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+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;
+	}
+	return 0;
+}
+
+FT_Error LcdFontRenderClass::getGlyphBitmap(FTC_ImageType font, FT_ULong glyph_index, FTC_SBit *sbit)
+{
+	return FTC_SBitCache_Lookup(sbitsCache, font, glyph_index, sbit, NULL);
+}
+
+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;
+	font.face_id=faceid;
+	font.width  = isize;
+	font.height = isize;
+	font.flags  = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_MONOCHROME;
+}
+
+FT_Error LcdFont::getGlyphBitmap(FT_ULong glyph_index, FTC_SBit *sbit)
+{
+	return renderer->getGlyphBitmap(&font, glyph_index, sbit);
+}
+
+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;
+
+	FTC_ScalerRec scaler;
+
+	scaler.face_id = font.face_id;
+	scaler.width   = font.width;
+	scaler.height  = font.height;
+	scaler.pixel   = true;
+
+	pthread_mutex_lock(&renderer->render_mutex);
+
+	if ((err=FTC_Manager_LookupSize(renderer->cacheManager, &scaler, &size))!=0)
+	{ 
+		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;
+
+		int index = FT_Get_Char_Index(size->face, unicode_value);
+
+		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)
+{
+	FTC_ScalerRec scaler;
+
+	scaler.face_id = font.face_id;
+	scaler.width   = font.width;
+	scaler.height  = font.height;
+	scaler.pixel   = true;
+
+	pthread_mutex_lock(&renderer->render_mutex);
+
+	if (FTC_Manager_LookupSize(renderer->cacheManager, &scaler, &size)<0)
+	{ 
+		printf("FTC_Manager_Lookup_Size failed!\n");
+		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;
+
+		int index=FT_Get_Char_Index(size->face, unicode_value);
+
+		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/driver/newclock.cpp

@@ -0,0 +1,222 @@
+/*      
+        LCD-Daemon  -   DBoxII-Project
+
+        Copyright (C) 2001 Steffen Hehn 'McClean',
+                      2003 thegoodguy	
+
+        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 <driver/newclock.h>
+
+static bool	time_digits[24*32 * 10];
+static bool	days[24*16 * 7];
+static bool	date_digits[16*16 * 10];
+static bool	months[32*16 * 12];
+
+static bool	signs[] = {1, 1, 1, 1,
+			   1, 1, 1, 1,
+			   1, 1, 1, 1,
+			   1, 1, 1, 1,
+			   
+			   1, 1, 1, 0,
+			   1, 1, 1, 0,
+			   0, 1, 1, 0,
+			   1, 1, 0, 0,
+			   
+			   1, 1, 1, 0,
+			   1, 1, 1, 0,
+			   1, 1, 1, 0,
+			   0, 0, 0, 0};
+
+void loadSkin(char * const filename, char * const backup_filename, const unsigned int modify_char_filename, const unsigned int modify_char_backup_filename, bool * const dest, const unsigned int count, const unsigned int width, const unsigned int height, const char * const name)
+{
+	FILE * fd;
+	int row, bit;
+	char * file;
+	unsigned int i ,byte, digit_pos;
+	unsigned char BMPWidth;
+	unsigned char BMPHeight;
+	char line_buffer[4];
+
+	file = filename;
+	digit_pos = modify_char_filename;
+
+	for (i = 0; i < count; i++)
+	{
+	retry:
+		if ((fd = fopen(file, "rb")) == 0)
+		{
+			printf("[lcdd] %s-skin not found -> using default...\n", name);
+			file = backup_filename;
+			digit_pos = modify_char_backup_filename;
+			i = 0;
+			goto retry;
+		}
+
+		fseek(fd, 0x12, SEEK_SET);
+		fread(&BMPWidth, 1, 1, fd);
+		fseek(fd, 0x16, SEEK_SET);
+		fread(&BMPHeight, 1, 1, fd);
+
+		if ((BMPWidth > width) || (BMPHeight > height))
+		{
+			printf("[lcdd] %s-skin not supported -> using default...\n", name);
+			fclose(fd);
+			file = backup_filename;
+			digit_pos = modify_char_backup_filename;
+			i = 0;
+			goto retry;
+		}
+
+		fseek(fd, 0x3E, SEEK_SET);
+
+		for (row = height - 1; row >= 0; row--)
+		{
+			fread(&line_buffer, 1, sizeof(line_buffer), fd); /* width must not be greater than 32 */
+
+			for (byte = 0; byte < (width >> 3); byte++) /* width must be multiple of 8 */
+			{
+				for (bit = 7; bit >= 0; bit--)
+				{
+					dest[(7 - bit) + (byte << 3) + (row + i * height) * width] = line_buffer[byte] & (1 << bit);
+				}
+			}
+		}
+
+		fclose(fd);
+
+		file[digit_pos]++;
+	}
+}
+
+void InitNewClock(void)
+{
+	char filename_usr[] = CONFIGDIR "/lcdd/clock/t_a.bmp";
+	char filename_std[] = DATADIR   "/lcdd/clock/t_a.bmp";
+
+	loadSkin(filename_usr, filename_std, sizeof(filename_usr) - 6, sizeof(filename_std) - 6, time_digits, 10, 24, 32, "time");
+
+	filename_usr[sizeof(filename_usr) - 8] = 'w';
+	filename_std[sizeof(filename_std) - 8] = 'w';
+	filename_usr[sizeof(filename_usr) - 6] = 'a';
+	filename_std[sizeof(filename_std) - 6] = 'a';
+	loadSkin(filename_usr, filename_std, sizeof(filename_usr) - 6, sizeof(filename_std) - 6, days, 7, 24, 16, "weekday");
+
+	filename_usr[sizeof(filename_usr) - 8] = 'd';
+	filename_std[sizeof(filename_std) - 8] = 'd';
+	filename_usr[sizeof(filename_usr) - 6] = 'a';
+	filename_std[sizeof(filename_std) - 6] = 'a';
+	loadSkin(filename_usr, filename_std, sizeof(filename_usr) - 6, sizeof(filename_std) - 6, date_digits, 10, 16, 16, "date");
+
+	filename_usr[sizeof(filename_usr) - 8] = 'm';
+	filename_std[sizeof(filename_std) - 8] = 'm';
+	filename_usr[sizeof(filename_usr) - 6] = 'a';
+	filename_std[sizeof(filename_std) - 6] = 'a';
+	loadSkin(filename_usr, filename_std, sizeof(filename_usr) - 6, sizeof(filename_std) - 6, months, 12, 32, 16, "month");
+}
+
+void RenderSign(CLCDDisplay* const display, int sign, int x_position, int y_position)
+{
+	int x, y;
+
+	for(y = 0; y < 4; y++)
+	{
+		for(x = 0; x < 4; x++)
+		{
+			display->draw_point(x_position + x, y_position + y, signs[x + y*4 + sign*sizeof(signs)/3] ? CLCDDisplay::PIXEL_ON : CLCDDisplay::PIXEL_OFF);
+		}
+	}
+}
+
+void RenderTimeDigit(CLCDDisplay* const display, int digit, int position)
+{
+	int x, y;
+
+	for(y = 0; y < 32; y++)
+	{
+		for(x = 0; x < 24; x++)
+		{
+			display->draw_point(position + x, 5 + y, time_digits[x + y*24 + digit*sizeof(time_digits)/10] ? CLCDDisplay::PIXEL_ON : CLCDDisplay::PIXEL_OFF);
+		}
+	}
+}
+
+void RenderDay(CLCDDisplay* const display, int day)
+{
+	int x, y;
+
+	for(y = 0; y < 16; y++)
+	{
+		for(x = 0; x < 24; x++)
+		{
+			display->draw_point(5 + x, 43 + y, days[x + y*24 + day*sizeof(days)/7] ? CLCDDisplay::PIXEL_ON : CLCDDisplay::PIXEL_OFF);
+		}
+	}
+}
+
+void RenderDateDigit(CLCDDisplay* const display, int digit, int position)
+{
+	int x, y;
+
+	for(y = 0; y < 16; y++)
+	{
+		for(x = 0; x < 16; x++)
+		{
+			display->draw_point(position + x, 43 + y, date_digits[x + y*16 + digit*sizeof(date_digits)/10] ? CLCDDisplay::PIXEL_ON : CLCDDisplay::PIXEL_OFF);
+		}
+	}
+}
+
+void RenderMonth(CLCDDisplay* const display, int month)
+{
+	int x, y;
+
+	for(y = 0; y < 16; y++)
+	{
+		for(x = 0; x < 32; x++)
+		{
+			display->draw_point(83 + x, 43 + y, months[x + y*32 + month*sizeof(months)/12] ? CLCDDisplay::PIXEL_ON : CLCDDisplay::PIXEL_OFF);
+		}
+	}
+}
+
+void ShowNewClock(CLCDDisplay* display, int hour, int minute, int second, int day, int date, int month)
+{
+	RenderTimeDigit(display, hour/10, 5);
+	RenderTimeDigit(display, hour%10, 32);
+	RenderTimeDigit(display, minute/10, 64);
+	RenderTimeDigit(display, minute%10, 91);
+
+	RenderDay(display, day);
+
+	RenderDateDigit(display, date/10, 43);
+	RenderDateDigit(display, date%10, 60);
+
+	RenderMonth(display, month);
+	
+	RenderSign(display, 1, 31, 57);
+	RenderSign(display, 2, 78, 56);
+
+	if (second % 2 == 0)
+	{
+	RenderSign(display, 0, 58, 15);
+	RenderSign(display, 0, 58, 23);
+	}
+}

src/driver/newclock.h

@@ -0,0 +1,30 @@
+/*      
+        LCD-Daemon  -   DBoxII-Project
+
+        Copyright (C) 2001 Steffen Hehn 'McClean'
+        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 <lcddisplay/lcddisplay.h>
+
+void InitNewClock();
+void ShowNewClock(CLCDDisplay* display, int hour, int minute, int second, int day, int date, int month);

src/driver/stream2file.cpp

@@ -54,12 +54,13 @@
 #include <signal.h>
 #include <libgen.h>
 
-#include <driver/vfd.h>
 #if HAVE_COOL_HARDWARE
 #include <record_cs.h>
+#include <driver/vfd.h>
 #endif
 #if HAVE_TRIPLEDRAGON
 #include <record_td.h>
+#include <driver/lcdd.h>
 #endif
 #include <zapit/cam.h>
 #include <zapit/channel.h>

src/global.h

@@ -40,8 +40,14 @@
 
 #include "driver/fontrenderer.h"
 #include "driver/rcinput.h"
+#if HAVE_COOL_HARDWARE
 #include "driver/vfd.h"
 #include "driver/rfmod.h"
+#endif
+#if HAVE_TRIPLEDRAGON
+#include "driver/lcdd.h"
+#define CVFD CLCD
+#endif
 
 #include "system/localize.h"
 #include "system/settings.h"
@@ -85,8 +91,10 @@ NEUTRINO_CPP  CEpgData		*g_EpgData;
 NEUTRINO_CPP  CInfoViewer	*g_InfoViewer;
 NEUTRINO_CPP  EventList		*g_EventList;
 
-NEUTRINO_CPP CLocaleManager	*g_Locale;
+NEUTRINO_CPP CLocaleManager		*g_Locale;
+#if HAVE_COOL_HARDWARE
 NEUTRINO_CPP RFmod		*g_RFmod;
+#endif
 
 NEUTRINO_CPP CVideoSettings	*g_videoSettings;
 

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;

src/neutrino.cpp

@@ -68,7 +68,10 @@
 #include <driver/stream2file.h>
 #include <driver/vcrcontrol.h>
 #include <driver/shutdown_count.h>
-
+#if HAVE_TRIPLEDRAGON
+#include <driver/lcdd.h>
+#include "gui/widget/lcdcontroler.h"
+#endif
 #include <gui/epgplus.h>
 #include <gui/streaminfo2.h>
 
@@ -77,8 +80,10 @@
 #include "gui/widget/messagebox.h"
 #include "gui/widget/hintbox.h"
 #include "gui/widget/icons.h"
+#if HAVE_COOL_HARDWARE
 #include "gui/widget/vfdcontroler.h"
 #include "gui/widget/progressbar.h"
+#endif
 #include "gui/widget/keychooser.h"
 #include "gui/widget/stringinput.h"
 #include "gui/widget/stringinput_ext.h"
@@ -349,7 +354,7 @@ typedef struct lcd_setting_t
 	const unsigned int default_value;
 } lcd_setting_struct_t;
 
-const lcd_setting_struct_t lcd_setting[LCD_SETTING_COUNT] =
+const lcd_setting_struct_t lcd_setting[SNeutrinoSettings::LCD_SETTING_COUNT] =
 {
 	{"lcd_brightness"       , DEFAULT_VFD_BRIGHTNESS       },
 	{"lcd_standbybrightness", DEFAULT_VFD_STANDBYBRIGHTNESS},
@@ -359,6 +364,9 @@ const lcd_setting_struct_t lcd_setting[LCD_SETTING_COUNT] =
 	{"lcd_show_volume"      , DEFAULT_LCD_SHOW_VOLUME      },
 	{"lcd_autodimm"         , DEFAULT_LCD_AUTODIMM         },
 	{"lcd_deepbrightness"   , DEFAULT_VFD_STANDBYBRIGHTNESS }
+#if HAVE_TRIPLEDRAGON
+	,{ "lcd_epgmode"        , 0 /*DEFAULT_LCD_EPGMODE*/ }
+#endif
 };
 
 /**************************************************************************************
@@ -771,7 +779,7 @@ printf("***************************** rec dir %s timeshift dir %s\n", g_settings
 	for (int i = 0; i < TIMING_SETTING_COUNT; i++)
 		g_settings.timing[i] = configfile.getInt32(locale_real_names[timing_setting_name[i]], default_timing[i]);
 
-	for (int i = 0; i < LCD_SETTING_COUNT; i++)
+	for (int i = 0; i < SNeutrinoSettings::LCD_SETTING_COUNT; i++)
 		g_settings.lcd_setting[i] = configfile.getInt32(lcd_setting[i].name, lcd_setting[i].default_value);
 	strcpy(g_settings.lcd_setting_dim_time, configfile.getString("lcd_dim_time","0").c_str());
 	strcpy(g_settings.lcd_setting_dim_brightness, configfile.getString("lcd_dim_brightness","0").c_str());
@@ -1283,7 +1291,7 @@ void CNeutrinoApp::saveSetup(const char * fname)
 	for (int i = 0; i < TIMING_SETTING_COUNT; i++)
 		configfile.setInt32(locale_real_names[timing_setting_name[i]], g_settings.timing[i]);
 
-	for (int i = 0; i < LCD_SETTING_COUNT; i++)
+	for (int i = 0; i < SNeutrinoSettings::LCD_SETTING_COUNT; i++)
 		configfile.setInt32(lcd_setting[i].name, g_settings.lcd_setting[i]);
 	configfile.setString("lcd_dim_time", g_settings.lcd_setting_dim_time);
 	configfile.setString("lcd_dim_brightness", g_settings.lcd_setting_dim_brightness);
@@ -4572,7 +4580,7 @@ void CNeutrinoApp::loadColors(const char * fname)
 	g_settings.infobar_Text_red = tconfig.getInt32( "infobar_Text_red", 0x64 );
 	g_settings.infobar_Text_green = tconfig.getInt32( "infobar_Text_green", 0x64 );
 	g_settings.infobar_Text_blue = tconfig.getInt32( "infobar_Text_blue", 0x64 );
-	for (int i = 0; i < LCD_SETTING_COUNT; i++)
+	for (int i = 0; i < SNeutrinoSettings::LCD_SETTING_COUNT; i++)
 		g_settings.lcd_setting[i] = tconfig.getInt32(lcd_setting[i].name, lcd_setting[i].default_value);
 	strcpy(g_settings.lcd_setting_dim_time, tconfig.getString("lcd_dim_time","0").c_str());
 	strcpy(g_settings.lcd_setting_dim_brightness, tconfig.getString("lcd_dim_brightness","0").c_str());
@@ -4638,7 +4646,7 @@ void CNeutrinoApp::saveColors(const char * fname)
 	tconfig.setInt32( "infobar_Text_red", g_settings.infobar_Text_red );
 	tconfig.setInt32( "infobar_Text_green", g_settings.infobar_Text_green );
 	tconfig.setInt32( "infobar_Text_blue", g_settings.infobar_Text_blue );
-	for (int i = 0; i < LCD_SETTING_COUNT; i++)
+	for (int i = 0; i < SNeutrinoSettings::LCD_SETTING_COUNT; i++)
 		tconfig.setInt32(lcd_setting[i].name, g_settings.lcd_setting[i]);
 	tconfig.setString("lcd_dim_time", g_settings.lcd_setting_dim_time);
 	tconfig.setString("lcd_dim_brightness", g_settings.lcd_setting_dim_brightness);

src/system/settings.h

@@ -384,16 +384,19 @@ struct SNeutrinoSettings
 	};
 
 	// lcdd
-#define LCD_SETTING_COUNT 8
 	enum LCD_SETTINGS {
 		LCD_BRIGHTNESS         = 0,
-		LCD_STANDBY_BRIGHTNESS = 1,
+		LCD_STANDBY_BRIGHTNESS ,
-		LCD_CONTRAST           = 2,
+		LCD_CONTRAST           ,
-		LCD_POWER              = 3,
+		LCD_POWER              ,
-		LCD_INVERSE            = 4,
+		LCD_INVERSE            ,
-		LCD_SHOW_VOLUME        = 5,
+		LCD_SHOW_VOLUME        ,
-		LCD_AUTODIMM           = 6,
+		LCD_AUTODIMM           ,
-		LCD_DEEPSTANDBY_BRIGHTNESS  = 7
+		LCD_DEEPSTANDBY_BRIGHTNESS,
+#if HAVE_TRIPLEDRAGON
+		LCD_EPGMODE            ,
+#endif
+		LCD_SETTING_COUNT
 	};
 	int lcd_setting[LCD_SETTING_COUNT];