mirrors/recycled-ni-neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-fork-migrations/recycled-ni-neutrino.git synced 2025-08-30 08:51:04 +02:00
Code Issues Packages Projects Releases Wiki Activity

add lcd display code for Tripledragon, mostly from tuxbox

Browse Source 
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
This commit is contained in:
Stefan Seyfried
2010-12-25 17:43:43 +00:00
parent be428c8cb3
commit 0d0f7c215c
18 changed files with 3297 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
configure.ac
View File

@@ -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

4
src/Makefile.am
View File

@@ -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

6
src/driver/Makefile.am
View File

@@ -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

6
src/driver/audiodec/vis.cpp
View File

@@ -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;

1391
src/driver/lcdd.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

256
src/driver/lcdd.h Normal file
View File

@@ -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

302
src/driver/lcdfontrenderer.cpp Normal file
View File

@@ -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;
}

222
src/driver/newclock.cpp Normal file
View File

@@ -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);
}
}

30
src/driver/newclock.h Normal file
View File

@@ -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);

3
src/driver/stream2file.cpp
View File

@@ -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>

10
src/global.h
View File

@@ -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;

7
src/lcddisplay/Makefile.am Normal file
View File

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

387
src/lcddisplay/fontrenderer.cpp Normal file
View File

@@ -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;
}

115
src/lcddisplay/fontrenderer.h Normal file
View File

@@ -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__ */

501
src/lcddisplay/lcddisplay.cpp Normal file
View File

@@ -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;
}

35
src/lcddisplay/lcddisplay.h
View File

@@ -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;

20
src/neutrino.cpp
View File

@@ -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);

19
src/system/settings.h
View File

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