Aksal/nuttx
3
1
Fork 1
mirror of https://github.com/apache/nuttx.git synced 2026-08-01 20:28:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Graphics: Initial separation of font cache from graphics/nxterm. Now in libnx/nxfronts

Browse source
This commit is contained in:
Gregory Nutt 2017-01-05 18:36:29 -06:00
parent d91cf5736e
commit dc05af6436
8 changed files with 796 additions and 389 deletions
Download patch file Download diff file Expand all files Collapse all files

38
graphics/nxterm/nxterm.h
View file

@ -1,7 +1,7 @@
/****************************************************************************
* nuttx/graphics/nxterm/nxterm.h
*
* Copyright (C) 2012, 2014 Gregory Nutt. All rights reserved.
* Copyright (C) 2012, 2014, 2017 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -33,8 +33,8 @@
*
****************************************************************************/
#ifndef __GRAPHICS_NXTERM_NXTERM_INTERNAL_H
#define __GRAPHICS_NXTERM_NXTERM_INTERNAL_H
#ifndef __GRAPHICS_NXTERM_NXTERM_H
#define __GRAPHICS_NXTERM_NXTERM_H
/****************************************************************************
* Included Files
@ -61,10 +61,6 @@
#define BMFLAGS_NOGLYPH (1 << 0) /* No glyph available, use space */
#define BM_ISSPACE(bm) (((bm)->flags & BMFLAGS_NOGLYPH) != 0)
/* Sizes and maximums */
#define MAX_USECNT 255 /* Limit to range of a uint8_t */
/* Device path formats */
#define NX_DEVNAME_FORMAT "/dev/nxterm%d"
@ -81,6 +77,7 @@
/****************************************************************************
* Public Types
****************************************************************************/
/* Identifies the state of the VT100 escape sequence processing */
enum nxterm_vt100state_e
@ -111,18 +108,6 @@ struct nxterm_operations_s
unsigned int stride);
};
/* Describes one cached glyph bitmap */
struct nxterm_glyph_s
{
uint8_t code; /* Character code */
uint8_t height; /* Height of this glyph (in rows) */
uint8_t width; /* Width of this glyph (in pixels) */
uint8_t stride; /* Width of the glyph row (in bytes) */
uint8_t usecnt; /* Use count */
FAR uint8_t *bitmap; /* Allocated bitmap memory */
};
/* Describes on character on the display */
struct nxterm_bitmap_s
@ -138,8 +123,7 @@ struct nxterm_state_s
{
FAR const struct nxterm_operations_s *ops; /* Window operations */
FAR void *handle; /* The window handle */
FAR struct nxterm_window_s wndo; /* Describes the window and font */
NXHANDLE font; /* The current font handle */
FAR struct nxterm_window_s wndo; /* Describes the window and font */
sem_t exclsem; /* Forces mutually exclusive access */
#ifdef CONFIG_DEBUG_FEATURES
pid_t holder; /* Deadlock avoidance */
@ -151,7 +135,6 @@ struct nxterm_state_s
uint8_t fheight; /* Max height of a font in pixels */
uint8_t fwidth; /* Max width of a font in pixels */
uint8_t spwidth; /* The width of a space */
uint8_t maxglyphs; /* Size of the glyph[] array */
uint16_t maxchars; /* Size of the bm[] array */
uint16_t nchars; /* Number of chars in the bm[] array */
@ -165,13 +148,10 @@ struct nxterm_state_s
/* Font cache data storage */
FCACHE fcache; /* Font cache handle */
struct nxterm_bitmap_s cursor;
struct nxterm_bitmap_s bm[CONFIG_NXTERM_MXCHARS];
/* Glyph cache data storage */
struct nxterm_glyph_s glyph[CONFIG_NXTERM_CACHESIZE];
/* Keyboard input support */
#ifdef CONFIG_NXTERM_NXKBDIN
@ -235,8 +215,8 @@ enum nxterm_vt100state_e nxterm_vt100(FAR struct nxterm_state_s *priv, char ch);
void nxterm_home(FAR struct nxterm_state_s *priv);
void nxterm_newline(FAR struct nxterm_state_s *priv);
FAR const struct nxterm_bitmap_s *nxterm_addchar(NXHANDLE hfont,
FAR struct nxterm_state_s *priv, uint8_t ch);
FAR const struct nxterm_bitmap_s *nxterm_addchar(FAR struct nxterm_state_s *priv,
uint8_t ch);
int nxterm_hidechar(FAR struct nxterm_state_s *priv,
FAR const struct nxterm_bitmap_s *bm);
int nxterm_backspace(FAR struct nxterm_state_s *priv);
@ -251,4 +231,4 @@ void nxterm_hidecursor(FAR struct nxterm_state_s *priv);
void nxterm_scroll(FAR struct nxterm_state_s *priv, int scrollheight);
#endif /* __GRAPHICS_NXTERM_NXTERM_INTERNAL_H */
#endif /* __GRAPHICS_NXTERM_NXTERM_H */

341
graphics/nxterm/nxterm_font.c
View file

@ -48,294 +48,26 @@
#include "nxterm.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Select renderer -- Some additional logic would be required to support
* pixel depths that are not directly addressable (1,2,4, and 24).
*/
#if CONFIG_NXTERM_BPP == 1
# define RENDERER nxf_convert_1bpp
#elif CONFIG_NXTERM_BPP == 2
# define RENDERER nxf_convert_2bpp
#elif CONFIG_NXTERM_BPP == 4
# define RENDERER nxf_convert_4bpp
#elif CONFIG_NXTERM_BPP == 8
# define RENDERER nxf_convert_8bpp
#elif CONFIG_NXTERM_BPP == 16
# define RENDERER nxf_convert_16bpp
#elif CONFIG_NXTERM_BPP == 24
# define RENDERER nxf_convert_24bpp
#elif CONFIG_NXTERM_BPP == 32
# define RENDERER nxf_convert_32bpp
#else
# error "Unsupported CONFIG_NXTERM_BPP"
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nxterm_freeglyph
****************************************************************************/
static void nxterm_freeglyph(FAR struct nxterm_glyph_s *glyph)
{
if (glyph->bitmap)
{
kmm_free(glyph->bitmap);
}
memset(glyph, 0, sizeof(struct nxterm_glyph_s));
}
/****************************************************************************
* Name: nxterm_allocglyph
****************************************************************************/
static inline FAR struct nxterm_glyph_s *
nxterm_allocglyph(FAR struct nxterm_state_s *priv)
{
FAR struct nxterm_glyph_s *glyph = NULL;
FAR struct nxterm_glyph_s *luglyph = NULL;
uint8_t luusecnt;
int i;
/* Search through the glyph cache looking for an unused glyph. Also, keep
* track of the least used glyph as well. We need that if we have to replace
* a glyph in the cache.
*/
for (i = 0; i < priv->maxglyphs; i++)
{
/* Is this glyph in use? */
glyph = &priv->glyph[i];
if (!glyph->usecnt)
{
/* No.. return this glyph with a use count of one */
glyph->usecnt = 1;
return glyph;
}
/* Yes.. check for the least recently used */
if (!luglyph || glyph->usecnt < luglyph->usecnt)
{
luglyph = glyph;
}
}
/* If we get here, the glyph cache is full. We replace the least used
* glyph with the one we need now. (luglyph can't be NULL).
*/
luusecnt = luglyph->usecnt;
nxterm_freeglyph(luglyph);
/* But lets decrement all of the usecnts so that the new one one be so
* far behind in the counts as the older ones.
*/
if (luusecnt > 1)
{
uint8_t decr = luusecnt - 1;
for (i = 0; i < priv->maxglyphs; i++)
{
/* Is this glyph in use? */
glyph = &priv->glyph[i];
if (glyph->usecnt > decr)
{
glyph->usecnt -= decr;
}
}
}
/* Then return the least used glyph */
luglyph->usecnt = 1;
return luglyph;
}
/****************************************************************************
* Name: nxterm_findglyph
****************************************************************************/
static FAR struct nxterm_glyph_s *
nxterm_findglyph(FAR struct nxterm_state_s *priv, uint8_t ch)
{
int i;
/* First, try to find the glyph in the cache of pre-rendered glyphs */
for (i = 0; i < priv->maxglyphs; i++)
{
FAR struct nxterm_glyph_s *glyph = &priv->glyph[i];
if (glyph->usecnt > 0 && glyph->code == ch)
{
/* Increment the use count (unless it is already at the max) */
if (glyph->usecnt < MAX_USECNT)
{
glyph->usecnt++;
}
/* And return the glyph that we found */
return glyph;
}
}
return NULL;
}
/****************************************************************************
* Name: nxterm_renderglyph
****************************************************************************/
static inline FAR struct nxterm_glyph_s *
nxterm_renderglyph(FAR struct nxterm_state_s *priv,
FAR const struct nx_fontbitmap_s *fbm, uint8_t ch)
{
FAR struct nxterm_glyph_s *glyph = NULL;
FAR nxgl_mxpixel_t *ptr;
#if CONFIG_NXTERM_BPP < 8
nxgl_mxpixel_t pixel;
#endif
int bmsize;
int row;
int col;
int ret;
/* Allocate the glyph (always succeeds) */
glyph = nxterm_allocglyph(priv);
glyph->code = ch;
/* Get the dimensions of the glyph */
glyph->width = fbm->metric.width + fbm->metric.xoffset;
glyph->height = fbm->metric.height + fbm->metric.yoffset;
/* Get the physical width of the glyph in bytes */
glyph->stride = (glyph->width * CONFIG_NXTERM_BPP + 7) / 8;
/* Allocate memory to hold the glyph with its offsets */
bmsize = glyph->stride * glyph->height;
glyph->bitmap = (FAR uint8_t *)kmm_malloc(bmsize);
if (glyph->bitmap)
{
/* Initialize the glyph memory to the background color using the
* hard-coded bits-per-pixel (BPP).
*
* TODO: The rest of NX is configured to support multiple devices
* with differing BPP. They logic should be extended to support
* differing BPP's as well.
*/
#if CONFIG_NXTERM_BPP < 8
pixel = priv->wndo.wcolor[0];
# if CONFIG_NXTERM_BPP == 1
/* Pack 1-bit pixels into a 2-bits */
pixel &= 0x01;
pixel = (pixel) << 1 | pixel;
# endif
# if CONFIG_NXTERM_BPP < 4
/* Pack 2-bit pixels into a nibble */
pixel &= 0x03;
pixel = (pixel) << 2 | pixel;
# endif
/* Pack 4-bit nibbles into a byte */
pixel &= 0x0f;
pixel = (pixel) << 4 | pixel;
ptr = (FAR nxgl_mxpixel_t *)glyph->bitmap;
for (row = 0; row < glyph->height; row++)
{
for (col = 0; col < glyph->stride; col++)
{
/* Transfer the packed bytes into the buffer */
*ptr++ = pixel;
}
}
#elif CONFIG_NXTERM_BPP == 24
# error "Additional logic is needed here for 24bpp support"
#else /* CONFIG_NXTERM_BPP = {8,16,32} */
ptr = (FAR nxgl_mxpixel_t *)glyph->bitmap;
for (row = 0; row < glyph->height; row++)
{
/* Just copy the color value into the glyph memory */
for (col = 0; col < glyph->width; col++)
{
*ptr++ = priv->wndo.wcolor[0];
}
}
#endif
/* Then render the glyph into the allocated memory */
ret = RENDERER((FAR nxgl_mxpixel_t *)glyph->bitmap,
glyph->height, glyph->width, glyph->stride,
fbm, priv->wndo.fcolor[0]);
if (ret < 0)
{
/* Actually, the RENDERER never returns a failure */
gerr("ERROR: nxterm_renderglyph: RENDERER failed\n");
nxterm_freeglyph(glyph);
glyph = NULL;
}
}
return glyph;
}
/****************************************************************************
* Name: nxterm_fontsize
****************************************************************************/
static int nxterm_fontsize(NXHANDLE hfont, uint8_t ch, FAR struct nxgl_size_s *size)
static int nxterm_fontsize(FAR struct nxterm_state_s *priv, uint8_t ch,
FAR struct nxgl_size_s *size)
{
FAR const struct nx_fontbitmap_s *fbm;
NXHANDLE hfont;
/* No, it is not cached... Does the code map to a font? */
/* Get the handle of the font managed by the font cache */
hfont = nxf_cache_getfonthandle(priv->fcache);
DEBUGASSERT(hfront != NULL);
/* Does the character code map to a font? */
fbm = nxf_getbitmap(hfont, ch);
if (fbm)
@ -347,40 +79,7 @@ static int nxterm_fontsize(NXHANDLE hfont, uint8_t ch, FAR struct nxgl_size_s *s
return OK;
}
return ERROR;
}
/****************************************************************************
* Name: nxterm_getglyph
****************************************************************************/
static FAR struct nxterm_glyph_s *
nxterm_getglyph(NXHANDLE hfont, FAR struct nxterm_state_s *priv, uint8_t ch)
{
FAR struct nxterm_glyph_s *glyph;
FAR const struct nx_fontbitmap_s *fbm;
/* First, try to find the glyph in the cache of pre-rendered glyphs */
glyph = nxterm_findglyph(priv, ch);
if (glyph)
{
/* We found it in the cache .. return the cached glyph */
return glyph;
}
/* No, it is not cached... Does the code map to a font? */
fbm = nxf_getbitmap(hfont, ch);
if (fbm)
{
/* Yes.. render the glyph */
glyph = nxterm_renderglyph(priv, fbm, ch);
}
return glyph;
return -ENOENT;
}
/****************************************************************************
@ -397,10 +96,10 @@ nxterm_getglyph(NXHANDLE hfont, FAR struct nxterm_state_s *priv, uint8_t ch)
****************************************************************************/
FAR const struct nxterm_bitmap_s *
nxterm_addchar(NXHANDLE hfont, FAR struct nxterm_state_s *priv, uint8_t ch)
nxterm_addchar(FAR struct nxterm_state_s *priv, uint8_t ch)
{
FAR struct nxterm_bitmap_s *bm = NULL;
FAR struct nxterm_glyph_s *glyph;
FAR struct nxfonts_glyph_s *glyph;
/* Is there space for another character on the display? */
@ -416,7 +115,7 @@ nxterm_addchar(NXHANDLE hfont, FAR struct nxterm_state_s *priv, uint8_t ch)
/* Find (or create) the matching glyph */
glyph = nxterm_getglyph(hfont, priv, ch);
glyph = nxf_cache_getglyph(priv->fcache, ch);
if (!glyph)
{
/* No, there is no font for this code. Just mark this as a space. */
@ -449,6 +148,7 @@ nxterm_addchar(NXHANDLE hfont, FAR struct nxterm_state_s *priv, uint8_t ch)
* Erase a character from the window.
*
****************************************************************************/
int nxterm_hidechar(FAR struct nxterm_state_s *priv,
FAR const struct nxterm_bitmap_s *bm)
{
@ -461,7 +161,7 @@ int nxterm_hidechar(FAR struct nxterm_state_s *priv,
* modification is required (not an error).
*/
ret = nxterm_fontsize(priv->font, bm->code, &fsize);
ret = nxterm_fontsize(priv, bm->code, &fsize);
if (ret < 0)
{
/* It was rendered as a space. */
@ -572,10 +272,10 @@ void nxterm_newline(FAR struct nxterm_state_s *priv)
****************************************************************************/
void nxterm_fillchar(FAR struct nxterm_state_s *priv,
FAR const struct nxgl_rect_s *rect,
FAR const struct nxterm_bitmap_s *bm)
FAR const struct nxgl_rect_s *rect,
FAR const struct nxterm_bitmap_s *bm)
{
FAR struct nxterm_glyph_s *glyph;
FAR struct nxfonts_glyph_s *glyph;
struct nxgl_rect_s bounds;
struct nxgl_rect_s intersection;
struct nxgl_size_s fsize;
@ -590,7 +290,7 @@ void nxterm_fillchar(FAR struct nxterm_state_s *priv,
/* Get the size of the font glyph (which may not have been created yet) */
ret = nxterm_fontsize(priv->font, bm->code, &fsize);
ret = nxterm_fontsize(priv, bm->code, &fsize);
if (ret < 0)
{
/* This would mean that there is no bitmap for the character code and
@ -632,7 +332,7 @@ void nxterm_fillchar(FAR struct nxterm_state_s *priv,
/* Find (or create) the glyph that goes with this font */
glyph = nxterm_getglyph(priv->font, priv, bm->code);
glyph = nxf_cache_getglyph(priv->fcache, bm->code);
if (!glyph)
{
/* Shouldn't happen */
@ -648,4 +348,3 @@ void nxterm_fillchar(FAR struct nxterm_state_s *priv,
DEBUGASSERT(ret >= 0);
}
}

2
graphics/nxterm/nxterm_putc.c
View file

@ -142,7 +142,7 @@ void nxterm_putc(FAR struct nxterm_state_s *priv, uint8_t ch)
* display.
*/
bm = nxterm_addchar(priv->font, priv, ch);
bm = nxterm_addchar(priv, ch);
if (bm)
{
nxterm_fillchar(priv, NULL, bm);

31
graphics/nxterm/nxterm_register.c
View file

@ -1,7 +1,7 @@
/****************************************************************************
* nuttx/graphics/nxterm/nxterm_register.c
*
* Copyright (C) 2012, 2016 Gregory Nutt. All rights reserved.
* Copyright (C) 2012, 2016-2017 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -66,7 +66,9 @@ FAR struct nxterm_state_s *
FAR const struct nxterm_operations_s *ops, int minor)
{
FAR struct nxterm_state_s *priv;
FAR const struct nx_font_s *fontset;
char devname[NX_DEVNAME_SIZE];
NXHANDLE hfont;
int ret;
DEBUGASSERT(handle && wndo && ops && (unsigned)minor < 256);
@ -101,22 +103,32 @@ FAR struct nxterm_state_s *
sem_setprotocol(&priv->waitsem, SEM_PRIO_NONE);
#endif
/* Select the font */
/* Connect to the font cache for the configured font characteristics */
priv->font = nxf_getfonthandle(wndo->fontid);
if (!priv->font)
priv->fcache = nxf_cache_connect(wndo->fontid, wndo->fcolor[0],
wndo->wcolor[0], CONFIG_NXTERM_BPP);
if (priv->fcache == NULL)
{
gerr("ERROR: Failed to get font ID %d: %d\n", wndo->fontid, errno);
gerr("ERROR: Failed to connect to font cache for font ID %d: %d\n",
wndo->fontid, errno);
goto errout;
}
FAR const struct nx_font_s *fontset;
/* Get the handle of the font managed by the font cache */
hfont = nxf_cache_getfonthandle(priv->fcache);
if (hfont == NULL)
{
gerr("ERROR: Failed to get handlr for font ID %d: %d\n",
wndo->fontid, errno);
goto errout;
}
/* Get information about the font set being used and save this in the
* state structure
*/
fontset = nxf_getfontset(priv->font);
fontset = nxf_getfontset(hfont);
priv->fheight = fontset->mxheight;
priv->fwidth = fontset->mxwidth;
priv->spwidth = fontset->spwidth;
@ -125,10 +137,6 @@ FAR struct nxterm_state_s *
priv->maxchars = CONFIG_NXTERM_MXCHARS;
/* Set up the font glyph bitmap cache */
priv->maxglyphs = CONFIG_NXTERM_CACHESIZE;
/* Set the initial display position */
nxterm_home(priv);
@ -146,6 +154,7 @@ FAR struct nxterm_state_s *
{
gerr("ERROR: Failed to register %s\n", devname);
}
return (NXTERM)priv;
errout:

28
graphics/nxterm/nxterm_unregister.c
View file

@ -50,22 +50,6 @@
#include "nxterm.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
@ -89,7 +73,6 @@ void nxterm_unregister(NXTERM handle)
{
FAR struct nxterm_state_s *priv;
char devname[NX_DEVNAME_SIZE];
int i;
DEBUGASSERT(handle);
@ -101,16 +84,9 @@ void nxterm_unregister(NXTERM handle)
sem_destroy(&priv->waitsem);
#endif
/* Free all allocated glyph bitmap */
/* Free the font cache */
for (i = 0; i < CONFIG_NXTERM_CACHESIZE; i++)
{
FAR struct nxterm_glyph_s *glyph = &priv->glyph[i];
if (glyph->bitmap)
{
kmm_free(glyph->bitmap);
}
}
nxf_cache_disconnect(priv->fcache);
/* Unregister the driver */

104
include/nuttx/nx/nxfonts.h
View file

@ -51,6 +51,7 @@
* Pre-processor definitions
****************************************************************************/
/* Font Definitions *********************************************************/
/* Select the default font. If no fonts are selected, then a compilation
* error is likely down the road.
*/
@ -202,10 +203,16 @@
#endif
/* Font Cache Definitions (**************************************************/
/* Limit to range of font cache usage count */
#define MAX_USECNT 255 /* Limit to range of a uint8_t */
/****************************************************************************
* Public Types
****************************************************************************/
/* Font Types ***************************************************************/
/* Font IDs */
enum nx_fontid_e
@ -453,6 +460,23 @@ struct nx_fontpackage_s
#endif
};
/* Font Cache ***************************************************************/
/* Opaque handle used to reference a font cache */
typedef FAR void *FCACHE;
/* Describes one cached font glyph */
struct nxfonts_glyph_s
{
uint8_t code; /* Character code */
uint8_t height; /* Height of this glyph (in rows) */
uint8_t width; /* Width of this glyph (in pixels) */
uint8_t stride; /* Width of the glyph row (in bytes) */
uint8_t usecnt; /* Use count */
FAR uint8_t *bitmap; /* Allocated bitmap memory */
};
/****************************************************************************
* Public Data
****************************************************************************/
@ -480,6 +504,9 @@ extern "C"
* Input Parameters:
* fontid: Identifies the font set to get
*
* Returned Value:
* One success, a non-NULL font handle is returned.
*
****************************************************************************/
NXHANDLE nxf_getfonthandle(enum nx_fontid_e fontid);
@ -564,6 +591,83 @@ int nxf_convert_32bpp(FAR uint32_t *dest, uint16_t height,
FAR const struct nx_fontbitmap_s *bm,
nxgl_mxpixel_t color);
/****************************************************************************
* Name: nxf_cache_connect
*
* Description:
* Create a new font cache for the provided 'fontid'. If the cache
* already, then just increment a reference count return the handler for
* the existing font cache.
*
* Input Parameters:
* fontid - Identifies the font supported by this cache
*
* Returned value:
* On success a non-NULL handle is returned that then may sequently be
* used with nxf_getglyph() to extract fonts from the font cache. NULL
* returned on any failure with the errno value set to indicate the nature
* of the error.
*
****************************************************************************/
FCACHE nxf_cache_connect(enum nx_fontid_e fontid,
nxgl_mxpixel_t fgcolor, nxgl_mxpixel_t bgcolor,
int bpp);
/****************************************************************************
* Name: nxf_cache_disconnect
*
* Description:
* Decrement the reference count on the font cache and, if the reference
* count goes to zero, free all resources used by the font cache. The
* font handler is invalid upon return in either case.
*
* Input Parameters:
* fcache - A font cache handler previously returned by nxf_cache_connect();
*
* Returned value:
* None
*
****************************************************************************/
void nxf_cache_disconnect(FCACHE fcache);
/****************************************************************************
* Name: nxf_cache_getfonthandle
*
* Description:
* Return the handle to the font set used by this instance of the font
* cache.
*
* Input Parameters:
* fcache - A font cache handle previously returned by nxf_cache_connect();
*
* Returned value:
* Zero (OK) is returned if the metrics were
*
* Returned Value:
* One success, a non-NULL font handle is returned.
*
****************************************************************************/
NXHANDLE nxf_cache_getfonthandle(FCACHE fcache);
/****************************************************************************
* Name: nxf_cache_getglyph
*
* Description:
* Get the font glyph for the character code 'ch' from the font cache. If
* the glyph for that character code does not exist in the font cache, it
* be rendered.
*
* Returned Value:
* On success, a non-NULL pointer to the rendered glyph in the font cache
* is returned. NULL is returned on any failure.
*
****************************************************************************/
FAR struct nxfonts_glyph_s *nxf_cache_getglyph(FCACHE fcache, uint8_t ch);
#undef EXTERN
#if defined(__cplusplus)
}

2
libnx/nxfonts/Make.defs
View file

@ -37,7 +37,7 @@
ifeq ($(CONFIG_NX),y)
CSRCS += nxfonts_getfont.c
CSRCS += nxfonts_getfont.c nxfonts_cache.c
CSRCS += nxfonts_convert_1bpp.c nxfonts_convert_2bpp.c
CSRCS += nxfonts_convert_4bpp.c nxfonts_convert_8bpp.c
CSRCS += nxfonts_convert_16bpp.c nxfonts_convert_24bpp.c

639
libnx/nxfonts/nxfonts_cache.c Normal file
View file

@ -0,0 +1,639 @@
/****************************************************************************
* libnx/nxfonts/nxfonts_cache.c
*
* Copyright (C) 2017 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <string.h>
#include <semaphore.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/kmalloc.h>
#include <nuttx/nx/nxfonts.h>
/****************************************************************************
* Private Types
****************************************************************************/
/* This describes a rendering function */
typedef CODE int (*nxf_renderer_t)(FAR nxgl_mxpixel_t *dest, uint16_t height,
uint16_t width, uint16_t stride,
FAR const struct nx_fontbitmap_s *bm,
nxgl_mxpixel_t color);
/* This structure defines one font cache */
struct nxfonts_fcache_s
{
FAR struct nxfonts_fcache_s *flink; /* Supports a singly linked list */
NXHANDLE font; /* Font handle associated with fontid */
sem_t fsem; /* Serializes access to the font cache */
uint16_t fontid; /* ID of font in this cache */
int16_t fclients; /* Number of connected clients */
uint8_t maxglyphs; /* Size of glyph[] array */
uint8_t bpp; /* Bits per pixel */
nxgl_mxpixel_t fgcolor; /* Foreground color */
nxgl_mxpixel_t bgcolor; /* Background color */
nxf_renderer_t renderer; /* Font renderer */
/* Glyph cache data storage */
struct nxfonts_glyph_s glyph[CONFIG_NXTERM_CACHESIZE];
};
/****************************************************************************
* Private Data
****************************************************************************/
/* Head of a list of font caches */
static FAR struct nxfonts_fcache_s *g_fcaches;
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nxf_freeglyph
****************************************************************************/
static void nxf_freeglyph(FAR struct nxfonts_glyph_s *glyph)
{
if (glyph->bitmap)
{
kmm_free(glyph->bitmap);
}
memset(glyph, 0, sizeof(struct nxfonts_glyph_s));
}
/****************************************************************************
* Name: nxf_allocglyph
****************************************************************************/
static inline FAR struct nxfonts_glyph_s *
nxf_allocglyph(FAR struct nxfonts_fcache_s *priv)
{
FAR struct nxfonts_glyph_s *glyph = NULL;
FAR struct nxfonts_glyph_s *luglyph = NULL;
uint8_t luusecnt;
int i;
/* Search through the glyph cache looking for an unused glyph. Also, keep
* track of the least used glyph as well. We need that if we have to replace
* a glyph in the cache.
*/
for (i = 0; i < priv->maxglyphs; i++)
{
/* Is this glyph in use? */
glyph = &priv->glyph[i];
if (!glyph->usecnt)
{
/* No.. return this glyph with a use count of one */
glyph->usecnt = 1;
return glyph;
}
/* Yes.. check for the least recently used */
if (!luglyph || glyph->usecnt < luglyph->usecnt)
{
luglyph = glyph;
}
}
/* If we get here, the glyph cache is full. We replace the least used
* glyph with the one we need now. (luglyph can't be NULL).
*/
luusecnt = luglyph->usecnt;
nxf_freeglyph(luglyph);
/* But lets decrement all of the usecnts so that the new one one be so
* far behind in the counts as the older ones.
*/
if (luusecnt > 1)
{
uint8_t decr = luusecnt - 1;
for (i = 0; i < priv->maxglyphs; i++)
{
/* Is this glyph in use? */
glyph = &priv->glyph[i];
if (glyph->usecnt > decr)
{
glyph->usecnt -= decr;
}
}
}
/* Then return the least used glyph */
luglyph->usecnt = 1;
return luglyph;
}
/****************************************************************************
* Name: nxf_findglyph
****************************************************************************/
static FAR struct nxfonts_glyph_s *
nxf_findglyph(FAR struct nxfonts_fcache_s *priv, uint8_t ch)
{
int i;
/* First, try to find the glyph in the cache of pre-rendered glyphs */
for (i = 0; i < priv->maxglyphs; i++)
{
FAR struct nxfonts_glyph_s *glyph = &priv->glyph[i];
if (glyph->usecnt > 0 && glyph->code == ch)
{
/* Increment the use count (unless it is already at the max) */
if (glyph->usecnt < MAX_USECNT)
{
glyph->usecnt++;
}
/* And return the glyph that we found */
return glyph;
}
}
return NULL;
}
/****************************************************************************
* Name: nxf_renderglyph
****************************************************************************/
static inline FAR struct nxfonts_glyph_s *
nxf_renderglyph(FAR struct nxfonts_fcache_s *priv,
FAR const struct nx_fontbitmap_s *fbm, uint8_t ch)
{
FAR struct nxfonts_glyph_s *glyph = NULL;
FAR nxgl_mxpixel_t *ptr;
#if CONFIG_NXTERM_BPP < 8
nxgl_mxpixel_t pixel;
#endif
int bmsize;
int row;
int col;
int ret;
/* Allocate the glyph (always succeeds) */
glyph = nxf_allocglyph(priv);
glyph->code = ch;
/* Get the dimensions of the glyph */
glyph->width = fbm->metric.width + fbm->metric.xoffset;
glyph->height = fbm->metric.height + fbm->metric.yoffset;
/* Get the physical width of the glyph in bytes */
glyph->stride = (glyph->width * CONFIG_NXTERM_BPP + 7) / 8;
/* Allocate memory to hold the glyph with its offsets */
bmsize = glyph->stride * glyph->height;
glyph->bitmap = (FAR uint8_t *)kmm_malloc(bmsize);
if (glyph->bitmap)
{
/* Initialize the glyph memory to the background color using the
* hard-coded bits-per-pixel (BPP).
*
* TODO: The rest of NX is configured to support multiple devices
* with differing BPP. They logic should be extended to support
* differing BPP's as well.
*/
#if CONFIG_NXTERM_BPP < 8
pixel = priv->bgcolor;
# if CONFIG_NXTERM_BPP == 1
/* Pack 1-bit pixels into a 2-bits */
pixel &= 0x01;
pixel = (pixel) << 1 | pixel;
# endif
# if CONFIG_NXTERM_BPP < 4
/* Pack 2-bit pixels into a nibble */
pixel &= 0x03;
pixel = (pixel) << 2 | pixel;
# endif
/* Pack 4-bit nibbles into a byte */
pixel &= 0x0f;
pixel = (pixel) << 4 | pixel;
ptr = (FAR nxgl_mxpixel_t *)glyph->bitmap;
for (row = 0; row < glyph->height; row++)
{
for (col = 0; col < glyph->stride; col++)
{
/* Transfer the packed bytes into the buffer */
*ptr++ = pixel;
}
}
#elif CONFIG_NXTERM_BPP == 24
# error "Additional logic is needed here for 24bpp support"
#else /* CONFIG_NXTERM_BPP = {8,16,32} */
ptr = (FAR nxgl_mxpixel_t *)glyph->bitmap;
for (row = 0; row < glyph->height; row++)
{
/* Just copy the color value into the glyph memory */
for (col = 0; col < glyph->width; col++)
{
*ptr++ = priv->bgcolor;
}
}
#endif
/* Then render the glyph into the allocated memory */
ret = priv->renderer((FAR nxgl_mxpixel_t *)glyph->bitmap,
glyph->height, glyph->width, glyph->stride,
fbm, priv->fgcolor);
if (ret < 0)
{
/* Actually, the renderer never returns a failure */
gerr("ERROR: nxf_renderglyph: Renderer failed\n");
nxf_freeglyph(glyph);
glyph = NULL;
}
}
return glyph;
}
/****************************************************************************
* Name: nxf_findcache
****************************************************************************/
static FAR struct nxfonts_fcache_s *
nxf_findcache(enum nx_fontid_e fontid, nxgl_mxpixel_t fgcolor,
nxgl_mxpixel_t bgcolor, int bpp)
{
FAR struct nxfonts_fcache_s *fcache;
/* Get exclusive access to the font cache list */
#warning Missing logic
/* Search for a cache for this font characteristics */
for (fcache = g_fcaches; fcache != NULL; fcache = fcache->flink)
{
/* Does this font have the same characteristics? */
if (fcache->fontid == fontid &&
fcache->fgcolor == fgcolor &&
fcache->bgcolor == bgcolor &&
fcache->bpp == bpp)
{
/* Yes... return it */
return fcache;
}
}
return NULL;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: nxf_cache_connect
*
* Description:
* Create a new font cache for the provided 'fontid'. If the cache
* already, then just increment a reference count return the handle for
* the existing font cache.
*
* Input Parameters:
* fontid - Identifies the font supported by this cache
* fgcolor - Foreground color
* bgcolor - Background color
* bpp - Bits per pixel
*
* Returned value:
* On success a non-NULL handle is returned that then may sequently be
* used with nxf_getglyph() to extract fonts from the font cache. NULL
* returned on any failure with the errno value set to indicate the nature
* of the error.
*
****************************************************************************/
FCACHE nxf_cache_connect(enum nx_fontid_e fontid,
nxgl_mxpixel_t fgcolor, nxgl_mxpixel_t bgcolor,
int bpp)
{
FAR struct nxfonts_fcache_s *priv;
int errcode;
/* Find a font cache with the matching font characteristics */
priv = nxf_findcache(fontid, fgcolor, bgcolor, bpp);
if (priv == NULL)
{
/* There isn't one... we will have to create a new font cache for this
* client.
*/
/* Allocate memory for the (empty) font cache */
priv = (FAR struct nxfonts_fcache_s *)
kmm_malloc(sizeof( struct nxfonts_fcache_s));
if (priv == NULL)
{
errcode = ENOMEM;
goto errout;
}
/* Initialize the font cache */
priv->maxglyphs = CONFIG_NXTERM_CACHESIZE;
priv->fontid = fontid;
priv->fgcolor = fgcolor;
priv->bgcolor = bgcolor;
priv->bpp = bpp;
/* Select the rendering function */
/* Select renderer -- Some additional logic would be required to
* support pixel depths that are not directly addressable (1,2,4, and
* 24).
*/
#ifndef CONFIG_NX_DISABLE_1BPP
if (bpp == 1)
{
priv->renderer = (nxf_renderer_t)nxf_convert_1bpp;
}
else
#endif
#ifndef CONFIG_NX_DISABLE_2BPP
if (bpp == 2)
{
priv->renderer = (nxf_renderer_t)nxf_convert_2bpp;
}
else
#endif
#ifndef CONFIG_NX_DISABLE_4BPP
if (bpp == 4)
{
priv->renderer = (nxf_renderer_t)nxf_convert_4bpp;
}
else
#endif
#ifndef CONFIG_NX_DISABLE_8BPP
if (bpp == 8)
{
priv->renderer = (nxf_renderer_t)nxf_convert_8bpp;
}
else
#endif
#ifndef CONFIG_NX_DISABLE_16BPP
if (bpp == 16)
{
priv->renderer = (nxf_renderer_t)nxf_convert_16bpp;
}
else
#endif
#ifndef CONFIG_NX_DISABLE_24BPP
if (bpp == 24)
{
priv->renderer = (nxf_renderer_t)nxf_convert_24bpp;
}
else
#endif
#ifndef CONFIG_NX_DISABLE_32BPP
if (bpp == 32)
{
priv->renderer = (nxf_renderer_t)nxf_convert_32bpp;
}
else
#endif
{
gerr("ERROR: Unsupported pixel depth: %d\n", bpp);
errcode = ENOSYS;
goto errout_with_fcache;
}
/* Select the font */
priv->font = nxf_getfonthandle(fontid);
if (priv->font == NULL)
{
errcode = get_errno();
gerr("ERROR: Failed to get font ID %d: %d\n", fontid, errcode);
goto errout_with_fcache;
}
}
return (FCACHE)priv;
errout_with_fcache:
kmm_free(priv);
errout:
set_errno(errcode);
return NULL;
}
/****************************************************************************
* Name: nxf_cache_disconnect
*
* Description:
* Decrement the reference count on the font cache and, if the reference
* count goes to zero, free all resources used by the font cache. The
* font handle is invalid upon return in either case.
*
* Input Parameters:
* fcache - A font cache handle previously returned by nxf_cache_connect();
*
* Returned value:
* None
*
****************************************************************************/
void nxf_cache_disconnect(FCACHE fcache)
{
FAR struct nxfonts_fcache_s *priv = (FAR struct nxfonts_fcache_s *)fcache;
int ret;
int i;
DEBUGASSERT(priv != NULL && priv->fclients > 0);
/* Get exclusive access to the font cache */
while ((ret = sem_wait(&priv->fsem)) < 0)
{
int errorcode = errno;
DEBUGASSERT(errorcode == EINTR || errorcode == ECANCELED);
UNUSED(errorcode);
}
/* Is this the last client of the font cache? */
if (priv->fclients <= 1)
{
/* Yes.. destroy the font cache */
/* Free all allocated glyph bitmap */
for (i = 0; i < CONFIG_NXTERM_CACHESIZE; i++)
{
FAR struct nxfonts_glyph_s *glyph = &priv->glyph[i];
if (glyph->bitmap)
{
kmm_free(glyph->bitmap);
}
}
/* Destroy the serializing semaphore... while we are holding it? */
sem_destroy(&priv->fsem);
/* Finally, free the font cache stucture itself */
kmm_free(fcache);
}
else
{
/* No.. just decrement the number of clients connected to the font
* cache.
*/
priv->fclients--;
sem_post(&priv->fsem);
}
}
/****************************************************************************
* Name: nxf_cache_getfonthandle
*
* Description:
* Return the handle to the font set used by this instance of the font
* cache.
*
* Input Parameters:
* fcache - A font cache handle previously returned by nxf_cache_connect();
*
* Returned value:
* Zero (OK) is returned if the metrics were
*
* Returned Value:
* One success, a non-NULL font handle is returned.
*
****************************************************************************/
NXHANDLE nxf_cache_getfonthandle(FCACHE fcache)
{
FAR struct nxfonts_fcache_s *priv = (FAR struct nxfonts_fcache_s *)fcache;
DEBUGASSERT(priv != NULL && priv->font != NULL);
return priv->font;
}
/****************************************************************************
* Name: nxf_cache_getglyph
*
* Description:
* Get the font glyph for the character code 'ch' from the font cache. If
* the glyph for that character code does not exist in the font cache, it
* be rendered.
*
* Returned Value:
* On success, a non-NULL pointer to the rendered glyph in the font cache
* is returned. NULL is returned on any failure.
*
****************************************************************************/
FAR struct nxfonts_glyph_s *nxf_cache_getglyph(FCACHE fcache, uint8_t ch)
{
FAR struct nxfonts_fcache_s *priv = (FAR struct nxfonts_fcache_s *)fcache;
FAR struct nxfonts_glyph_s *glyph;
FAR const struct nx_fontbitmap_s *fbm;
/* First, try to find the glyph in the cache of pre-rendered glyphs */
glyph = nxf_findglyph(priv, ch);
if (glyph)
{
/* We found it in the cache .. return the cached glyph */
return glyph;
}
/* No, it is not cached... Does the code map to a font? */
fbm = nxf_getbitmap(priv->font, ch);
if (fbm)
{
/* Yes.. render the glyph */
glyph = nxf_renderglyph(priv, fbm, ch);
}
return glyph;
}