GNU Unifont  15.1.01
Pan-Unicode font with complete Unicode Plane 0 coverage and partial coverage of higher planes
unifont-support.c File Reference

: Support functions for Unifont .hex files. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Include dependency graph for unifont-support.c:

Go to the source code of this file.

Functions

void parse_hex (char *hexstring, int *width, unsigned *codept, unsigned char glyph[16][2])
 Decode a Unifont .hex file into Uniocde code point and glyph. More...
 
void glyph2bits (int width, unsigned char glyph[16][2], unsigned char glyphbits[16][16])
 Convert a Unifont binary glyph into a binary glyph array of bits. More...
 
void hexpose (int width, unsigned char glyphbits[16][16], unsigned char transpose[2][16])
 Transpose a Unifont .hex format glyph into 2 column-major sub-arrays. More...
 
void glyph2string (int width, unsigned codept, unsigned char glyph[16][2], char *outstring)
 Convert a glyph code point and byte array into a Unifont .hex string. More...
 
void xglyph2string (int width, unsigned codept, unsigned char transpose[2][16], char *outstring)
 Convert a code point and transposed glyph into a Unifont .hex string. More...
 

Detailed Description

: Support functions for Unifont .hex files.

Author
Paul Hardy

Definition in file unifont-support.c.

Function Documentation

◆ glyph2bits()

void glyph2bits ( int  width,
unsigned char  glyph[16][2],
unsigned char  glyphbits[16][16] 
)

Convert a Unifont binary glyph into a binary glyph array of bits.

This function takes a Unifont 16-row by 1- or 2-byte wide binary glyph and returns an array of 16 rows by 16 columns. For each output array element, a 1 indicates the corresponding bit was set in the binary glyph, and a 0 indicates the corresponding bit was not set.

Parameters
[in]widthThe number of columns in the glyph.
[in]glyphThe binary glyph, as a 16-row by 2-byte array.
[out]glyphbitsThe converted glyph, as a 16-row, 16-column array.

Definition at line 91 of file unifont-support.c.

93  {
94 
95  unsigned char tmp_byte;
96  unsigned char mask;
97  int row, column;
98 
99  for (row = 0; row < 16; row++) {
100  tmp_byte = glyph [row][0];
101  mask = 0x80;
102  for (column = 0; column < 8; column++) {
103  glyphbits [row][column] = tmp_byte & mask ? 1 : 0;
104  mask >>= 1;
105  }
106 
107  if (width > 8)
108  tmp_byte = glyph [row][1];
109  else
110  tmp_byte = 0x00;
111 
112  mask = 0x80;
113  for (column = 8; column < 16; column++) {
114  glyphbits [row][column] = tmp_byte & mask ? 1 : 0;
115  mask >>= 1;
116  }
117  }
118 
119 
120  return;
121 }

◆ glyph2string()

void glyph2string ( int  width,
unsigned  codept,
unsigned char  glyph[16][2],
char *  outstring 
)

Convert a glyph code point and byte array into a Unifont .hex string.

This function takes a code point and a 16-row by 1- or 2-byte binary glyph, and converts it into a Unifont .hex format character array.

Parameters
[in]widthThe number of columns in the glyph.
[in]codeptThe code point to appear in the output .hex string.
[in]glyphThe glyph, with each of 16 rows 1 or 2 bytes wide.
[out]outstringThe output string, in Unifont .hex format.

Definition at line 221 of file unifont-support.c.

223  {
224 
225  int i; /* index into outstring array */
226  int row;
227 
228  if (codept <= 0xFFFF) {
229  sprintf (outstring, "%04X:", codept);
230  i = 5;
231  }
232  else {
233  sprintf (outstring, "%06X:", codept);
234  i = 7;
235  }
236 
237  for (row = 0; row < 16; row++) {
238  sprintf (&outstring[i], "%02X", glyph [row][0]);
239  i += 2;
240 
241  if (width > 8) {
242  sprintf (&outstring[i], "%02X", glyph [row][1]);
243  i += 2;
244  }
245  }
246 
247  outstring[i] = '\0'; /* terminate output string */
248 
249 
250  return;
251 }

◆ hexpose()

void hexpose ( int  width,
unsigned char  glyphbits[16][16],
unsigned char  transpose[2][16] 
)

Transpose a Unifont .hex format glyph into 2 column-major sub-arrays.

This function takes a 16-by-16 cell bit array made from a Unifont glyph (as created by the glyph2bits function) and outputs a transposed array of 2 sets of 8 or 16 columns, depending on the glyph width. This format simplifies outputting these bit patterns on a graphics display with a controller chip designed to output a column of 8 pixels at a time.

For a line of text with Unifont output, first all glyphs can have their first 8 rows of pixels displayed on a line. Then the second 8 rows of all glyphs on the line can be displayed. This simplifies code for such controller chips that are designed to automatically increment input bytes of column data by one column at a time for each successive byte.

The glyphbits array contains a '1' in each cell where the corresponding non-transposed glyph has a pixel set, and 0 in each cell where a pixel is not set.

Parameters
[in]widthThe number of columns in the glyph.
[in]glyphbitsThe 16-by-16 pixel glyph bits.
[out]transposeThe array of 2 sets of 8 ot 16 columns of 8 pixels.

Definition at line 150 of file unifont-support.c.

152  {
153 
154  int column;
155 
156 
157  for (column = 0; column < 8; column++) {
158  transpose [0][column] =
159  (glyphbits [ 0][column] << 7) |
160  (glyphbits [ 1][column] << 6) |
161  (glyphbits [ 2][column] << 5) |
162  (glyphbits [ 3][column] << 4) |
163  (glyphbits [ 4][column] << 3) |
164  (glyphbits [ 5][column] << 2) |
165  (glyphbits [ 6][column] << 1) |
166  (glyphbits [ 7][column] );
167  transpose [1][column] =
168  (glyphbits [ 8][column] << 7) |
169  (glyphbits [ 9][column] << 6) |
170  (glyphbits [10][column] << 5) |
171  (glyphbits [11][column] << 4) |
172  (glyphbits [12][column] << 3) |
173  (glyphbits [13][column] << 2) |
174  (glyphbits [14][column] << 1) |
175  (glyphbits [15][column] );
176  }
177  if (width > 8) {
178  for (column = 8; column < width; column++) {
179  transpose [0][column] =
180  (glyphbits [0][column] << 7) |
181  (glyphbits [1][column] << 6) |
182  (glyphbits [2][column] << 5) |
183  (glyphbits [3][column] << 4) |
184  (glyphbits [4][column] << 3) |
185  (glyphbits [5][column] << 2) |
186  (glyphbits [6][column] << 1) |
187  (glyphbits [7][column] );
188  transpose [1][column] =
189  (glyphbits [ 8][column] << 7) |
190  (glyphbits [ 9][column] << 6) |
191  (glyphbits [10][column] << 5) |
192  (glyphbits [11][column] << 4) |
193  (glyphbits [12][column] << 3) |
194  (glyphbits [13][column] << 2) |
195  (glyphbits [14][column] << 1) |
196  (glyphbits [15][column] );
197  }
198  }
199  else {
200  for (column = 8; column < width; column++)
201  transpose [0][column] = transpose [1][column] = 0x00;
202  }
203 
204 
205  return;
206 }

◆ parse_hex()

void parse_hex ( char *  hexstring,
int *  width,
unsigned *  codept,
unsigned char  glyph[16][2] 
)

Decode a Unifont .hex file into Uniocde code point and glyph.

This function takes one line from a Unifont .hex file and decodes it into a code point followed by a 16-row glyph array. The glyph array can be one byte (8 columns) or two bytes (16 columns).

Parameters
[in]hexstringThe Unicode .hex string for one code point.
[out]widthThe number of columns in a glyph with 16 rows.
[out]codeptThe code point, contained in the first .hex file field.
[out]glyphThe Unifont glyph, as 16 rows by 1 or 2 bytes wide.

Definition at line 44 of file unifont-support.c.

47  {
48 
49  int i;
50  int row;
51  int length;
52 
53  sscanf (hexstring, "%X", codept);
54  length = strlen (hexstring);
55  for (i = length - 1; i > 0 && hexstring[i] != '\n'; i--);
56  hexstring[i] = '\0';
57  for (i = 0; i < 9 && hexstring[i] != ':'; i++);
58  i++; /* Skip over ':' */
59  *width = (length - i) * 4 / 16; /* 16 rows per glyphbits */
60 
61  for (row = 0; row < 16; row++) {
62  sscanf (&hexstring[i], "%2hhX", &glyph [row][0]);
63  i += 2;
64  if (*width > 8) {
65  sscanf (&hexstring[i], "%2hhX", &glyph [row][1]);
66  i += 2;
67  }
68  else {
69  glyph [row][1] = 0x00;
70  }
71  }
72 
73 
74  return;
75 }

◆ xglyph2string()

void xglyph2string ( int  width,
unsigned  codept,
unsigned char  transpose[2][16],
char *  outstring 
)

Convert a code point and transposed glyph into a Unifont .hex string.

This function takes a code point and a transposed Unifont glyph of 2 rows of 8 pixels in a column, and converts it into a Unifont .hex format character array.

Parameters
[in]widthThe number of columns in the glyph.
[in]codeptThe code point to appear in the output .hex string.
[in]transposeThe transposed glyph, with 2 sets of 8-row data.
[out]outstringThe output string, in Unifont .hex format.

Definition at line 267 of file unifont-support.c.

269  {
270 
271  int i; /* index into outstring array */
272  int column;
273 
274  if (codept <= 0xFFFF) {
275  sprintf (outstring, "%04X:", codept);
276  i = 5;
277  }
278  else {
279  sprintf (outstring, "%06X:", codept);
280  i = 7;
281  }
282 
283  for (column = 0; column < 8; column++) {
284  sprintf (&outstring[i], "%02X", transpose [0][column]);
285  i += 2;
286  }
287  if (width > 8) {
288  for (column = 8; column < 16; column++) {
289  sprintf (&outstring[i], "%02X", transpose [0][column]);
290  i += 2;
291  }
292  }
293  for (column = 0; column < 8; column++) {
294  sprintf (&outstring[i], "%02X", transpose [1][column]);
295  i += 2;
296  }
297  if (width > 8) {
298  for (column = 8; column < 16; column++) {
299  sprintf (&outstring[i], "%02X", transpose [1][column]);
300  i += 2;
301  }
302  }
303 
304  outstring[i] = '\0'; /* terminate output string */
305 
306 
307  return;
308 }