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 #include "diacritic.h"
  39
  40 #define MAX_FONTSIZE_FOR_16_BIT_OFFSETS 0xFFDB
  41
  42 /* max static loadable font buffer size */
  43 #ifndef MAX_FONT_SIZE
  44 #if LCD_HEIGHT > 64
  45 #if MEM > 2
  46 #define MAX_FONT_SIZE   60000
  47 #else
  48 #define MAX_FONT_SIZE   10000
  49 #endif
  50 #else
  51 #define MAX_FONT_SIZE   4000
  52 #endif
  53 #endif
  54
  55 #ifndef FONT_HEADER_SIZE
  56 #define FONT_HEADER_SIZE 36
  57 #endif
  58
  59 #define GLYPH_CACHE_FILE ROCKBOX_DIR"/.glyphcache"
  60
  61 #ifndef BOOTLOADER
  62 /* Font cache includes */
  63 #include "font_cache.h"
  64 #include "lru.h"
  65 #endif
  66
  67 #ifndef O_BINARY
  68 #define O_BINARY 0
  69 #endif
  70
  71 /* compiled-in font */
  72 extern struct font sysfont;
  73
  74 #ifndef BOOTLOADER
  75
  76 /* structure filled in by font_load */
  77 static struct font font_ui;
  78 /* static buffer allocation structures */
  79 static unsigned char main_buf[MAX_FONT_SIZE];
  80 #ifdef HAVE_REMOTE_LCD
  81 #define REMOTE_FONT_SIZE 10000
  82 static struct font remote_font_ui;
  83 static unsigned char remote_buf[REMOTE_FONT_SIZE];
  84 #endif
  85
  86 /* system font table, in order of FONT_xxx definition */
  87 static struct font* sysfonts[MAXFONTS] = { &sysfont, &font_ui, NULL};
  88
  89
  90 /* Font cache structures */
  91 static void cache_create(struct font* pf, int maxwidth, int height);
  92 static void glyph_cache_load(struct font* pf);
  93 /* End Font cache structures */
  94
  95 void font_init(void)
  96 {
  97     int i = SYSTEMFONTCOUNT;
  98     while (i<MAXFONTS)
  99         sysfonts[i++] = NULL;
 100     font_reset(NULL);
 101 }
 102
 103 /* Check if we have x bytes left in the file buffer */
 104 #define HAVEBYTES(x) (pf->buffer_position + (x) <= pf->buffer_end)
 105
 106 /* Helper functions to read big-endian unaligned short or long from
 107    the file buffer.  Bounds-checking must be done in the calling
 108    function.
 109  */
 110
 111 static short readshort(struct font *pf)
 112 {
 113     unsigned short s;
 114
 115     s = *pf->buffer_position++ & 0xff;
 116     s |= (*pf->buffer_position++ << 8);
 117     return s;
 118 }
 119
 120 static int32_t readlong(struct font *pf)
 121 {
 122     uint32_t l;
 123
 124     l = *pf->buffer_position++ & 0xff;
 125     l |= *pf->buffer_position++ << 8;
 126     l |= ((uint32_t)(*pf->buffer_position++)) << 16;
 127     l |= ((uint32_t)(*pf->buffer_position++)) << 24;
 128     return l;
 129 }
 130
 131 void font_reset(struct font *pf)
 132 {
 133     unsigned char* buffer = NULL;
 134     size_t buf_size = 0;
 135     if (pf == NULL)
 136         pf = &font_ui;
 137     else
 138     {
 139         buffer = pf->buffer_start;
 140         buf_size = pf->buffer_size;
 141     }
 142     memset(pf, 0, sizeof(struct font));
 143     pf->fd = -1;
 144     if (buffer)
 145     {
 146         pf->buffer_start = buffer;
 147         pf->buffer_size = buf_size;
 148     }
 149 }
 150
 151 static struct font* font_load_header(struct font *pf)
 152 {
 153     /* Check we have enough data */
 154     if (!HAVEBYTES(28))
 155         return NULL;
 156
 157     /* read magic and version #*/
 158     if (memcmp(pf->buffer_position, VERSION, 4) != 0)
 159         return NULL;
 160
 161     pf->buffer_position += 4;
 162
 163     /* font info*/
 164     pf->maxwidth = readshort(pf);
 165     pf->height = readshort(pf);
 166     pf->ascent = readshort(pf);
 167     pf->buffer_position += 2; /* Skip padding */
 168     pf->firstchar = readlong(pf);
 169     pf->defaultchar = readlong(pf);
 170     pf->size = readlong(pf);
 171
 172     /* get variable font data sizes*/
 173     /* # words of bitmap_t*/
 174     pf->bits_size = readlong(pf);
 175
 176     return pf;
 177 }
 178 /* Load memory font */
 179 static struct font* font_load_in_memory(struct font* pf)
 180 {
 181     int32_t i, noffset, nwidth;
 182
 183     if (!HAVEBYTES(4))
 184         return NULL;
 185
 186     /* # longs of offset*/
 187     noffset = readlong(pf);
 188
 189     /* # bytes of width*/
 190     nwidth = readlong(pf);
 191
 192     /* variable font data*/
 193     pf->bits = (unsigned char *)pf->buffer_position;
 194     pf->buffer_position += pf->bits_size*sizeof(unsigned char);
 195
 196     if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS)
 197     {
 198         /* pad to 16-bit boundary */
 199         pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 1) & ~1);
 200     }
 201     else
 202     {
 203         /* pad to 32-bit boundary*/
 204         pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 3) & ~3);
 205     }
 206
 207     if (noffset)
 208     {
 209         if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS)
 210         {
 211             pf->long_offset = 0;
 212             pf->offset = (uint16_t*)pf->buffer_position;
 213
 214             /* Check we have sufficient buffer */
 215             if (!HAVEBYTES(noffset * sizeof(uint16_t)))
 216                 return NULL;
 217
 218             for (i=0; i<noffset; ++i)
 219             {
 220                 ((uint16_t*)(pf->offset))[i] = (uint16_t)readshort(pf);
 221             }
 222         }
 223         else
 224         {
 225             pf->long_offset = 1;
 226             pf->offset = (uint16_t*)pf->buffer_position;
 227
 228             /* Check we have sufficient buffer */
 229             if (!HAVEBYTES(noffset * sizeof(int32_t)))
 230                 return NULL;
 231
 232             for (i=0; i<noffset; ++i)
 233             {
 234                 ((uint32_t*)(pf->offset))[i] = (uint32_t)readlong(pf);
 235             }
 236         }
 237     }
 238     else
 239         pf->offset = NULL;
 240
 241     if (nwidth) {
 242         pf->width = (unsigned char *)pf->buffer_position;
 243         pf->buffer_position += nwidth*sizeof(unsigned char);
 244     }
 245     else
 246         pf->width = NULL;
 247
 248     if (pf->buffer_position > pf->buffer_end)
 249         return NULL;
 250
 251     return pf;    /* success!*/
 252 }
 253
 254 /* Load cached font */
 255 static struct font* font_load_cached(struct font* pf)
 256 {
 257     uint32_t noffset, nwidth;
 258     unsigned char* oldfileptr = pf->buffer_position;
 259
 260     if (!HAVEBYTES(2 * sizeof(int32_t)))
 261         return NULL;
 262
 263     /* # longs of offset*/
 264     noffset = readlong(pf);
 265
 266     /* # bytes of width*/
 267     nwidth = readlong(pf);
 268
 269     /* We are now at the bitmap data, this is fixed at 36.. */
 270     pf->bits = NULL;
 271
 272     /* Calculate offset to offset data */
 273     pf->buffer_position += pf->bits_size * sizeof(unsigned char);
 274
 275     if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS)
 276     {
 277         pf->long_offset = 0;
 278         /* pad to 16-bit boundary */
 279         pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 1) & ~1);
 280     }
 281     else
 282     {
 283         pf->long_offset = 1;
 284         /* pad to 32-bit boundary*/
 285         pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 3) & ~3);
 286     }
 287
 288     if (noffset)
 289         pf->file_offset_offset = (uint32_t)(pf->buffer_position - pf->buffer_start);
 290     else
 291         pf->file_offset_offset = 0;
 292
 293     /* Calculate offset to widths data */
 294     if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS)
 295         pf->buffer_position += noffset * sizeof(uint16_t);
 296     else
 297         pf->buffer_position += noffset * sizeof(uint32_t);
 298
 299     if (nwidth)
 300         pf->file_width_offset = (uint32_t)(pf->buffer_position - pf->buffer_start);
 301     else
 302         pf->file_width_offset = 0;
 303
 304     pf->buffer_position = oldfileptr;
 305
 306     /* Create the cache */
 307     cache_create(pf, pf->maxwidth, pf->height);
 308
 309     return pf;
 310 }
 311
 312 static bool internal_load_font(struct font* pf, const char *path,
 313                                char *buf, size_t buf_size)
 314 {
 315     int size;
 316
 317     /* save loaded glyphs */
 318     glyph_cache_save(pf);
 319     /* Close font file handle */
 320     if (pf->fd >= 0)
 321         close(pf->fd);
 322
 323     font_reset(pf);
 324
 325     /* open and read entire font file*/
 326     pf->fd = open(path, O_RDONLY|O_BINARY);
 327
 328     if (pf->fd < 0) {
 329         DEBUGF("Can't open font: %s\n", path);
 330         return false;
 331     }
 332
 333     /* Check file size */
 334     size = filesize(pf->fd);
 335     pf->buffer_start = buf;
 336     pf->buffer_size = buf_size;
 337
 338     pf->buffer_position = buf;
 339
 340     if (size > pf->buffer_size)
 341     {
 342         read(pf->fd, pf->buffer_position, FONT_HEADER_SIZE);
 343         pf->buffer_end = pf->buffer_position + FONT_HEADER_SIZE;
 344
 345         if (!font_load_header(pf))
 346         {
 347             DEBUGF("Failed font header load");
 348             return false;
 349         }
 350
 351         if (!font_load_cached(pf))
 352         {
 353             DEBUGF("Failed font cache load");
 354             return false;
 355         }
 356
 357         glyph_cache_load(pf);
 358     }
 359     else
 360     {
 361         read(pf->fd, pf->buffer_position, pf->buffer_size);
 362         pf->buffer_end = pf->buffer_position + size;
 363         close(pf->fd);
 364         pf->fd = -1;
 365
 366         if (!font_load_header(pf))
 367         {
 368             DEBUGF("Failed font header load");
 369             return false;
 370         }
 371
 372         if (!font_load_in_memory(pf))
 373         {
 374             DEBUGF("Failed mem load");
 375             return false;
 376         }
 377     }
 378     return true;
 379 }
 380
 381 #ifdef HAVE_REMOTE_LCD
 382 /* Load a font into the special remote ui font slot */
 383 int font_load_remoteui(const char* path)
 384 {
 385     struct font* pf = &remote_font_ui;
 386     if (!path)
 387     {
 388         if (sysfonts[FONT_UI_REMOTE] && sysfonts[FONT_UI_REMOTE] != sysfonts[FONT_UI])
 389             font_unload(FONT_UI_REMOTE);
 390         sysfonts[FONT_UI_REMOTE] = NULL;
 391         return FONT_UI;
 392     }
 393     if (!internal_load_font(pf, path, remote_buf, REMOTE_FONT_SIZE))
 394     {
 395         sysfonts[FONT_UI_REMOTE] = NULL;
 396         return -1;
 397     }
 398
 399     sysfonts[FONT_UI_REMOTE] = pf;
 400     return FONT_UI_REMOTE;
 401 }
 402 #endif
 403
 404 /* read and load font into incore font structure,
 405  * returns the font number on success, -1 on failure */
 406 int font_load(struct font* pf, const char *path)
 407 {
 408     int font_id = -1;
 409     char *buffer;
 410     size_t buffer_size;
 411     if (pf == NULL)
 412     {
 413         pf = &font_ui;
 414         font_id = FONT_UI;
 415     }
 416     else
 417     {
 418         for (font_id = SYSTEMFONTCOUNT; font_id < MAXFONTS; font_id++)
 419         {
 420             if (sysfonts[font_id] == NULL)
 421                 break;
 422         }
 423         if (font_id == MAXFONTS)
 424             return -1; /* too many fonts */
 425     }
 426
 427     if (font_id == FONT_UI)
 428     {
 429         /* currently, font loading replaces earlier font allocation*/
 430         buffer = (unsigned char *)(((intptr_t)main_buf + 3) & ~3);
 431         buffer_size = MAX_FONT_SIZE;
 432     }
 433     else
 434     {
 435         buffer = pf->buffer_start;
 436         buffer_size = pf->buffer_size;
 437     }
 438
 439     if (!internal_load_font(pf, path, buffer, buffer_size))
 440         return -1;
 441
 442     sysfonts[font_id] = pf;
 443     return font_id; /* success!*/
 444 }
 445
 446 void font_unload(int font_id)
 447 {
 448     struct font* pf = sysfonts[font_id];
 449     if (font_id >= SYSTEMFONTCOUNT && pf)
 450     {
 451         if (pf->fd >= 0)
 452             close(pf->fd);
 453         sysfonts[font_id] = NULL;
 454     }
 455 }
 456
 457 /*
 458  * Return a pointer to an incore font structure.
 459  * If the requested font isn't loaded/compiled-in,
 460  * decrement the font number and try again.
 461  */
 462 struct font* font_get(int font)
 463 {
 464     struct font* pf;
 465
 466     while (1) {
 467         pf = sysfonts[font];
 468         if (pf && pf->height)
 469             return pf;
 470         if (--font < 0)
 471             panicf("No font!");
 472     }
 473 }
 474
 475 /*
 476  * Reads an entry into cache entry
 477  */
 478 static void
 479 load_cache_entry(struct font_cache_entry* p, void* callback_data)
 480 {
 481     struct font* pf = callback_data;
 482     unsigned short char_code = p->_char_code;
 483     unsigned char tmp[2];
 484
 485     if (pf->file_width_offset)
 486     {
 487         int width_offset = pf->file_width_offset + char_code;
 488         lseek(pf->fd, width_offset, SEEK_SET);
 489         read(pf->fd, &(p->width), 1);
 490     }
 491     else
 492     {
 493         p->width = pf->maxwidth;
 494     }
 495
 496     int32_t bitmap_offset = 0;
 497
 498     if (pf->file_offset_offset)
 499     {
 500         int32_t offset = pf->file_offset_offset + char_code * (pf->long_offset ? sizeof(int32_t) : sizeof(int16_t));
 501         lseek(pf->fd, offset, SEEK_SET);
 502         read (pf->fd, tmp, 2);
 503         bitmap_offset = tmp[0] | (tmp[1] << 8);
 504         if (pf->long_offset) {
 505             read (pf->fd, tmp, 2);
 506             bitmap_offset |= (tmp[0] << 16) | (tmp[1] << 24);
 507         }
 508     }
 509     else
 510     {
 511         bitmap_offset = ((pf->height + 7) / 8) * p->width * char_code;
 512     }
 513
 514     int32_t file_offset = FONT_HEADER_SIZE + bitmap_offset;
 515     lseek(pf->fd, file_offset, SEEK_SET);
 516
 517     int src_bytes = p->width * ((pf->height + 7) / 8);
 518     read(pf->fd, p->bitmap, src_bytes);
 519 }
 520
 521 /*
 522  * Converts cbuf into a font cache
 523  */
 524 static void cache_create(struct font* pf, int maxwidth, int height)
 525 {
 526     /* maximum size of rotated bitmap */
 527     int bitmap_size = maxwidth * ((height + 7) / 8);
 528
 529     /* Initialise cache */
 530     font_cache_create(&pf->cache, pf->buffer_start, pf->buffer_size, bitmap_size);
 531 }
 532
 533 /*
 534  * Returns width of character
 535  */
 536 int font_get_width(struct font* pf, unsigned short char_code)
 537 {
 538     /* check input range*/
 539     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 540         char_code = pf->defaultchar;
 541     char_code -= pf->firstchar;
 542
 543     return (pf->fd >= 0 && pf != &sysfont)?
 544         font_cache_get(&pf->cache,char_code,load_cache_entry,pf)->width:
 545         pf->width? pf->width[char_code]: pf->maxwidth;
 546 }
 547
 548 const unsigned char* font_get_bits(struct font* pf, unsigned short char_code)
 549 {
 550     const unsigned char* bits;
 551
 552     /* check input range*/
 553     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 554         char_code = pf->defaultchar;
 555     char_code -= pf->firstchar;
 556
 557     if (pf->fd >= 0 && pf != &sysfont)
 558     {
 559         bits =
 560             (unsigned char*)font_cache_get(&pf->cache,char_code,load_cache_entry,pf)->bitmap;
 561     }
 562     else
 563     {
 564         bits = pf->bits;
 565         if (pf->offset)
 566         {
 567             if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS)
 568                 bits += ((uint16_t*)(pf->offset))[char_code];
 569             else
 570                 bits += ((uint32_t*)(pf->offset))[char_code];
 571         }
 572         else
 573             bits += ((pf->height + 7) / 8) * pf->maxwidth * char_code;
 574     }
 575
 576     return bits;
 577 }
 578 static int cache_fd;
 579 static void glyph_file_write(void* data)
 580 {
 581     struct font_cache_entry* p = data;
 582     struct font* pf = &font_ui;
 583     unsigned short ch;
 584     unsigned char tmp[2];
 585
 586     ch = p->_char_code + pf->firstchar;
 587
 588     if (ch != 0xffff && cache_fd >= 0) {
 589         tmp[0] = ch >> 8;
 590         tmp[1] = ch & 0xff;
 591         if (write(cache_fd, tmp, 2) != 2) {
 592             close(cache_fd);
 593             cache_fd = -1;
 594         }
 595     }
 596     return;
 597 }
 598
 599 /* save the char codes of the loaded glyphs to a file */
 600 void glyph_cache_save(struct font* pf)
 601 {
 602     if (!pf)
 603         pf = &font_ui;
 604     if (pf->fd >= 0 && pf == &font_ui)
 605     {
 606 #ifdef WPSEDITOR
 607         cache_fd = open(GLYPH_CACHE_FILE, O_WRONLY|O_CREAT|O_TRUNC);
 608 #else
 609         cache_fd = creat(GLYPH_CACHE_FILE);
 610 #endif
 611         if (cache_fd < 0) return;
 612
 613         lru_traverse(&pf->cache._lru, glyph_file_write);
 614
 615         if (cache_fd < 0)
 616         {
 617             close(cache_fd);
 618             cache_fd = -1;
 619         }
 620     }
 621     return;
 622 }
 623
 624 static void glyph_cache_load(struct font* pf)
 625 {
 626     if (pf->fd >= 0) {
 627         int fd;
 628         unsigned char tmp[2];
 629         unsigned short ch;
 630
 631         fd = open(GLYPH_CACHE_FILE, O_RDONLY|O_BINARY);
 632
 633         if (fd >= 0) {
 634
 635             while (read(fd, tmp, 2) == 2) {
 636                 ch = (tmp[0] << 8) | tmp[1];
 637                 font_get_bits(pf, ch);
 638             }
 639
 640             close(fd);
 641         } else {
 642             /* load latin1 chars into cache */
 643             ch = 256;
 644             while (ch-- > 32)
 645                 font_get_bits(pf, ch);
 646         }
 647     }
 648     return;
 649 }
 650 #else /* BOOTLOADER */
 651
 652 void font_init(void)
 653 {
 654 }
 655
 656 /*
 657  * Bootloader only supports the built-in sysfont.
 658  */
 659 struct font* font_get(int font)
 660 {
 661     (void)font;
 662     return &sysfont;
 663 }
 664
 665 /*
 666  * Returns width of character
 667  */
 668 int font_get_width(struct font* pf, unsigned short char_code)
 669 {
 670     /* check input range*/
 671     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 672         char_code = pf->defaultchar;
 673     char_code -= pf->firstchar;
 674
 675     return pf->width? pf->width[char_code]: pf->maxwidth;
 676 }
 677
 678 const unsigned char* font_get_bits(struct font* pf, unsigned short char_code)
 679 {
 680     const unsigned char* bits;
 681
 682     /* check input range*/
 683     if (char_code < pf->firstchar || char_code >= pf->firstchar+pf->size)
 684         char_code = pf->defaultchar;
 685     char_code -= pf->firstchar;
 686
 687     /* assume small font with uint16_t offsets*/
 688     bits = pf->bits + (pf->offset?
 689             ((uint16_t*)(pf->offset))[char_code]:
 690             (((pf->height + 7) / 8) * pf->maxwidth * char_code));
 691
 692     return bits;
 693 }
 694
 695 #endif /* BOOTLOADER */
 696
 697 /*
 698  * Returns the stringsize of a given string.
 699  */
 700 int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
 701 {
 702     struct font* pf = font_get(fontnumber);
 703     unsigned short ch;
 704     int width = 0;
 705
 706     for (str = utf8decode(str, &ch); ch != 0 ; str = utf8decode(str, &ch))
 707     {
 708         if (is_diacritic(ch, NULL))
 709             continue;
 710
 711         /* get proportional width and glyph bits*/
 712         width += font_get_width(pf,ch);
 713     }
 714     if ( w )
 715         *w = width;
 716     if ( h )
 717         *h = pf->height;
 718     return width;
 719 }
 720
 721 /* -----------------------------------------------------------------
 722  * vim: et sw=4 ts=8 sts=4 tw=78
 723  */