firmware/font.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (c) 2002 by Greg Haerr <greg@censoft.com>
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 /*
  20  * Rockbox startup font initialization
  21  * This file specifies which fonts get compiled-in and
  22  * loaded at startup, as well as their mapping into
  23  * the FONT_SYSFIXED, FONT_UI and FONT_MP3 ids.
  24  */
  25 #include "config.h"
  26
  27 #if defined(HAVE_LCD_BITMAP) || defined(SIMULATOR)
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include "lcd.h"
  32 #include "font.h"
  33 #include "file.h"
  34 #include "debug.h"
  35 #include "panic.h"
  36 #include "rbunicode.h"
  37 /* Font cache includes */
  38 #include "font_cache.h"
  39 #include "lru.h"
  40
  41 #ifndef O_BINARY
  42 #define O_BINARY 0
  43 #endif
  44
  45 /* compiled-in font */
  46 extern struct font sysfont;
  47
  48 /* structure filled in by font_load */
  49 static struct font font_ui;
  50
  51 /* system font table, in order of FONT_xxx definition */
  52 static struct font* const sysfonts[MAXFONTS] = { &sysfont, &font_ui };
  53
  54 /* static buffer allocation structures */
  55 static unsigned char mbuf[MAX_FONT_SIZE];
  56 static unsigned char *freeptr = mbuf;
  57 static unsigned char *fileptr;
  58 static unsigned char *eofptr;
  59
  60 /* Font cache structures */
  61 static struct font_cache font_cache_ui;
  62 static int fnt_file = -1;           /* >=0 if font is cached   */
  63 unsigned long file_width_offset;    /* offset to file width data    */
  64 unsigned long file_offset_offset;   /* offset to file offset data   */
  65 static void cache_create(int maxwidth, int height);
  66 static int long_offset = 0;
  67 static int glyph_file;
  68 /* End Font cache structures */
  69
  70 void font_init(void)
  71 {
  72     memset(&font_ui, 0, sizeof(struct font));
  73 }
  74
  75 /* Check if we have x bytes left in the file buffer */
  76 #define HAVEBYTES(x) (fileptr + (x) <= eofptr)
  77
  78 /* Helper functions to read big-endian unaligned short or long from
  79    the file buffer.  Bounds-checking must be done in the calling
  80    function.
  81  */
  82
  83 static short readshort(void)
  84 {
  85     unsigned short s;
  86
  87     s = *fileptr++ & 0xff;
  88     s |= (*fileptr++ << 8);
  89     return s;
  90 }
  91
  92 static long readlong(void)
  93 {
  94     unsigned long l;
  95
  96     l = *fileptr++ & 0xff;
  97     l |= *fileptr++ << 8;
  98     l |= ((unsigned long)(*fileptr++)) << 16;
  99     l |= ((unsigned long)(*fileptr++)) << 24;
 100     return l;
 101 }
 102
 103 /* read count bytes*/
 104 static void readstr(char *buf, int count)
 105 {
 106     while (count--)
 107         *buf++ = *fileptr++;
 108 }
 109
 110 void font_reset(void)
 111 {
 112     memset(&font_ui, 0, sizeof(struct font));
 113 }
 114
 115 static struct font*  font_load_header(struct font *pf)
 116 {
 117     char version[4+1];
 118
 119     /* Check we have enough data */
 120     if (!HAVEBYTES(28))
 121         return NULL;
 122
 123     /* read magic and version #*/
 124     memset(version, 0, sizeof(version));
 125     readstr(version, 4);
 126
 127     if (strcmp(version, VERSION) != 0)
 128         return NULL;
 129
 130     /* font info*/
 131     pf->maxwidth = readshort();
 132     pf->height = readshort();
 133     pf->ascent = readshort();
 134     fileptr += 2; /* Skip padding */
 135     pf->firstchar = readlong();
 136     pf->defaultchar = readlong();
 137     pf->size = readlong();
 138
 139     /* get variable font data sizes*/
 140     /* # words of bitmap_t*/
 141     pf->bits_size = readlong();
 142
 143     return pf;
 144 }
 145 /* Load memory font */
 146 struct font* font_load_in_memory(struct font* pf)
 147 {
 148     long i, noffset, nwidth;
 149
 150     if (!HAVEBYTES(4))
 151         return NULL;
 152
 153     /* # longs of offset*/
 154     noffset = readlong();
 155
 156     /* # bytes of width*/
 157     nwidth = readlong();
 158
 159     /* variable font data*/
 160     pf->bits = (unsigned char *)fileptr;
 161     fileptr += pf->bits_size*sizeof(unsigned char);
 162
 163     if ( pf->bits_size < 0xFFDB )
 164     {
 165         /* pad to 16-bit boundary */
 166         fileptr = (unsigned char *)(((long)fileptr + 1) & ~1);
 167     }
 168     else
 169     {
 170         /* pad to 32-bit boundary*/
 171         fileptr = (unsigned char *)(((long)fileptr + 3) & ~3);
 172     }
 173
 174     if (noffset)
 175     {
 176         if ( pf->bits_size < 0xFFDB )
 177         {
 178             long_offset = 0;
 179             pf->offset = (unsigned short *)fileptr;
 180
 181             /* Check we have sufficient buffer */
 182             if (!HAVEBYTES(noffset * sizeof(short)))
 183                 return NULL;
 184
 185             for (i=0; i<noffset; ++i)
 186             {
 187                 ((unsigned short*)(pf->offset))[i] = (unsigned short)readshort();
 188             }
 189         }
 190         else
 191         {
 192             long_offset = 1;
 193             pf->offset = (unsigned short *)fileptr;
 194
 195             /* Check we have sufficient buffer */
 196             if (!HAVEBYTES(noffset * sizeof(long)))
 197                 return NULL;
 198
 199             for (i=0; i<noffset; ++i)
 200             {
 201                 ((unsigned long*)(pf->offset))[i] = (unsigned long)readlong();
 202             }
 203         }
 204     }
 205     else
 206         pf->offset = NULL;
 207
 208     if (nwidth) {
 209         pf->width = (unsigned char *)fileptr;
 210         fileptr += nwidth*sizeof(unsigned char);
 211     }
 212     else
 213         pf->width = NULL;
 214
 215     if (fileptr > eofptr)
 216         return NULL;
 217
 218     return pf;    /* success!*/
 219 }
 220
 221 /* Load cached font */
 222 struct font* font_load_cached(struct font* pf)
 223 {
 224     unsigned long noffset, nwidth;
 225     unsigned char* oldfileptr = fileptr;
 226
 227     if (!HAVEBYTES(2 * sizeof(long)))
 228         return NULL;
 229
 230     /* # longs of offset*/
 231     noffset = readlong();
 232
 233     /* # bytes of width*/
 234     nwidth = readlong();
 235
 236     /* We are now at the bitmap data, this is fixed at 36.. */
 237     pf->bits = NULL;
 238
 239     /* Calculate offset to offset data */
 240     fileptr += pf->bits_size * sizeof(unsigned char);
 241
 242     if ( pf->bits_size < 0xFFDB )
 243     {
 244         long_offset = 0;
 245         /* pad to 16-bit boundary */
 246         fileptr = (unsigned char *)(((long)fileptr + 1) & ~1);
 247     }
 248     else
 249     {
 250         long_offset = 1;
 251         /* pad to 32-bit boundary*/
 252         fileptr = (unsigned char *)(((long)fileptr + 3) & ~3);
 253     }
 254
 255     if (noffset)
 256         file_offset_offset = (unsigned long)(fileptr - freeptr);
 257     else
 258         file_offset_offset = 0;
 259
 260     /* Calculate offset to widths data */
 261     if ( pf->bits_size < 0xFFDB )
 262         fileptr += noffset * sizeof(unsigned short);
 263     else
 264         fileptr += noffset * sizeof(unsigned long);
 265
 266     if (nwidth)
 267         file_width_offset = (unsigned long)(fileptr - freeptr);
 268     else
 269         file_width_offset = 0;
 270
 271     fileptr = oldfileptr;
 272
 273     /* Create the cache */
 274     cache_create(pf->maxwidth, pf->height);
 275
 276     return pf;
 277 }
 278
 279 /* read and load font into incore font structure*/
 280 struct font* font_load(const char *path)
 281 {
 282     int size;
 283     struct font* pf = &font_ui;
 284
 285     /* save loaded glyphs */
 286     glyph_cache_save();
 287
 288     /* Close font file handle */
 289     if (fnt_file >= 0)
 290         close(fnt_file);
 291
 292     /* open and read entire font file*/
 293     fnt_file = open(path, O_RDONLY|O_BINARY);
 294
 295     if (fnt_file < 0) {
 296         DEBUGF("Can't open font: %s\n", path);
 297         return NULL;
 298     }
 299
 300     /* Check file size */
 301     size = filesize(fnt_file);
 302
 303     font_reset();
 304
 305     /* currently, font loading replaces earlier font allocation*/
 306     freeptr = (unsigned char *)(((int)mbuf + 3) & ~3);
 307     fileptr = freeptr;
 308
 309
 310     if (size > MAX_FONT_SIZE)
 311     {
 312         read(fnt_file, fileptr, FONT_HEADER_SIZE);
 313         eofptr = fileptr + FONT_HEADER_SIZE;
 314
 315         if (!font_load_header(pf))
 316         {
 317             DEBUGF("Failed font header load");
 318             return NULL;
 319         }
 320
 321         if (!font_load_cached(pf))
 322         {
 323             DEBUGF("Failed font cache load");
 324             return NULL;
 325         }
 326
 327         glyph_cache_load();
 328     }
 329     else
 330     {
 331         read(fnt_file, fileptr, MAX_FONT_SIZE);
 332         eofptr = fileptr + size;
 333         close(fnt_file);
 334         fnt_file = -1;
 335
 336         if (!font_load_header(pf))
 337         {
 338             DEBUGF("Failed font header load");
 339             return NULL;
 340         }
 341
 342         if (!font_load_in_memory(pf))
 343         {
 344             DEBUGF("Failed mem load");
 345             return NULL;
 346         }
 347     }
 348
 349     /* no need for multiple font loads currently*/
 350     /*freeptr += filesize;*/
 351     /*freeptr = (unsigned char *)(freeptr + 3) & ~3;*/  /* pad freeptr*/
 352
 353     return pf; /* success!*/
 354 }
 355
 356 /*
 357  * Return a pointer to an incore font structure.
 358  * If the requested font isn't loaded/compiled-in,
 359  * decrement the font number and try again.
 360  */
 361 struct font* font_get(int font)
 362 {
 363     struct font* pf;
 364
 365     if (font >= MAXFONTS)
 366         font = 0;
 367
 368     while (1) {
 369         pf = sysfonts[font];
 370         if (pf && pf->height)
 371             return pf;
 372         if (--font < 0)
 373             panicf("No font!");
 374     }
 375 }
 376 /*
 377  * Returns the stringsize of a given string.
 378  */
 379 int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
 380 {
 381     struct font* pf = font_get(fontnumber);
 382     unsigned short ch;
 383     int width = 0;
 384
 385     for (str = utf8decode(str, &ch); ch != 0 ; str = utf8decode(str, &ch))
 386     {
 387
 388         /* get proportional width and glyph bits*/
 389         width += font_get_width(pf,ch);
 390     }
 391     if ( w )
 392         *w = width;
 393     if ( h )
 394         *h = pf->height;
 395     return width;
 396 }
 397
 398 /*
 399  * Reads an entry into cache entry
 400  */
 401 static void
 402 load_cache_entry(struct font_cache_entry* p, void* callback_data)
 403 {
 404     struct font* pf = callback_data;
 405     unsigned short char_code = p->_char_code;
 406     unsigned char tmp[2];
 407
 408     if (file_width_offset)
 409     {
 410         int width_offset = file_width_offset + char_code;
 411         lseek(fnt_file, width_offset, SEEK_SET);
 412         read(fnt_file, &(p->width), 1);
 413     }
 414     else
 415     {
 416         p->width = pf->maxwidth;
 417     }
 418
 419     long bitmap_offset = 0;
 420
 421     if (file_offset_offset)
 422     {
 423         long offset = file_offset_offset + char_code * (long_offset ? sizeof(long) : sizeof(short));
 424         lseek(fnt_file, offset, SEEK_SET);
 425         read (fnt_file, tmp, 2);
 426         bitmap_offset = tmp[0] | (tmp[1] << 8);
 427         if (long_offset) {
 428             read (fnt_file, tmp, 2);
 429             bitmap_offset |= (tmp[0] << 16) | (tmp[1] << 24);
 430         }
 431     }
 432     else
 433     {
 434         bitmap_offset = ((pf->height + 7) / 8) * p->width * char_code;
 435     }
 436
 437     long file_offset = FONT_HEADER_SIZE + bitmap_offset;
 438     lseek(fnt_file, file_offset, SEEK_SET);
 439
 440     int src_bytes = p->width * ((pf->height + 7) / 8);
 441     read(fnt_file, p->bitmap, src_bytes);
 442 }
 443
 444 /*
 445  * Converts cbuf into a font cache
 446  */
 447 static void cache_create(int maxwidth, int height)
 448 {
 449     /* maximum size of rotated bitmap */
 450     int bitmap_size = maxwidth * ((height + 7) / 8);
 451
 452     /* Initialise cache */
 453     font_cache_create(&font_cache_ui, mbuf, MAX_FONT_SIZE, bitmap_size);
 454 }
 455
 456 /*
 457  * Returns width of character
 458  */
 459 int font_get_width(struct font* pf, unsigned short char_code)
 460 {
 461     /* check input range*/
 462     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 463         char_code = pf->defaultchar;
 464     char_code -= pf->firstchar;
 465
 466     return (fnt_file >= 0 && pf != &sysfont)?
 467         font_cache_get(&font_cache_ui,char_code,load_cache_entry,pf)->width:
 468         pf->width? pf->width[char_code]: pf->maxwidth;
 469 }
 470
 471 const unsigned char* font_get_bits(struct font* pf, unsigned short char_code)
 472 {
 473     const unsigned char* bits;
 474
 475     /* check input range*/
 476     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 477         char_code = pf->defaultchar;
 478     char_code -= pf->firstchar;
 479
 480     if (fnt_file >= 0 && pf != &sysfont)
 481     {
 482         bits =
 483             (unsigned char*)font_cache_get(&font_cache_ui,char_code,load_cache_entry,pf)->bitmap;
 484     }
 485     else
 486     {
 487         bits = pf->bits + (pf->offset?
 488             pf->offset[char_code]:
 489             (((pf->height + 7) / 8) * pf->maxwidth * char_code));
 490     }
 491
 492     return bits;
 493 }
 494
 495 void glyph_file_write(void* data)
 496 {
 497     struct font_cache_entry* p = data;
 498     struct font* pf = &font_ui;
 499     unsigned short ch;
 500     unsigned char tmp[2];
 501
 502     ch = p->_char_code + pf->firstchar;
 503
 504     if (ch != 0xffff && glyph_file >= 0) {
 505         tmp[0] = ch >> 8;
 506         tmp[1] = ch & 0xff;
 507         if (write(glyph_file, tmp, 2) != 2) {
 508             close(glyph_file);
 509             glyph_file = -1;
 510         }
 511     }
 512     return;
 513 }
 514
 515 /* save the char codes of the loaded glyphs to a file */
 516 void glyph_cache_save(void)
 517 {
 518
 519     if (fnt_file >= 0) {
 520
 521         glyph_file = creat(GLYPH_CACHE_FILE);
 522
 523         if (glyph_file < 0) return;
 524
 525         lru_traverse(&font_cache_ui._lru, glyph_file_write);
 526
 527         if (glyph_file >= 0)
 528             close(glyph_file);
 529     }
 530     return;
 531 }
 532
 533 void glyph_cache_load(void)
 534 {
 535     if (fnt_file >= 0) {
 536
 537         int fd;
 538         unsigned char tmp[2];
 539         unsigned short ch;
 540         struct font* pf = &font_ui;
 541
 542         fd = open(GLYPH_CACHE_FILE, O_RDONLY|O_BINARY);
 543
 544         if (fd >= 0) {
 545
 546             while (read(fd, tmp, 2) == 2) {
 547                 ch = (tmp[0] << 8) | tmp[1];
 548                 font_get_bits(pf, ch);
 549             }
 550
 551             close(fd);
 552         } else {
 553             /* load latin1 chars into cache */
 554             ch = 256;
 555             while (ch-- > 32)
 556                 font_get_bits(pf, ch);
 557         }
 558     }
 559     return;
 560 }
 561
 562 #endif /* HAVE_LCD_BITMAP */
 563
 564 /* -----------------------------------------------------------------
 565  * vim: et sw=4 ts=8 sts=4 tw=78
 566  */