tools/convbdf.c

   1 /*
   2  * Convert BDF files to C source and/or Rockbox .fnt file format
   3  *
   4  * Copyright (c) 2002 by Greg Haerr <greg@censoft.com>
   5  *
   6  * What fun it is converting font data...
   7  *
   8  * 09/17/02     Version 1.0
   9  */
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <time.h>
  14
  15 #define ROTATE /* define this for the new, rotated format */
  16
  17 /* BEGIN font.h*/
  18 /* loadable font magic and version #*/
  19 #ifdef ROTATE
  20 #define VERSION         "RB12" /* newer version */
  21 #else
  22 #define VERSION         "RB11"
  23 #endif
  24
  25 /* bitmap_t helper macros*/
  26 #define BITMAP_WORDS(x)         (((x)+15)/16)   /* image size in words*/
  27 #define BITMAP_BYTES(x)         (BITMAP_WORDS(x)*sizeof(bitmap_t))
  28 #define BITMAP_BITSPERIMAGE     (sizeof(bitmap_t) * 8)
  29 #define BITMAP_BITVALUE(n)      ((bitmap_t) (((bitmap_t) 1) << (n)))
  30 #define BITMAP_FIRSTBIT         (BITMAP_BITVALUE(BITMAP_BITSPERIMAGE - 1))
  31 #define BITMAP_TESTBIT(m)       ((m) & BITMAP_FIRSTBIT)
  32 #define BITMAP_SHIFTBIT(m)      ((bitmap_t) ((m) << 1))
  33
  34 typedef unsigned short bitmap_t; /* bitmap image unit size*/
  35
  36 /* builtin C-based proportional/fixed font structure */
  37 /* based on The Microwindows Project http://microwindows.org */
  38 struct font {
  39     int         maxwidth;       /* max width in pixels*/
  40     int         height;         /* height in pixels*/
  41     int         ascent;         /* ascent (baseline) height*/
  42     int         firstchar;      /* first character in bitmap*/
  43     int         size;           /* font size in glyphs*/
  44     bitmap_t*   bits;           /* 16-bit right-padded bitmap data*/
  45     unsigned long* offset;      /* offsets into bitmap data*/
  46     unsigned char* width;       /* character widths or NULL if fixed*/
  47     int         defaultchar;    /* default char (not glyph index)*/
  48     long        bits_size;      /* # words of bitmap_t bits*/
  49
  50     /* unused by runtime system, read in by convbdf*/
  51     unsigned long* offrot;      /* offsets into rotated bitmap data*/
  52     char *      name;           /* font name*/
  53     char *      facename;       /* facename of font*/
  54     char *      copyright;      /* copyright info for loadable fonts*/
  55     int         pixel_size;
  56     int         descent;
  57     int         fbbw, fbbh, fbbx, fbby;
  58 };
  59 /* END font.h*/
  60
  61 #define isprefix(buf,str)       (!strncmp(buf, str, strlen(str)))
  62 #define strequal(s1,s2)         (!strcmp(s1, s2))
  63
  64 #define EXTRA   300             /* # bytes extra allocation for buggy .bdf files*/
  65
  66 int gen_c = 0;
  67 int gen_fnt = 0;
  68 int gen_map = 1;
  69 int start_char = 0;
  70 int limit_char = 65535;
  71 int oflag = 0;
  72 char outfile[256];
  73
  74 void usage(void);
  75 void getopts(int *pac, char ***pav);
  76 int convbdf(char *path);
  77
  78 void free_font(struct font* pf);
  79 struct font* bdf_read_font(char *path);
  80 int bdf_read_header(FILE *fp, struct font* pf);
  81 int bdf_read_bitmaps(FILE *fp, struct font* pf);
  82 char * bdf_getline(FILE *fp, char *buf, int len);
  83 bitmap_t bdf_hexval(unsigned char *buf, int ndx1, int ndx2);
  84
  85 int gen_c_source(struct font* pf, char *path);
  86 int gen_fnt_file(struct font* pf, char *path);
  87
  88 void
  89 usage(void)
  90 {
  91     char help[] = {
  92         "Usage: convbdf [options] [input-files]\n"
  93         "       convbdf [options] [-o output-file] [single-input-file]\n"
  94         "Options:\n"
  95         "    -c     Convert .bdf to .c source file\n"
  96         "    -f     Convert .bdf to .fnt font file\n"
  97         "    -s N   Start output at character encodings >= N\n"
  98         "    -l N   Limit output to character encodings <= N\n"
  99         "    -n     Don't generate bitmaps as comments in .c file\n"
 100         };
 101
 102     fprintf(stderr, help);
 103 }
 104
 105 /* parse command line options*/
 106 void getopts(int *pac, char ***pav)
 107 {
 108     char *p;
 109     char **av;
 110     int ac;
 111
 112     ac = *pac;
 113     av = *pav;
 114     while (ac > 0 && av[0][0] == '-') {
 115         p = &av[0][1];
 116         while( *p)
 117             switch(*p++) {
 118             case ' ':                   /* multiple -args on av[]*/
 119                 while( *p && *p == ' ')
 120                     p++;
 121                 if( *p++ != '-')        /* next option must have dash*/
 122                     p = "";
 123                 break;                  /* proceed to next option*/
 124             case 'c':                   /* generate .c output*/
 125                 gen_c = 1;
 126                 break;
 127             case 'f':                   /* generate .fnt output*/
 128                 gen_fnt = 1;
 129                 break;
 130             case 'n':                   /* don't gen bitmap comments*/
 131                 gen_map = 0;
 132                 break;
 133             case 'o':                   /* set output file*/
 134                 oflag = 1;
 135                 if (*p) {
 136                     strcpy(outfile, p);
 137                     while (*p && *p != ' ')
 138                         p++;
 139                 }
 140                 else {
 141                     av++; ac--;
 142                     if (ac > 0)
 143                         strcpy(outfile, av[0]);
 144                 }
 145                 break;
 146             case 'l':                   /* set encoding limit*/
 147                 if (*p) {
 148                     limit_char = atoi(p);
 149                     while (*p && *p != ' ')
 150                         p++;
 151                 }
 152                 else {
 153                     av++; ac--;
 154                     if (ac > 0)
 155                         limit_char = atoi(av[0]);
 156                 }
 157                 break;
 158             case 's':                   /* set encoding start*/
 159                 if (*p) {
 160                     start_char = atoi(p);
 161                     while (*p && *p != ' ')
 162                         p++;
 163                 }
 164                 else {
 165                     av++; ac--;
 166                     if (ac > 0)
 167                         start_char = atoi(av[0]);
 168                 }
 169                 break;
 170             default:
 171                 fprintf(stderr, "Unknown option ignored: %c\r\n", *(p-1));
 172             }
 173         ++av; --ac;
 174     }
 175     *pac = ac;
 176     *pav = av;
 177 }
 178
 179 /* remove directory prefix and file suffix from full path*/
 180 char *basename(char *path)
 181 {
 182     char *p, *b;
 183     static char base[256];
 184
 185     /* remove prepended path and extension*/
 186     b = path;
 187     for (p=path; *p; ++p) {
 188         if (*p == '/')
 189             b = p + 1;
 190     }
 191     strcpy(base, b);
 192     for (p=base; *p; ++p) {
 193         if (*p == '.') {
 194             *p = 0;
 195             break;
 196         }
 197     }
 198     return base;
 199 }
 200
 201 int convbdf(char *path)
 202 {
 203     struct font* pf;
 204     int ret = 0;
 205
 206     pf = bdf_read_font(path);
 207     if (!pf)
 208         exit(1);
 209
 210     if (gen_c) {
 211         if (!oflag) {
 212             strcpy(outfile, basename(path));
 213             strcat(outfile, ".c");
 214         }
 215         ret |= gen_c_source(pf, outfile);
 216     }
 217
 218     if (gen_fnt) {
 219         if (!oflag) {
 220             strcpy(outfile, basename(path));
 221             strcat(outfile, ".fnt");
 222         }
 223         ret |= gen_fnt_file(pf, outfile);
 224     }
 225
 226     free_font(pf);
 227     return ret;
 228 }
 229
 230 int main(int ac, char **av)
 231 {
 232     int ret = 0;
 233
 234     ++av; --ac;         /* skip av[0]*/
 235     getopts(&ac, &av);  /* read command line options*/
 236
 237     if (ac < 1 || (!gen_c && !gen_fnt)) {
 238         usage();
 239         exit(1);
 240     }
 241     if (oflag) {
 242         if (ac > 1 || (gen_c && gen_fnt)) {
 243             usage();
 244             exit(1);
 245         }
 246     }
 247
 248     while (ac > 0) {
 249         ret |= convbdf(av[0]);
 250         ++av; --ac;
 251     }
 252
 253     exit(ret);
 254 }
 255
 256 /* free font structure*/
 257 void free_font(struct font* pf)
 258 {
 259     if (!pf)
 260         return;
 261     if (pf->name)
 262         free(pf->name);
 263     if (pf->facename)
 264         free(pf->facename);
 265     if (pf->bits)
 266         free(pf->bits);
 267     if (pf->offset)
 268         free(pf->offset);
 269     if (pf->offrot)
 270         free(pf->offrot);
 271     if (pf->width)
 272         free(pf->width);
 273     free(pf);
 274 }
 275
 276 /* build incore structure from .bdf file*/
 277 struct font* bdf_read_font(char *path)
 278 {
 279     FILE *fp;
 280     struct font* pf;
 281
 282     fp = fopen(path, "rb");
 283     if (!fp) {
 284         fprintf(stderr, "Error opening file: %s\n", path);
 285         return NULL;
 286     }
 287
 288     pf = (struct font*)calloc(1, sizeof(struct font));
 289     if (!pf)
 290         goto errout;
 291
 292     pf->name = strdup(basename(path));
 293
 294     if (!bdf_read_header(fp, pf)) {
 295         fprintf(stderr, "Error reading font header\n");
 296         goto errout;
 297     }
 298
 299     if (!bdf_read_bitmaps(fp, pf)) {
 300         fprintf(stderr, "Error reading font bitmaps\n");
 301         goto errout;
 302     }
 303
 304     fclose(fp);
 305     return pf;
 306
 307  errout:
 308     fclose(fp);
 309     free_font(pf);
 310     return NULL;
 311 }
 312
 313 /* read bdf font header information, return 0 on error*/
 314 int bdf_read_header(FILE *fp, struct font* pf)
 315 {
 316     int encoding;
 317     int nchars, maxwidth;
 318     int firstchar = 65535;
 319     int lastchar = -1;
 320     char buf[256];
 321     char facename[256];
 322     char copyright[256];
 323
 324     /* set certain values to errors for later error checking*/
 325     pf->defaultchar = -1;
 326     pf->ascent = -1;
 327     pf->descent = -1;
 328
 329     for (;;) {
 330         if (!bdf_getline(fp, buf, sizeof(buf))) {
 331             fprintf(stderr, "Error: EOF on file\n");
 332             return 0;
 333         }
 334         if (isprefix(buf, "FONT ")) {           /* not required*/
 335             if (sscanf(buf, "FONT %[^\n]", facename) != 1) {
 336                 fprintf(stderr, "Error: bad 'FONT'\n");
 337                 return 0;
 338             }
 339             pf->facename = strdup(facename);
 340             continue;
 341         }
 342         if (isprefix(buf, "COPYRIGHT ")) {      /* not required*/
 343             if (sscanf(buf, "COPYRIGHT \"%[^\"]", copyright) != 1) {
 344                 fprintf(stderr, "Error: bad 'COPYRIGHT'\n");
 345                 return 0;
 346             }
 347             pf->copyright = strdup(copyright);
 348             continue;
 349         }
 350         if (isprefix(buf, "DEFAULT_CHAR ")) {   /* not required*/
 351             if (sscanf(buf, "DEFAULT_CHAR %d", &pf->defaultchar) != 1) {
 352                 fprintf(stderr, "Error: bad 'DEFAULT_CHAR'\n");
 353                 return 0;
 354             }
 355         }
 356         if (isprefix(buf, "FONT_DESCENT ")) {
 357             if (sscanf(buf, "FONT_DESCENT %d", &pf->descent) != 1) {
 358                 fprintf(stderr, "Error: bad 'FONT_DESCENT'\n");
 359                 return 0;
 360             }
 361             continue;
 362         }
 363         if (isprefix(buf, "FONT_ASCENT ")) {
 364             if (sscanf(buf, "FONT_ASCENT %d", &pf->ascent) != 1) {
 365                 fprintf(stderr, "Error: bad 'FONT_ASCENT'\n");
 366                 return 0;
 367             }
 368             continue;
 369         }
 370         if (isprefix(buf, "FONTBOUNDINGBOX ")) {
 371             if (sscanf(buf, "FONTBOUNDINGBOX %d %d %d %d",
 372                        &pf->fbbw, &pf->fbbh, &pf->fbbx, &pf->fbby) != 4) {
 373                 fprintf(stderr, "Error: bad 'FONTBOUNDINGBOX'\n");
 374                 return 0;
 375             }
 376             continue;
 377         }
 378         if (isprefix(buf, "CHARS ")) {
 379             if (sscanf(buf, "CHARS %d", &nchars) != 1) {
 380                 fprintf(stderr, "Error: bad 'CHARS'\n");
 381                 return 0;
 382             }
 383             continue;
 384         }
 385
 386         /*
 387          * Reading ENCODING is necessary to get firstchar/lastchar
 388          * which is needed to pre-calculate our offset and widths
 389          * array sizes.
 390          */
 391         if (isprefix(buf, "ENCODING ")) {
 392             if (sscanf(buf, "ENCODING %d", &encoding) != 1) {
 393                 fprintf(stderr, "Error: bad 'ENCODING'\n");
 394                 return 0;
 395             }
 396             if (encoding >= 0 &&
 397                 encoding <= limit_char &&
 398                 encoding >= start_char) {
 399
 400                 if (firstchar > encoding)
 401                     firstchar = encoding;
 402                 if (lastchar < encoding)
 403                     lastchar = encoding;
 404             }
 405             continue;
 406         }
 407         if (strequal(buf, "ENDFONT"))
 408             break;
 409     }
 410
 411     /* calc font height*/
 412     if (pf->ascent < 0 || pf->descent < 0 || firstchar < 0) {
 413         fprintf(stderr, "Error: Invalid BDF file, requires FONT_ASCENT/FONT_DESCENT/ENCODING\n");
 414         return 0;
 415     }
 416     pf->height = pf->ascent + pf->descent;
 417
 418     /* calc default char*/
 419     if (pf->defaultchar < 0 ||
 420         pf->defaultchar < firstchar ||
 421         pf->defaultchar > limit_char )
 422         pf->defaultchar = firstchar;
 423
 424     /* calc font size (offset/width entries)*/
 425     pf->firstchar = firstchar;
 426     pf->size = lastchar - firstchar + 1;
 427
 428     /* use the font boundingbox to get initial maxwidth*/
 429     /*maxwidth = pf->fbbw - pf->fbbx;*/
 430     maxwidth = pf->fbbw;
 431
 432     /* initially use font maxwidth * height for bits allocation*/
 433     pf->bits_size = nchars * BITMAP_WORDS(maxwidth) * pf->height;
 434
 435     /* allocate bits, offset, and width arrays*/
 436     pf->bits = (bitmap_t *)malloc(pf->bits_size * sizeof(bitmap_t) + EXTRA);
 437     pf->offset = (unsigned long *)malloc(pf->size * sizeof(unsigned long));
 438     pf->offrot = (unsigned long *)malloc(pf->size * sizeof(unsigned long));
 439     pf->width = (unsigned char *)malloc(pf->size * sizeof(unsigned char));
 440
 441     if (!pf->bits || !pf->offset || !pf->offrot || !pf->width) {
 442         fprintf(stderr, "Error: no memory for font load\n");
 443         return 0;
 444     }
 445
 446     return 1;
 447 }
 448
 449 /* read bdf font bitmaps, return 0 on error*/
 450 int bdf_read_bitmaps(FILE *fp, struct font* pf)
 451 {
 452     long ofs = 0;
 453     long ofr = 0;
 454     int maxwidth = 0;
 455     int i, k, encoding, width;
 456     int bbw, bbh, bbx, bby;
 457     int proportional = 0;
 458     int encodetable = 0;
 459     long l;
 460     char buf[256];
 461
 462     /* reset file pointer*/
 463     fseek(fp, 0L, SEEK_SET);
 464
 465     /* initially mark offsets as not used*/
 466     for (i=0; i<pf->size; ++i)
 467         pf->offset[i] = -1;
 468
 469     for (;;) {
 470         if (!bdf_getline(fp, buf, sizeof(buf))) {
 471             fprintf(stderr, "Error: EOF on file\n");
 472             return 0;
 473         }
 474         if (isprefix(buf, "STARTCHAR")) {
 475             encoding = width = bbw = bbh = bbx = bby = -1;
 476             continue;
 477         }
 478         if (isprefix(buf, "ENCODING ")) {
 479             if (sscanf(buf, "ENCODING %d", &encoding) != 1) {
 480                 fprintf(stderr, "Error: bad 'ENCODING'\n");
 481                 return 0;
 482             }
 483             if (encoding < start_char || encoding > limit_char)
 484                 encoding = -1;
 485             continue;
 486         }
 487         if (isprefix(buf, "DWIDTH ")) {
 488             if (sscanf(buf, "DWIDTH %d", &width) != 1) {
 489                 fprintf(stderr, "Error: bad 'DWIDTH'\n");
 490                 return 0;
 491             }
 492             /* use font boundingbox width if DWIDTH <= 0*/
 493             if (width <= 0)
 494                 width = pf->fbbw - pf->fbbx;
 495             continue;
 496         }
 497         if (isprefix(buf, "BBX ")) {
 498             if (sscanf(buf, "BBX %d %d %d %d", &bbw, &bbh, &bbx, &bby) != 4) {
 499                 fprintf(stderr, "Error: bad 'BBX'\n");
 500                 return 0;
 501             }
 502             continue;
 503         }
 504         if (strequal(buf, "BITMAP")) {
 505             bitmap_t *ch_bitmap = pf->bits + ofs;
 506             int ch_words;
 507
 508             if (encoding < 0)
 509                 continue;
 510
 511             /* set bits offset in encode map*/
 512             if (pf->offset[encoding-pf->firstchar] != (unsigned long)-1) {
 513                 fprintf(stderr, "Error: duplicate encoding for character %d (0x%02x), ignoring duplicate\n",
 514                         encoding, encoding);
 515                 continue;
 516             }
 517             pf->offset[encoding-pf->firstchar] = ofs;
 518             pf->offrot[encoding-pf->firstchar] = ofr;
 519
 520             /* calc char width*/
 521             if (bbx < 0) {
 522                 width -= bbx;
 523                                 /*if (width > maxwidth)
 524                                   width = maxwidth;*/
 525                 bbx = 0;
 526             }
 527             if (width > maxwidth)
 528                 maxwidth = width;
 529             pf->width[encoding-pf->firstchar] = width;
 530
 531             /* clear bitmap*/
 532             memset(ch_bitmap, 0, BITMAP_BYTES(width) * pf->height);
 533
 534             ch_words = BITMAP_WORDS(width);
 535 #define BM(row,col)     (*(ch_bitmap + ((row)*ch_words) + (col)))
 536 #define BITMAP_NIBBLES  (BITMAP_BITSPERIMAGE/4)
 537
 538             /* read bitmaps*/
 539             for (i=0; ; ++i) {
 540                 int hexnibbles;
 541
 542                 if (!bdf_getline(fp, buf, sizeof(buf))) {
 543                     fprintf(stderr, "Error: EOF reading BITMAP data\n");
 544                     return 0;
 545                 }
 546                 if (isprefix(buf, "ENDCHAR"))
 547                     break;
 548
 549                 hexnibbles = strlen(buf);
 550                 for (k=0; k<ch_words; ++k) {
 551                     int ndx = k * BITMAP_NIBBLES;
 552                     int padnibbles = hexnibbles - ndx;
 553                     bitmap_t value;
 554
 555                     if (padnibbles <= 0)
 556                         break;
 557                     if (padnibbles >= BITMAP_NIBBLES)
 558                         padnibbles = 0;
 559
 560                     value = bdf_hexval((unsigned char *)buf,
 561                                        ndx, ndx+BITMAP_NIBBLES-1-padnibbles);
 562                     value <<= padnibbles * BITMAP_NIBBLES;
 563
 564                     BM(pf->height - pf->descent - bby - bbh + i, k) |=
 565                         value >> bbx;
 566                     /* handle overflow into next image word*/
 567                     if (bbx) {
 568                         BM(pf->height - pf->descent - bby - bbh + i, k+1) =
 569                             value << (BITMAP_BITSPERIMAGE - bbx);
 570                     }
 571                 }
 572             }
 573
 574             ofs += BITMAP_WORDS(width) * pf->height;
 575             ofr += pf->width[encoding-pf->firstchar] * ((pf->height+7)/8);
 576
 577             continue;
 578         }
 579         if (strequal(buf, "ENDFONT"))
 580             break;
 581     }
 582
 583     /* set max width*/
 584     pf->maxwidth = maxwidth;
 585
 586     /* change unused offset/width values to default char values*/
 587     for (i=0; i<pf->size; ++i) {
 588         int defchar = pf->defaultchar - pf->firstchar;
 589
 590         if (pf->offset[i] == (unsigned long)-1) {
 591             pf->offset[i] = pf->offset[defchar];
 592             pf->offrot[i] = pf->offrot[defchar];
 593             pf->width[i] = pf->width[defchar];
 594         }
 595     }
 596
 597     /* determine whether font doesn't require encode table*/
 598 #ifdef ROTATE
 599     l = 0;
 600     for (i=0; i<pf->size; ++i) {
 601         if (pf->offrot[i] != l) {
 602             encodetable = 1;
 603             break;
 604         }
 605         l += pf->maxwidth * (pf->height + 7) / 8;
 606     }
 607 #else
 608     l = 0;
 609     for (i=0; i<pf->size; ++i) {
 610         if (pf->offset[i] != l) {
 611             encodetable = 1;
 612             break;
 613         }
 614         l += BITMAP_WORDS(pf->width[i]) * pf->height;
 615     }
 616 #endif
 617     if (!encodetable) {
 618         free(pf->offset);
 619         pf->offset = NULL;
 620     }
 621
 622     /* determine whether font is fixed-width*/
 623     for (i=0; i<pf->size; ++i) {
 624         if (pf->width[i] != maxwidth) {
 625             proportional = 1;
 626             break;
 627         }
 628     }
 629     if (!proportional) {
 630         free(pf->width);
 631         pf->width = NULL;
 632     }
 633
 634     /* reallocate bits array to actual bits used*/
 635     if (ofs < pf->bits_size) {
 636         pf->bits = realloc(pf->bits, ofs * sizeof(bitmap_t));
 637         pf->bits_size = ofs;
 638     }
 639     else {
 640         if (ofs > pf->bits_size) {
 641             fprintf(stderr, "Warning: DWIDTH spec > max FONTBOUNDINGBOX\n");
 642             if (ofs > pf->bits_size+EXTRA) {
 643                 fprintf(stderr, "Error: Not enough bits initially allocated\n");
 644                 return 0;
 645             }
 646             pf->bits_size = ofs;
 647         }
 648     }
 649
 650 #ifdef ROTATE
 651     pf->bits_size = ofr; /* always update, rotated is smaller */
 652 #endif
 653
 654     return 1;
 655 }
 656
 657 /* read the next non-comment line, returns buf or NULL if EOF*/
 658 char *bdf_getline(FILE *fp, char *buf, int len)
 659 {
 660     int c;
 661     char *b;
 662
 663     for (;;) {
 664         b = buf;
 665         while ((c = getc(fp)) != EOF) {
 666             if (c == '\r')
 667                 continue;
 668             if (c == '\n')
 669                 break;
 670             if (b - buf >= (len - 1))
 671                 break;
 672             *b++ = c;
 673         }
 674         *b = '\0';
 675         if (c == EOF && b == buf)
 676             return NULL;
 677         if (b != buf && !isprefix(buf, "COMMENT"))
 678             break;
 679     }
 680     return buf;
 681 }
 682
 683 /* return hex value of portion of buffer*/
 684 bitmap_t bdf_hexval(unsigned char *buf, int ndx1, int ndx2)
 685 {
 686     bitmap_t val = 0;
 687     int i, c;
 688
 689     for (i=ndx1; i<=ndx2; ++i) {
 690         c = buf[i];
 691         if (c >= '0' && c <= '9')
 692             c -= '0';
 693         else
 694             if (c >= 'A' && c <= 'F')
 695                 c = c - 'A' + 10;
 696             else
 697                 if (c >= 'a' && c <= 'f')
 698                     c = c - 'a' + 10;
 699                 else
 700                     c = 0;
 701         val = (val << 4) | c;
 702     }
 703     return val;
 704 }
 705
 706 /*
 707  * Take an bitmap_t bitmap and convert to Rockbox format.
 708  * Used for converting font glyphs for the time being.
 709  * Can use for standard X11 and Win32 images as well.
 710  * See format description in lcd-recorder.c
 711  *
 712  * Doing it this way keeps fonts in standard formats,
 713  * as well as keeping Rockbox hw bitmap format.
 714  */
 715 int rotleft(unsigned char *dst, bitmap_t *src, unsigned int width,
 716                     unsigned int height)
 717 {
 718     unsigned int i,j;
 719     unsigned int src_words;        /* # words of input image*/
 720     unsigned int dst_mask;      /* bit mask for destination */
 721     bitmap_t src_mask;          /* bit mask for source */
 722
 723     /* calc words of input image*/
 724     src_words = BITMAP_WORDS(width) * height;
 725
 726     /* clear background*/
 727     memset(dst, 0, ((height + 7) / 8) * width);
 728
 729     dst_mask = 1;
 730
 731     for (i=0; i < src_words; i++) {
 732
 733         /* calc src input bit*/
 734         src_mask = 1 << (sizeof (bitmap_t) * 8 - 1);
 735
 736         /* for each input column...*/
 737         for(j=0; j < width; j++) {
 738
 739             /* if set in input, set in rotated output */
 740             if (src[i] & src_mask)
 741                 dst[j] |= dst_mask;
 742
 743             src_mask >>= 1;    /* next input bit */
 744             if (src_mask == 0) /* input word done? */
 745             {
 746                 src_mask = 1 << (sizeof (bitmap_t) * 8 - 1);
 747                 i++;           /* next input word */
 748             }
 749         }
 750
 751         dst_mask <<= 1;          /* next output bit (row) */
 752         if (dst_mask > (1 << 7)) /* output bit > 7? */
 753         {
 754             dst_mask = 1;
 755             dst += width;        /* next output byte row */
 756         }
 757     }
 758     return ((height + 7) / 8) * width; /* return result size in bytes */
 759 }
 760
 761
 762 /* generate C source from in-core font*/
 763 int gen_c_source(struct font* pf, char *path)
 764 {
 765     FILE *ofp;
 766     int i;
 767     int did_defaultchar = 0;
 768     int did_syncmsg = 0;
 769     time_t t = time(0);
 770     bitmap_t *ofs = pf->bits;
 771     char buf[256];
 772     char obuf[256];
 773     char hdr1[] = {
 774         "/* Generated by convbdf on %s. */\n"
 775         "#include \"font.h\"\n"
 776         "#ifdef HAVE_LCD_BITMAP\n"
 777         "\n"
 778         "/* Font information:\n"
 779         "   name: %s\n"
 780         "   facename: %s\n"
 781         "   w x h: %dx%d\n"
 782         "   size: %d\n"
 783         "   ascent: %d\n"
 784         "   descent: %d\n"
 785         "   first char: %d (0x%02x)\n"
 786         "   last char: %d (0x%02x)\n"
 787         "   default char: %d (0x%02x)\n"
 788         "   proportional: %s\n"
 789         "   %s\n"
 790         "*/\n"
 791         "\n"
 792         "/* Font character bitmap data. */\n"
 793         "static const unsigned char _font_bits[] = {\n"
 794     };
 795
 796     ofp = fopen(path, "w");
 797     if (!ofp) {
 798         fprintf(stderr, "Can't create %s\n", path);
 799         return 1;
 800     }
 801
 802     strcpy(buf, ctime(&t));
 803     buf[strlen(buf)-1] = 0;
 804
 805     fprintf(ofp, hdr1, buf,
 806             pf->name,
 807             pf->facename? pf->facename: "",
 808             pf->maxwidth, pf->height,
 809             pf->size,
 810             pf->ascent, pf->descent,
 811             pf->firstchar, pf->firstchar,
 812             pf->firstchar+pf->size-1, pf->firstchar+pf->size-1,
 813             pf->defaultchar, pf->defaultchar,
 814             pf->width? "yes": "no",
 815             pf->copyright? pf->copyright: "");
 816
 817     /* generate bitmaps*/
 818     for (i=0; i<pf->size; ++i) {
 819         int x;
 820         int bitcount = 0;
 821         int width = pf->width ? pf->width[i] : pf->maxwidth;
 822         int height = pf->height;
 823         bitmap_t *bits = pf->bits + (pf->offset? pf->offset[i]: (height * i));
 824         bitmap_t bitvalue;
 825
 826         /*
 827          * Generate bitmap bits only if not this index isn't
 828          * the default character in encode map, or the default
 829          * character hasn't been generated yet.
 830          */
 831         if (pf->offset &&
 832             (pf->offset[i] == pf->offset[pf->defaultchar-pf->firstchar])) {
 833             if (did_defaultchar)
 834                 continue;
 835             did_defaultchar = 1;
 836         }
 837
 838         fprintf(ofp, "\n/* Character %d (0x%02x):\n   width %d",
 839                 i+pf->firstchar, i+pf->firstchar, width);
 840
 841         if (gen_map) {
 842             fprintf(ofp, "\n   +");
 843             for (x=0; x<width; ++x) fprintf(ofp, "-");
 844             fprintf(ofp, "+\n");
 845
 846             x = 0;
 847             while (height > 0) {
 848                 if (x == 0) fprintf(ofp, "   |");
 849
 850                 if (bitcount <= 0) {
 851                     bitcount = BITMAP_BITSPERIMAGE;
 852                     bitvalue = *bits++;
 853                 }
 854
 855                 fprintf(ofp, BITMAP_TESTBIT(bitvalue)? "*": " ");
 856
 857                 bitvalue = BITMAP_SHIFTBIT(bitvalue);
 858                 --bitcount;
 859                 if (++x == width) {
 860                     fprintf(ofp, "|\n");
 861                     --height;
 862                     x = 0;
 863                     bitcount = 0;
 864                 }
 865             }
 866             fprintf(ofp, "   +");
 867             for (x=0; x<width; ++x)
 868                 fprintf(ofp, "-");
 869             fprintf(ofp, "+ */\n");
 870         }
 871         else
 872             fprintf(ofp, " */\n");
 873
 874         bits = pf->bits + (pf->offset? pf->offset[i]: (pf->height * i));
 875 #ifdef ROTATE /* pre-rotated into Rockbox bitmap format */
 876         {
 877           unsigned char bytemap[256];
 878           int y8, ix=0;
 879
 880           rotleft(bytemap, bits, width, pf->height);
 881           for (y8=0; y8<pf->height; y8+=8) /* column rows */
 882           {
 883             for (x=0; x<width; x++) {
 884                 fprintf(ofp, "0x%02x, ", bytemap[ix]);
 885                 ix++;
 886             }
 887             fprintf(ofp, "\n");
 888           }
 889         }
 890 #else
 891         for (x=BITMAP_WORDS(width)*pf->height; x>0; --x) {
 892             fprintf(ofp, "0x%04x,\n", *bits);
 893             if (!did_syncmsg && *bits++ != *ofs++) {
 894                 fprintf(stderr, "Warning: found encoding values in non-sorted order (not an error).\n");
 895                 did_syncmsg = 1;
 896             }
 897         }
 898 #endif
 899     }
 900     fprintf(ofp, "};\n\n");
 901
 902     if (pf->offset) {
 903         /* output offset table*/
 904         fprintf(ofp, "/* Character->glyph mapping. */\n"
 905                 "static const unsigned short _sysfont_offset[] = {\n");
 906
 907         for (i=0; i<pf->size; ++i)
 908             fprintf(ofp, "  %ld,\t/* (0x%02x) */\n",
 909 #ifdef ROTATE
 910                     pf->offrot[i], i+pf->firstchar);
 911 #else
 912                     pf->offset[i], i+pf->firstchar);
 913 #endif
 914         fprintf(ofp, "};\n\n");
 915     }
 916
 917     /* output width table for proportional fonts*/
 918     if (pf->width) {
 919         fprintf(ofp, "/* Character width data. */\n"
 920                 "static const unsigned char _sysfont_width[] = {\n");
 921
 922         for (i=0; i<pf->size; ++i)
 923             fprintf(ofp, "  %d,\t/* (0x%02x) */\n",
 924                     pf->width[i], i+pf->firstchar);
 925         fprintf(ofp, "};\n\n");
 926     }
 927
 928     /* output struct font struct*/
 929     if (pf->offset)
 930         sprintf(obuf, "_sysfont_offset,");
 931     else
 932         sprintf(obuf, "0,  /* no encode table */");
 933
 934     if (pf->width)
 935         sprintf(buf, "_sysfont_width,  /* width */");
 936     else
 937         sprintf(buf, "0,  /* fixed width */");
 938
 939     fprintf(ofp,        "/* Exported structure definition. */\n"
 940             "const struct font sysfont = {\n"
 941             "  %d,  /* maxwidth */\n"
 942             "  %d,  /* height */\n"
 943             "  %d,  /* ascent */\n"
 944             "  %d,  /* firstchar */\n"
 945             "  %d,  /* size */\n"
 946             "  _font_bits, /* bits */\n"
 947             "  %s  /* offset */\n"
 948             "  %s\n"
 949             "  %d,  /* defaultchar */\n"
 950             "};\n"
 951             "#endif /* HAVE_LCD_BITMAP */\n",
 952             pf->maxwidth, pf->height,
 953             pf->ascent,
 954             pf->firstchar,
 955             pf->size,
 956             obuf,
 957             buf,
 958             pf->defaultchar);
 959
 960     return 0;
 961 }
 962
 963 static int writebyte(FILE *fp, unsigned char c)
 964 {
 965     return putc(c, fp) != EOF;
 966 }
 967
 968 static int writeshort(FILE *fp, unsigned short s)
 969 {
 970     putc(s, fp);
 971     return putc(s>>8, fp) != EOF;
 972 }
 973
 974 static int writelong(FILE *fp, unsigned long l)
 975 {
 976     putc(l, fp);
 977     putc(l>>8, fp);
 978     putc(l>>16, fp);
 979     return putc(l>>24, fp) != EOF;
 980 }
 981
 982 static int writestr(FILE *fp, char *str, int count)
 983 {
 984     return fwrite(str, 1, count, fp) == count;
 985 }
 986
 987 static int writestrpad(FILE *fp, char *str, int totlen)
 988 {
 989     int ret;
 990
 991     while (str && *str && totlen > 0) {
 992         if (*str) {
 993             ret = putc(*str++, fp);
 994             --totlen;
 995         }
 996     }
 997     while (--totlen >= 0)
 998         ret = putc(' ', fp);
 999     return ret;
1000 }
1001
1002 /* generate .fnt format file from in-core font*/
1003 int gen_fnt_file(struct font* pf, char *path)
1004 {
1005     FILE *ofp;
1006     int i;
1007     int did_defaultchar = 0;
1008
1009     ofp = fopen(path, "wb");
1010     if (!ofp) {
1011         fprintf(stderr, "Can't create %s\n", path);
1012         return 1;
1013     }
1014
1015     /* write magic and version #*/
1016     writestr(ofp, VERSION, 4);
1017 #ifndef ROTATE
1018     /* internal font name*/
1019     writestrpad(ofp, pf->name, 64);
1020
1021     /* copyright*/
1022     writestrpad(ofp, pf->copyright, 256);
1023 #endif
1024     /* font info*/
1025     writeshort(ofp, pf->maxwidth);
1026     writeshort(ofp, pf->height);
1027     writeshort(ofp, pf->ascent);
1028     writeshort(ofp, 0);
1029     writelong(ofp, pf->firstchar);
1030     writelong(ofp, pf->defaultchar);
1031     writelong(ofp, pf->size);
1032
1033     /* variable font data sizes*/
1034     writelong(ofp, pf->bits_size);                /* # words of bitmap_t*/
1035     writelong(ofp, pf->offset? pf->size: 0);  /* # longs of offset*/
1036     writelong(ofp, pf->width? pf->size: 0);       /* # bytes of width*/
1037     /* variable font data*/
1038 #ifdef ROTATE
1039     for (i=0; i<pf->size; ++i)
1040     {
1041         bitmap_t* bits = pf->bits + (pf->offset? pf->offset[i]: (pf->height * i));
1042         int width = pf->width ? pf->width[i] : pf->maxwidth;
1043         int size;
1044         unsigned char bytemap[256];
1045
1046         if (pf->offset &&
1047             (pf->offset[i] == pf->offset[pf->defaultchar-pf->firstchar])) {
1048             if (did_defaultchar)
1049                 continue;
1050             did_defaultchar = 1;
1051         }
1052
1053         size = rotleft(bytemap, bits, width, pf->height);
1054         writestr(ofp, bytemap, size);
1055     }
1056
1057     if (ftell(ofp) & 1)
1058         writebyte(ofp, 0);              /* pad to 16-bit boundary*/
1059
1060     if (pf->offset)
1061         for (i=0; i<pf->size; ++i)
1062             writeshort(ofp, pf->offrot[i]);
1063
1064     if (pf->width)
1065         for (i=0; i<pf->size; ++i)
1066             writebyte(ofp, pf->width[i]);
1067 #else
1068     for (i=0; i<pf->bits_size; ++i)
1069         writeshort(ofp, pf->bits[i]);
1070     if (ftell(ofp) & 2)
1071         writeshort(ofp, 0);             /* pad to 32-bit boundary*/
1072
1073     if (pf->offset)
1074         for (i=0; i<pf->size; ++i)
1075             writelong(ofp, pf->offset[i]);
1076
1077     if (pf->width)
1078         for (i=0; i<pf->size; ++i)
1079             writebyte(ofp, pf->width[i]);
1080 #endif
1081     fclose(ofp);
1082     return 0;
1083 }