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