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 int* offset;       /* offsets into bitmap data*/
  46     unsigned char* width;       /* character widths or NULL if fixed*/
  47     int         defaultchar;    /* default char (not glyph index)*/
  48     int bits_size;      /* # words of bitmap_t bits*/
  49
  50     /* unused by runtime system, read in by convbdf*/
  51     unsigned int* 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 > lastchar)
 423         pf->defaultchar = firstchar;
 424
 425     /* calc font size (offset/width entries)*/
 426     pf->firstchar = firstchar;
 427     pf->size = lastchar - firstchar + 1;
 428
 429     /* use the font boundingbox to get initial maxwidth*/
 430     /*maxwidth = pf->fbbw - pf->fbbx;*/
 431     maxwidth = pf->fbbw;
 432
 433     /* initially use font maxwidth * height for bits allocation*/
 434     pf->bits_size = nchars * BITMAP_WORDS(maxwidth) * pf->height;
 435
 436     /* allocate bits, offset, and width arrays*/
 437     pf->bits = (bitmap_t *)malloc(pf->bits_size * sizeof(bitmap_t) + EXTRA);
 438     pf->offset = (unsigned int *)malloc(pf->size * sizeof(unsigned int));
 439     pf->offrot = (unsigned int *)malloc(pf->size * sizeof(unsigned int));
 440     pf->width = (unsigned char *)malloc(pf->size * sizeof(unsigned char));
 441
 442     if (!pf->bits || !pf->offset || !pf->offrot || !pf->width) {
 443         fprintf(stderr, "Error: no memory for font load\n");
 444         return 0;
 445     }
 446
 447     fprintf(stderr, "Header parsed\n");
 448     return 1;
 449 }
 450
 451 /* read bdf font bitmaps, return 0 on error*/
 452 int bdf_read_bitmaps(FILE *fp, struct font* pf)
 453 {
 454     int ofs = 0;
 455     int ofr = 0;
 456     int maxwidth = 0;
 457     int i, k, encoding, width;
 458     int bbw, bbh, bbx, bby;
 459     int proportional = 0;
 460     int encodetable = 0;
 461     int l;
 462     char buf[256];
 463
 464     /* reset file pointer*/
 465     fseek(fp, 0L, SEEK_SET);
 466
 467     /* initially mark offsets as not used*/
 468     for (i=0; i<pf->size; ++i)
 469         pf->offset[i] = -1;
 470
 471     for (;;) {
 472         if (!bdf_getline(fp, buf, sizeof(buf))) {
 473             fprintf(stderr, "Error: EOF on file\n");
 474             return 0;
 475         }
 476         if (isprefix(buf, "STARTCHAR")) {
 477             encoding = width = bbw = bbh = bbx = bby = -1;
 478             continue;
 479         }
 480         if (isprefix(buf, "ENCODING ")) {
 481             if (sscanf(buf, "ENCODING %d", &encoding) != 1) {
 482                 fprintf(stderr, "Error: bad 'ENCODING'\n");
 483                 return 0;
 484             }
 485             if (encoding < start_char || encoding > limit_char)
 486                 encoding = -1;
 487             continue;
 488         }
 489         if (isprefix(buf, "DWIDTH ")) {
 490             if (sscanf(buf, "DWIDTH %d", &width) != 1) {
 491                 fprintf(stderr, "Error: bad 'DWIDTH'\n");
 492                 return 0;
 493             }
 494             /* use font boundingbox width if DWIDTH <= 0*/
 495             if (width <= 0)
 496                 width = pf->fbbw - pf->fbbx;
 497             continue;
 498         }
 499         if (isprefix(buf, "BBX ")) {
 500             if (sscanf(buf, "BBX %d %d %d %d", &bbw, &bbh, &bbx, &bby) != 4) {
 501                 fprintf(stderr, "Error: bad 'BBX'\n");
 502                 return 0;
 503             }
 504             continue;
 505         }
 506         if (strequal(buf, "BITMAP")) {
 507             bitmap_t *ch_bitmap = pf->bits + ofs;
 508             int ch_words;
 509
 510             if (encoding < 0)
 511                 continue;
 512
 513             /* set bits offset in encode map*/
 514             if (pf->offset[encoding-pf->firstchar] != (unsigned int)-1) {
 515                 fprintf(stderr, "Error: duplicate encoding for character %d (0x%02x), ignoring duplicate\n",
 516                         encoding, encoding);
 517                 continue;
 518             }
 519             pf->offset[encoding-pf->firstchar] = ofs;
 520             pf->offrot[encoding-pf->firstchar] = ofr;
 521
 522             /* calc char width*/
 523             if (bbx < 0) {
 524                 width -= bbx;
 525                                 /*if (width > maxwidth)
 526                                   width = maxwidth;*/
 527                 bbx = 0;
 528             }
 529             if (width > maxwidth)
 530                 maxwidth = width;
 531             pf->width[encoding-pf->firstchar] = width;
 532
 533             /* clear bitmap*/
 534             memset(ch_bitmap, 0, BITMAP_BYTES(width) * pf->height);
 535
 536             ch_words = BITMAP_WORDS(width);
 537 #define BM(row,col)     (*(ch_bitmap + ((row)*ch_words) + (col)))
 538 #define BITMAP_NIBBLES  (BITMAP_BITSPERIMAGE/4)
 539
 540             /* read bitmaps*/
 541             for (i=0; ; ++i) {
 542                 int hexnibbles;
 543
 544                 if (!bdf_getline(fp, buf, sizeof(buf))) {
 545                     fprintf(stderr, "Error: EOF reading BITMAP data\n");
 546                     return 0;
 547                 }
 548                 if (isprefix(buf, "ENDCHAR"))
 549                     break;
 550
 551                 hexnibbles = strlen(buf);
 552                 for (k=0; k<ch_words; ++k) {
 553                     int ndx = k * BITMAP_NIBBLES;
 554                     int padnibbles = hexnibbles - ndx;
 555                     bitmap_t value;
 556
 557                     if (padnibbles <= 0)
 558                         break;
 559                     if (padnibbles >= BITMAP_NIBBLES)
 560                         padnibbles = 0;
 561
 562                     value = bdf_hexval((unsigned char *)buf,
 563                                        ndx, ndx+BITMAP_NIBBLES-1-padnibbles);
 564                     value <<= padnibbles * BITMAP_NIBBLES;
 565
 566                     BM(pf->height - pf->descent - bby - bbh + i, k) |=
 567                         value >> bbx;
 568                     /* handle overflow into next image word*/
 569                     if (bbx) {
 570                         BM(pf->height - pf->descent - bby - bbh + i, k+1) =
 571                             value << (BITMAP_BITSPERIMAGE - bbx);
 572                     }
 573                 }
 574             }
 575
 576             ofs += BITMAP_WORDS(width) * pf->height;
 577             ofr += pf->width[encoding-pf->firstchar] * ((pf->height+7)/8);
 578
 579             continue;
 580         }
 581         if (strequal(buf, "ENDFONT"))
 582             break;
 583     }
 584
 585     /* set max width*/
 586     pf->maxwidth = maxwidth;
 587
 588     /* change unused offset/width values to default char values*/
 589     for (i=0; i<pf->size; ++i) {
 590         int defchar = pf->defaultchar - pf->firstchar;
 591
 592         if (pf->offset[i] == (unsigned int)-1) {
 593             pf->offset[i] = pf->offset[defchar];
 594             pf->offrot[i] = pf->offrot[defchar];
 595             pf->width[i] = pf->width[defchar];
 596         }
 597     }
 598
 599     /* determine whether font doesn't require encode table*/
 600 #ifdef ROTATE
 601     l = 0;
 602     for (i=0; i<pf->size; ++i) {
 603         if (pf->offrot[i] != l) {
 604             encodetable = 1;
 605             break;
 606         }
 607         l += pf->maxwidth * ((pf->height + 7) / 8);
 608     }
 609 #else
 610     l = 0;
 611     for (i=0; i<pf->size; ++i) {
 612         if (pf->offset[i] != l) {
 613             encodetable = 1;
 614             break;
 615         }
 616         l += BITMAP_WORDS(pf->width[i]) * pf->height;
 617     }
 618 #endif
 619     if (!encodetable) {
 620         free(pf->offset);
 621         pf->offset = NULL;
 622     }
 623
 624     /* determine whether font is fixed-width*/
 625     for (i=0; i<pf->size; ++i) {
 626         if (pf->width[i] != maxwidth) {
 627             proportional = 1;
 628             break;
 629         }
 630     }
 631     if (!proportional) {
 632         free(pf->width);
 633         pf->width = NULL;
 634     }
 635
 636     /* reallocate bits array to actual bits used*/
 637     if (ofs < pf->bits_size) {
 638         pf->bits = realloc(pf->bits, ofs * sizeof(bitmap_t));
 639         pf->bits_size = ofs;
 640     }
 641     else {
 642         if (ofs > pf->bits_size) {
 643             fprintf(stderr, "Warning: DWIDTH spec > max FONTBOUNDINGBOX\n");
 644             if (ofs > pf->bits_size+EXTRA) {
 645                 fprintf(stderr, "Error: Not enough bits initially allocated\n");
 646                 return 0;
 647             }
 648             pf->bits_size = ofs;
 649         }
 650     }
 651
 652 #ifdef ROTATE
 653     pf->bits_size = ofr; /* always update, rotated is smaller */
 654 #endif
 655
 656     return 1;
 657 }
 658
 659 /* read the next non-comment line, returns buf or NULL if EOF*/
 660 char *bdf_getline(FILE *fp, char *buf, int len)
 661 {
 662     int c;
 663     char *b;
 664
 665     for (;;) {
 666         b = buf;
 667         while ((c = getc(fp)) != EOF) {
 668             if (c == '\r')
 669                 continue;
 670             if (c == '\n')
 671                 break;
 672             if (b - buf >= (len - 1))
 673                 break;
 674             *b++ = c;
 675         }
 676         *b = '\0';
 677         if (c == EOF && b == buf)
 678             return NULL;
 679         if (b != buf && !isprefix(buf, "COMMENT"))
 680             break;
 681     }
 682     return buf;
 683 }
 684
 685 /* return hex value of portion of buffer*/
 686 bitmap_t bdf_hexval(unsigned char *buf, int ndx1, int ndx2)
 687 {
 688     bitmap_t val = 0;
 689     int i, c;
 690
 691     for (i=ndx1; i<=ndx2; ++i) {
 692         c = buf[i];
 693         if (c >= '0' && c <= '9')
 694             c -= '0';
 695         else
 696             if (c >= 'A' && c <= 'F')
 697                 c = c - 'A' + 10;
 698             else
 699                 if (c >= 'a' && c <= 'f')
 700                     c = c - 'a' + 10;
 701                 else
 702                     c = 0;
 703         val = (val << 4) | c;
 704     }
 705     return val;
 706 }
 707
 708 /*
 709  * Take an bitmap_t bitmap and convert to Rockbox format.
 710  * Used for converting font glyphs for the time being.
 711  * Can use for standard X11 and Win32 images as well.
 712  * See format description in lcd-recorder.c
 713  *
 714  * Doing it this way keeps fonts in standard formats,
 715  * as well as keeping Rockbox hw bitmap format.
 716  */
 717 int rotleft(unsigned char *dst, bitmap_t *src, unsigned int width,
 718                     unsigned int height)
 719 {
 720     unsigned int i,j;
 721     unsigned int src_words;        /* # words of input image*/
 722     unsigned int dst_mask;      /* bit mask for destination */
 723     bitmap_t src_mask;          /* bit mask for source */
 724
 725     /* calc words of input image*/
 726     src_words = BITMAP_WORDS(width) * height;
 727
 728     /* clear background*/
 729     memset(dst, 0, ((height + 7) / 8) * width);
 730
 731     dst_mask = 1;
 732
 733     for (i=0; i < src_words; i++) {
 734
 735         /* calc src input bit*/
 736         src_mask = 1 << (sizeof (bitmap_t) * 8 - 1);
 737
 738         /* for each input column...*/
 739         for(j=0; j < width; j++) {
 740
 741             if (src_mask == 0) /* input word done? */
 742             {
 743                 src_mask = 1 << (sizeof (bitmap_t) * 8 - 1);
 744                 i++;    /* next input word */
 745             }
 746
 747             /* if set in input, set in rotated output */
 748             if (src[i] & src_mask)
 749                 dst[j] |= dst_mask;
 750
 751             src_mask >>= 1;    /* next input bit */
 752         }
 753
 754         dst_mask <<= 1;          /* next output bit (row) */
 755         if (dst_mask > (1 << 7)) /* output bit > 7? */
 756         {
 757             dst_mask = 1;
 758             dst += width;        /* next output byte row */
 759         }
 760     }
 761     return ((height + 7) / 8) * width; /* return result size in bytes */
 762 }
 763
 764
 765 /* generate C source from in-core font*/
 766 int gen_c_source(struct font* pf, char *path)
 767 {
 768     FILE *ofp;
 769     int i, ofr = 0;
 770     int did_defaultchar = 0;
 771     int did_syncmsg = 0;
 772     time_t t = time(0);
 773     bitmap_t *ofs = pf->bits;
 774     char buf[256];
 775     char obuf[256];
 776     char hdr1[] = {
 777         "/* Generated by convbdf on %s. */\n"
 778         "#include \"font.h\"\n"
 779         "#ifdef HAVE_LCD_BITMAP\n"
 780         "\n"
 781         "/* Font information:\n"
 782         "   name: %s\n"
 783         "   facename: %s\n"
 784         "   w x h: %dx%d\n"
 785         "   size: %d\n"
 786         "   ascent: %d\n"
 787         "   descent: %d\n"
 788         "   first char: %d (0x%02x)\n"
 789         "   last char: %d (0x%02x)\n"
 790         "   default char: %d (0x%02x)\n"
 791         "   proportional: %s\n"
 792         "   %s\n"
 793         "*/\n"
 794         "\n"
 795         "/* Font character bitmap data. */\n"
 796         "static const unsigned char _font_bits[] = {\n"
 797     };
 798
 799     ofp = fopen(path, "w");
 800     if (!ofp) {
 801         fprintf(stderr, "Can't create %s\n", path);
 802         return 1;
 803     }
 804
 805     strcpy(buf, ctime(&t));
 806     buf[strlen(buf)-1] = 0;
 807
 808     fprintf(ofp, hdr1, buf,
 809             pf->name,
 810             pf->facename? pf->facename: "",
 811             pf->maxwidth, pf->height,
 812             pf->size,
 813             pf->ascent, pf->descent,
 814             pf->firstchar, pf->firstchar,
 815             pf->firstchar+pf->size-1, pf->firstchar+pf->size-1,
 816             pf->defaultchar, pf->defaultchar,
 817             pf->width? "yes": "no",
 818             pf->copyright? pf->copyright: "");
 819
 820     /* generate bitmaps*/
 821     for (i=0; i<pf->size; ++i) {
 822         int x;
 823         int bitcount = 0;
 824         int width = pf->width ? pf->width[i] : pf->maxwidth;
 825         int height = pf->height;
 826         bitmap_t *bits = pf->bits + (pf->offset? pf->offset[i]: (height * i));
 827         bitmap_t bitvalue;
 828
 829         /*
 830          * Generate bitmap bits only if not this index isn't
 831          * the default character in encode map, or the default
 832          * character hasn't been generated yet.
 833          */
 834         if (pf->offset &&
 835             (pf->offset[i] == pf->offset[pf->defaultchar-pf->firstchar])) {
 836             if (did_defaultchar) {
 837                 pf->offrot[i] = pf->offrot[pf->defaultchar-pf->firstchar];
 838                 continue;
 839             }
 840             did_defaultchar = 1;
 841         }
 842
 843         fprintf(ofp, "\n/* Character %d (0x%02x):\n   width %d",
 844                 i+pf->firstchar, i+pf->firstchar, width);
 845
 846         if (gen_map) {
 847             fprintf(ofp, "\n   +");
 848             for (x=0; x<width; ++x) fprintf(ofp, "-");
 849             fprintf(ofp, "+\n");
 850
 851             x = 0;
 852             while (height > 0) {
 853                 if (x == 0) fprintf(ofp, "   |");
 854
 855                 if (bitcount <= 0) {
 856                     bitcount = BITMAP_BITSPERIMAGE;
 857                     bitvalue = *bits++;
 858                 }
 859
 860                 fprintf(ofp, BITMAP_TESTBIT(bitvalue)? "*": " ");
 861
 862                 bitvalue = BITMAP_SHIFTBIT(bitvalue);
 863                 --bitcount;
 864                 if (++x == width) {
 865                     fprintf(ofp, "|\n");
 866                     --height;
 867                     x = 0;
 868                     bitcount = 0;
 869                 }
 870             }
 871             fprintf(ofp, "   +");
 872             for (x=0; x<width; ++x)
 873                 fprintf(ofp, "-");
 874             fprintf(ofp, "+ */\n");
 875         }
 876         else
 877             fprintf(ofp, " */\n");
 878
 879         bits = pf->bits + (pf->offset? pf->offset[i]: (pf->height * i));
 880 #ifdef ROTATE /* pre-rotated into Rockbox bitmap format */
 881         {
 882           unsigned char bytemap[256];
 883           int y8, ix=0;
 884
 885           int size = rotleft(bytemap, bits, width, pf->height);
 886           for (y8=0; y8<pf->height; y8+=8) /* column rows */
 887           {
 888             for (x=0; x<width; x++) {
 889                 fprintf(ofp, "0x%02x, ", bytemap[ix]);
 890                 ix++;
 891             }
 892             fprintf(ofp, "\n");
 893           }
 894
 895         /* update offrot since bits are now in sorted order */
 896         pf->offrot[i] = ofr;
 897         ofr += size;
 898
 899         }
 900 #else
 901         for (x=BITMAP_WORDS(width)*pf->height; x>0; --x) {
 902             fprintf(ofp, "0x%04x,\n", *bits);
 903             if (!did_syncmsg && *bits++ != *ofs++) {
 904                 fprintf(stderr, "Warning: found encoding values in non-sorted order (not an error).\n");
 905                 did_syncmsg = 1;
 906             }
 907         }
 908 #endif
 909     }
 910     fprintf(ofp, "};\n\n");
 911
 912     if (pf->offset) {
 913         /* output offset table*/
 914         fprintf(ofp, "/* Character->glyph mapping. */\n"
 915                 "static const unsigned short _sysfont_offset[] = {\n");
 916
 917         for (i=0; i<pf->size; ++i)
 918             fprintf(ofp, "  %ld,\t/* (0x%02x) */\n",
 919 #ifdef ROTATE
 920                     pf->offrot[i], i+pf->firstchar);
 921 #else
 922                     pf->offset[i], i+pf->firstchar);
 923 #endif
 924         fprintf(ofp, "};\n\n");
 925     }
 926
 927     /* output width table for proportional fonts*/
 928     if (pf->width) {
 929         fprintf(ofp, "/* Character width data. */\n"
 930                 "static const unsigned char _sysfont_width[] = {\n");
 931
 932         for (i=0; i<pf->size; ++i)
 933             fprintf(ofp, "  %d,\t/* (0x%02x) */\n",
 934                     pf->width[i], i+pf->firstchar);
 935         fprintf(ofp, "};\n\n");
 936     }
 937
 938     /* output struct font struct*/
 939     if (pf->offset)
 940         sprintf(obuf, "_sysfont_offset,");
 941     else
 942         sprintf(obuf, "0,  /* no encode table */");
 943
 944     if (pf->width)
 945         sprintf(buf, "_sysfont_width,  /* width */");
 946     else
 947         sprintf(buf, "0,  /* fixed width */");
 948
 949     fprintf(ofp,        "/* Exported structure definition. */\n"
 950             "const struct font sysfont = {\n"
 951             "  %d,  /* maxwidth */\n"
 952             "  %d,  /* height */\n"
 953             "  %d,  /* ascent */\n"
 954             "  %d,  /* firstchar */\n"
 955             "  %d,  /* size */\n"
 956             "  _font_bits, /* bits */\n"
 957             "  %s  /* offset */\n"
 958             "  %s\n"
 959             "  %d,  /* defaultchar */\n"
 960             "  %d   /* bits_size */\n"
 961             "};\n"
 962             "#endif /* HAVE_LCD_BITMAP */\n",
 963             pf->maxwidth, pf->height,
 964             pf->ascent,
 965             pf->firstchar,
 966             pf->size,
 967             obuf,
 968             buf,
 969             pf->defaultchar,
 970             pf->bits_size);
 971
 972     return 0;
 973 }
 974
 975 static int writebyte(FILE *fp, unsigned char c)
 976 {
 977     return putc(c, fp) != EOF;
 978 }
 979
 980 static int writeshort(FILE *fp, unsigned short s)
 981 {
 982     putc(s, fp);
 983     return putc(s>>8, fp) != EOF;
 984 }
 985
 986 static int writeint(FILE *fp, unsigned int l)
 987 {
 988     putc(l, fp);
 989     putc(l>>8, fp);
 990     putc(l>>16, fp);
 991     return putc(l>>24, fp) != EOF;
 992 }
 993
 994 static int writestr(FILE *fp, char *str, int count)
 995 {
 996     return fwrite(str, 1, count, fp) == count;
 997 }
 998
 999 static int writestrpad(FILE *fp, char *str, int totlen)
1000 {
1001     int ret;
1002
1003     while (str && *str && totlen > 0) {
1004         if (*str) {
1005             ret = putc(*str++, fp);
1006             --totlen;
1007         }
1008     }
1009     while (--totlen >= 0)
1010         ret = putc(' ', fp);
1011     return ret;
1012 }
1013
1014 /* generate .fnt format file from in-core font*/
1015 int gen_fnt_file(struct font* pf, char *path)
1016 {
1017     FILE *ofp;
1018     int i;
1019     int did_defaultchar = 0;
1020 #ifdef ROTATE
1021     int ofr = 0;
1022 #endif
1023
1024     ofp = fopen(path, "wb");
1025     if (!ofp) {
1026         fprintf(stderr, "Can't create %s\n", path);
1027         return 1;
1028     }
1029
1030     /* write magic and version #*/
1031     writestr(ofp, VERSION, 4);
1032 #ifndef ROTATE
1033     /* internal font name*/
1034     writestrpad(ofp, pf->name, 64);
1035
1036     /* copyright*/
1037     writestrpad(ofp, pf->copyright, 256);
1038 #endif
1039     /* font info*/
1040     writeshort(ofp, pf->maxwidth);
1041     writeshort(ofp, pf->height);
1042     writeshort(ofp, pf->ascent);
1043     writeshort(ofp, 0);
1044     writeint(ofp, pf->firstchar);
1045     writeint(ofp, pf->defaultchar);
1046     writeint(ofp, pf->size);
1047
1048     /* variable font data sizes*/
1049     writeint(ofp, pf->bits_size);                 /* # words of bitmap_t*/
1050     writeint(ofp, pf->offset? pf->size: 0);  /* # ints of offset*/
1051     writeint(ofp, pf->width? pf->size: 0);        /* # bytes of width*/
1052     /* variable font data*/
1053 #ifdef ROTATE
1054     for (i=0; i<pf->size; ++i)
1055     {
1056         bitmap_t* bits = pf->bits + (pf->offset? pf->offset[i]: (pf->height * i));
1057         int width = pf->width ? pf->width[i] : pf->maxwidth;
1058         int size;
1059         unsigned char bytemap[256];
1060
1061         if (pf->offset &&
1062             (pf->offset[i] == pf->offset[pf->defaultchar-pf->firstchar])) {
1063             if (did_defaultchar) {
1064                 pf->offrot[i] = pf->offrot[pf->defaultchar-pf->firstchar];
1065                 continue;
1066             }
1067             did_defaultchar = 1;
1068         }
1069
1070         size = rotleft(bytemap, bits, width, pf->height);
1071         writestr(ofp, (char *)bytemap, size);
1072
1073         /* update offrot since bits are now in sorted order */
1074         pf->offrot[i] = ofr;
1075         ofr += size;
1076     }
1077
1078     if ( pf->bits_size < 0xFFDB )
1079     {
1080         /* bitmap offset is small enough, use unsigned short for offset */
1081         if (ftell(ofp) & 1)
1082             writebyte(ofp, 0);          /* pad to 16-bit boundary*/
1083     }
1084     else
1085     {
1086         /* bitmap offset is large then 64K, use unsigned int for offset */
1087         while (ftell(ofp) & 3)
1088             writebyte(ofp, 0);          /* pad to 32-bit boundary*/
1089     }
1090
1091     if (pf->offset)
1092     {
1093         for (i=0; i<pf->size; ++i)
1094         {
1095             if ( pf->bits_size < 0xFFDB )
1096                 writeshort(ofp, pf->offrot[i]);
1097             else
1098                 writeint(ofp, pf->offrot[i]);
1099         }
1100     }
1101
1102     if (pf->width)
1103         for (i=0; i<pf->size; ++i)
1104             writebyte(ofp, pf->width[i]);
1105 #else
1106     for (i=0; i<pf->bits_size; ++i)
1107         writeshort(ofp, pf->bits[i]);
1108     if (ftell(ofp) & 2)
1109         writeshort(ofp, 0);             /* pad to 32-bit boundary*/
1110
1111     if (pf->offset)
1112         for (i=0; i<pf->size; ++i)
1113             writeint(ofp, pf->offset[i]);
1114
1115     if (pf->width)
1116         for (i=0; i<pf->size; ++i)
1117             writebyte(ofp, pf->width[i]);
1118 #endif
1119     fclose(ofp);
1120     return 0;
1121 }