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 static int readshort(unsigned short *sp)
  76 {
  77     unsigned short s;
  78
  79     s = *fileptr++ & 0xff;
  80     *sp = (*fileptr++ << 8) | s;
  81     return (fileptr <= eofptr);
  82 }
  83
  84 static long readlong(unsigned long *lp)
  85 {
  86     unsigned long l;
  87
  88     l = *fileptr++ & 0xff;
  89     l |= *fileptr++ << 8;
  90     l |= ((unsigned long)(*fileptr++)) << 16;
  91     l |= ((unsigned long)(*fileptr++)) << 24;
  92     *lp = l;
  93     return (fileptr <= eofptr);
  94 }
  95
  96 /* read count bytes*/
  97 static int readstr(char *buf, int count)
  98 {
  99     int n = count;
 100
 101     while (--n >= 0)
 102         *buf++ = *fileptr++;
 103     return (fileptr <= eofptr)? count: 0;
 104 }
 105
 106 void font_reset(void)
 107 {
 108     memset(&font_ui, 0, sizeof(struct font));
 109 }
 110
 111 static struct font*  font_load_header(struct font *pf)
 112 {
 113     char version[4+1];
 114     unsigned short maxwidth, height, ascent, pad;
 115     unsigned long firstchar, defaultchar, size;
 116     unsigned long nbits;
 117
 118     /* read magic and version #*/
 119     memset(version, 0, sizeof(version));
 120     if (readstr(version, 4) != 4)
 121         return NULL;
 122     if (strcmp(version, VERSION) != 0)
 123         return NULL;
 124
 125     /* font info*/
 126     if (!readshort(&maxwidth))
 127         return NULL;
 128     pf->maxwidth = maxwidth;
 129     if (!readshort(&height))
 130         return NULL;
 131     pf->height = height;
 132     if (!readshort(&ascent))
 133         return NULL;
 134     pf->ascent = ascent;
 135     if (!readshort(&pad))
 136         return NULL;
 137     if (!readlong(&firstchar))
 138         return NULL;
 139     pf->firstchar = firstchar;
 140     if (!readlong(&defaultchar))
 141         return NULL;
 142     pf->defaultchar = defaultchar;
 143     if (!readlong(&size))
 144         return NULL;
 145     pf->size = size;
 146
 147     /* get variable font data sizes*/
 148     /* # words of bitmap_t*/
 149     if (!readlong(&nbits))
 150         return NULL;
 151     pf->bits_size = nbits;
 152
 153     return pf;
 154 }
 155 /* Load memory font */
 156 struct font* font_load_in_memory(struct font* pf)
 157 {
 158     long i, noffset, nwidth;
 159
 160     /* # longs of offset*/
 161     if (!readlong(&noffset))
 162         return NULL;
 163
 164     /* # bytes of width*/
 165     if (!readlong(&nwidth))
 166         return NULL;
 167
 168     /* variable font data*/
 169     pf->bits = (unsigned char *)fileptr;
 170     fileptr += pf->bits_size*sizeof(unsigned char);
 171
 172     if ( pf->bits_size < 0xFFDB )
 173     {
 174         /* pad to 16-bit boundary */
 175         fileptr = (unsigned char *)(((long)fileptr + 1) & ~1);
 176     }
 177     else
 178     {
 179         /* pad to 32-bit boundary*/
 180         fileptr = (unsigned char *)(((long)fileptr + 3) & ~3);
 181     }
 182
 183     if (noffset)
 184     {
 185         if ( pf->bits_size < 0xFFDB )
 186         {
 187             long_offset = 0;
 188             pf->offset = (unsigned short *)fileptr;
 189             for (i=0; i<noffset; ++i)
 190             {
 191                 unsigned short offset;
 192                 if (!readshort(&offset))
 193                     return NULL;
 194                 ((unsigned short*)(pf->offset))[i] = (unsigned short)offset;
 195             }
 196         }
 197         else
 198         {
 199             long_offset = 1;
 200             pf->offset = (unsigned short *)fileptr;
 201             for (i=0; i<noffset; ++i)
 202             {
 203                 unsigned long offset;
 204                 if (!readlong(&offset))
 205                     return NULL;
 206                 ((unsigned long*)(pf->offset))[i] = (unsigned long)offset;
 207             }
 208         }
 209     }
 210     else
 211         pf->offset = NULL;
 212
 213     if (nwidth) {
 214         pf->width = (unsigned char *)fileptr;
 215         fileptr += nwidth*sizeof(unsigned char);
 216     }
 217     else
 218         pf->width = NULL;
 219
 220     if (fileptr > eofptr)
 221         return NULL;
 222
 223     return pf;    /* success!*/
 224 }
 225
 226 /* Load cached font */
 227 struct font* font_load_cached(struct font* pf)
 228 {
 229     unsigned long noffset, nwidth;
 230     unsigned char* oldfileptr = fileptr;
 231
 232     /* # longs of offset*/
 233     if (!readlong(&noffset))
 234         return NULL;
 235
 236     /* # bytes of width*/
 237     if (!readlong(&nwidth))
 238         return NULL;
 239
 240     /* We are now at the bitmap data, this is fixed at 36.. */
 241     pf->bits = NULL;
 242
 243     /* Calculate offset to offset data */
 244     fileptr += pf->bits_size * sizeof(unsigned char);
 245
 246     if ( pf->bits_size < 0xFFDB )
 247     {
 248         long_offset = 0;
 249         /* pad to 16-bit boundary */
 250         fileptr = (unsigned char *)(((long)fileptr + 1) & ~1);
 251     }
 252     else
 253     {
 254         long_offset = 1;
 255         /* pad to 32-bit boundary*/
 256         fileptr = (unsigned char *)(((long)fileptr + 3) & ~3);
 257     }
 258
 259     if (noffset)
 260         file_offset_offset = (unsigned long)(fileptr - freeptr);
 261     else
 262         file_offset_offset = 0;
 263
 264     /* Calculate offset to widths data */
 265     if ( pf->bits_size < 0xFFDB )
 266         fileptr += noffset * sizeof(unsigned short);
 267     else
 268         fileptr += noffset * sizeof(unsigned long);
 269
 270     if (nwidth)
 271         file_width_offset = (unsigned long)(fileptr - freeptr);
 272     else
 273         file_width_offset = 0;
 274
 275     fileptr = oldfileptr;
 276
 277     /* Create the cache */
 278     cache_create(pf->maxwidth, pf->height);
 279
 280     return pf;
 281 }
 282
 283 /* read and load font into incore font structure*/
 284 struct font* font_load(const char *path)
 285 {
 286     int size;
 287     struct font* pf = &font_ui;
 288
 289     /* save loaded glyphs */
 290     glyph_cache_save();
 291
 292     /* Close font file handle */
 293     if (fnt_file >= 0)
 294         close(fnt_file);
 295
 296     /* open and read entire font file*/
 297     fnt_file = open(path, O_RDONLY|O_BINARY);
 298
 299     if (fnt_file < 0) {
 300         DEBUGF("Can't open font: %s\n", path);
 301         return NULL;
 302     }
 303
 304     /* Check file size */
 305     size = filesize(fnt_file);
 306
 307     font_reset();
 308
 309     /* currently, font loading replaces earlier font allocation*/
 310     freeptr = (unsigned char *)(((int)mbuf + 3) & ~3);
 311     fileptr = freeptr;
 312
 313
 314     if (size > MAX_FONT_SIZE)
 315     {
 316         read(fnt_file, fileptr, FONT_HEADER_SIZE);
 317         eofptr = fileptr + FONT_HEADER_SIZE;
 318
 319         if (!font_load_header(pf))
 320         {
 321             DEBUGF("Failed font header load");
 322             return NULL;
 323         }
 324
 325         if (!font_load_cached(pf))
 326         {
 327             DEBUGF("Failed font cache load");
 328             return NULL;
 329         }
 330
 331         glyph_cache_load();
 332     }
 333     else
 334     {
 335         read(fnt_file, fileptr, MAX_FONT_SIZE);
 336         eofptr = fileptr + size;
 337         close(fnt_file);
 338         fnt_file = -1;
 339
 340         if (!font_load_header(pf))
 341         {
 342             DEBUGF("Failed font header load");
 343             return NULL;
 344         }
 345
 346         if (!font_load_in_memory(pf))
 347         {
 348             DEBUGF("Failed mem load");
 349             return NULL;
 350         }
 351     }
 352
 353     /* no need for multiple font loads currently*/
 354     /*freeptr += filesize;*/
 355     /*freeptr = (unsigned char *)(freeptr + 3) & ~3;*/  /* pad freeptr*/
 356
 357     return pf; /* success!*/
 358 }
 359
 360 /*
 361  * Return a pointer to an incore font structure.
 362  * If the requested font isn't loaded/compiled-in,
 363  * decrement the font number and try again.
 364  */
 365 struct font* font_get(int font)
 366 {
 367     struct font* pf;
 368
 369     if (font >= MAXFONTS)
 370         font = 0;
 371
 372     while (1) {
 373         pf = sysfonts[font];
 374         if (pf && pf->height)
 375             return pf;
 376         if (--font < 0)
 377             panicf("No font!");
 378     }
 379 }
 380 /*
 381  * Returns the stringsize of a given string.
 382  */
 383 int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
 384 {
 385     struct font* pf = font_get(fontnumber);
 386     unsigned short ch;
 387     int width = 0;
 388
 389     for (str = utf8decode(str, &ch); ch != 0 ; str = utf8decode(str, &ch))
 390     {
 391
 392         /* get proportional width and glyph bits*/
 393         width += font_get_width(pf,ch);
 394     }
 395     if ( w )
 396         *w = width;
 397     if ( h )
 398         *h = pf->height;
 399     return width;
 400 }
 401
 402 /*
 403  * Reads an entry into cache entry
 404  */
 405 static void
 406 load_cache_entry(struct font_cache_entry* p, void* callback_data)
 407 {
 408     struct font* pf = callback_data;
 409     unsigned short char_code = p->_char_code;
 410     unsigned char tmp[2];
 411
 412     if (file_width_offset)
 413     {
 414         int width_offset = file_width_offset + char_code;
 415         lseek(fnt_file, width_offset, SEEK_SET);
 416         read(fnt_file, &(p->width), 1);
 417     }
 418     else
 419     {
 420         p->width = pf->maxwidth;
 421     }
 422
 423     long bitmap_offset = 0;
 424
 425     if (file_offset_offset)
 426     {
 427         long offset = file_offset_offset + char_code * (long_offset ? sizeof(long) : sizeof(short));
 428         lseek(fnt_file, offset, SEEK_SET);
 429         read (fnt_file, tmp, 2);
 430         bitmap_offset = tmp[0] | (tmp[1] << 8);
 431         if (long_offset) {
 432             read (fnt_file, tmp, 2);
 433             bitmap_offset |= (tmp[0] << 16) | (tmp[1] << 24);
 434         }
 435     }
 436     else
 437     {
 438         bitmap_offset = ((pf->height + 7) / 8) * p->width * char_code;
 439     }
 440
 441     long file_offset = FONT_HEADER_SIZE + bitmap_offset;
 442     lseek(fnt_file, file_offset, SEEK_SET);
 443
 444     int src_bytes = p->width * ((pf->height + 7) / 8);
 445     read(fnt_file, p->bitmap, src_bytes);
 446 }
 447
 448 /*
 449  * Converts cbuf into a font cache
 450  */
 451 static void cache_create(int maxwidth, int height)
 452 {
 453     /* maximum size of rotated bitmap */
 454     int bitmap_size = maxwidth * ((height + 7) / 8);
 455
 456     /* Initialise cache */
 457     font_cache_create(&font_cache_ui, mbuf, MAX_FONT_SIZE, bitmap_size);
 458 }
 459
 460 /*
 461  * Returns width of character
 462  */
 463 int font_get_width(struct font* pf, unsigned short char_code)
 464 {
 465     /* check input range*/
 466     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 467         char_code = pf->defaultchar;
 468     char_code -= pf->firstchar;
 469
 470     return (fnt_file >= 0 && pf != &sysfont)?
 471         font_cache_get(&font_cache_ui,char_code,load_cache_entry,pf)->width:
 472         pf->width? pf->width[char_code]: pf->maxwidth;
 473 }
 474
 475 const unsigned char* font_get_bits(struct font* pf, unsigned short char_code)
 476 {
 477     const unsigned char* bits;
 478
 479     /* check input range*/
 480     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 481         char_code = pf->defaultchar;
 482     char_code -= pf->firstchar;
 483
 484     if (fnt_file >= 0 && pf != &sysfont)
 485     {
 486         bits =
 487             (unsigned char*)font_cache_get(&font_cache_ui,char_code,load_cache_entry,pf)->bitmap;
 488     }
 489     else
 490     {
 491         bits = pf->bits + (pf->offset?
 492             pf->offset[char_code]:
 493             (((pf->height + 7) / 8) * pf->maxwidth * char_code));
 494     }
 495
 496     return bits;
 497 }
 498
 499 void glyph_file_write(void* data)
 500 {
 501     struct font_cache_entry* p = data;
 502     struct font* pf = &font_ui;
 503     unsigned short ch;
 504     unsigned char tmp[2];
 505
 506     ch = p->_char_code + pf->firstchar;
 507
 508     if (ch != 0xffff && glyph_file >= 0) {
 509         tmp[0] = ch >> 8;
 510         tmp[1] = ch & 0xff;
 511         if (write(glyph_file, tmp, 2) != 2) {
 512             close(glyph_file);
 513             glyph_file = -1;
 514         }
 515     }
 516     return;
 517 }
 518
 519 /* save the char codes of the loaded glyphs to a file */
 520 void glyph_cache_save(void)
 521 {
 522
 523     if (fnt_file >= 0) {
 524
 525         glyph_file = creat(GLYPH_CACHE_FILE, O_WRONLY);
 526
 527         if (glyph_file < 0) return;
 528
 529         lru_traverse(&font_cache_ui._lru, glyph_file_write);
 530
 531         if (glyph_file >= 0)
 532             close(glyph_file);
 533     }
 534     return;
 535 }
 536
 537 void glyph_cache_load(void)
 538 {
 539     if (fnt_file >= 0) {
 540
 541         int fd;
 542         unsigned char tmp[2];
 543         unsigned short ch;
 544         struct font* pf = &font_ui;
 545
 546         fd = open(GLYPH_CACHE_FILE, O_RDONLY|O_BINARY);
 547
 548         if (fd >= 0) {
 549
 550             while (read(fd, tmp, 2) == 2) {
 551                 ch = (tmp[0] << 8) | tmp[1];
 552                 font_get_bits(pf, ch);
 553             }
 554
 555             close(fd);
 556         } else {
 557             /* load latin1 chars into cache */
 558             ch = 256;
 559             while (ch-- > 32)
 560                 font_get_bits(pf, ch);
 561         }
 562     }
 563     return;
 564 }
 565
 566 #endif /* HAVE_LCD_BITMAP */
 567
 568 /* -----------------------------------------------------------------
 569  * vim: et sw=4 ts=8 sts=4 tw=78
 570  */