mirrors/neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-neutrino/neutrino.git synced 2025-09-02 18:31:22 +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
This commit is contained in:
seife
2010-12-25 17:43:43 +00:00
parent 2e037a6b73
commit 66dd0b0174
18 changed files with 3297 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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>