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