Index: uspace/lib/draw/Makefile =================================================================== --- uspace/lib/draw/Makefile (revision 794e368715ec380ebe888af673c8db3fae585d9f) +++ uspace/lib/draw/Makefile (revision 8d3512f119e2a44f134b45bad386692c49984b5b) @@ -38,4 +38,5 @@ font/embedded.c \ font/bitmap_backend.c \ + font/pcf.c \ gfx/font-8x16.c \ gfx/cursor-11x18.c \ Index: uspace/lib/draw/font/pcf.c =================================================================== --- uspace/lib/draw/font/pcf.c (revision 8d3512f119e2a44f134b45bad386692c49984b5b) +++ uspace/lib/draw/font/pcf.c (revision 8d3512f119e2a44f134b45bad386692c49984b5b) @@ -0,0 +1,628 @@ +/* + * Copyright (c) 2014 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup draw + * @{ + */ +/** + * @file + */ + +#include +#include +#include +#include +#include +#include + +#include "pcf.h" +#include "../drawctx.h" +#include "bitmap_backend.h" + +#define PCF_TABLE_ACCELERATORS 0x02 +#define PCF_TABLE_METRICS 0x04 +#define PCF_TABLE_BITMAPS 0x08 +#define PCF_TABLE_INK_METRICS 0x10 +#define PCF_TABLE_ENCODINGS 0x20 + +#define PCF_FORMAT_DEFAULT 0x00000000 +#define PCF_FORMAT_MASK 0xffffff00 +#define PCF_FORMAT_MSBYTE_FIRST 0x00000004 +#define PCF_FORMAT_MSBIT_FIRST 0x00000008 +#define PCF_FORMAT_COMPRESSED_METRICS 0x00000100 + +typedef struct { + uint32_t type; + uint32_t format; + uint32_t size; /* in bytes */ + uint32_t offset; /* in bytes from beginning of file */ +} __attribute__((__packed__)) pcf_toc_entry_t; + +typedef struct { + uint16_t min_byte2; + uint16_t max_byte2; + uint16_t min_byte1; + uint16_t max_byte1; + uint16_t default_char; +} __attribute__((__packed__)) pcf_encoding_t; + +typedef struct { + uint8_t left_side_bearing; + uint8_t right_side_bearing; + uint8_t character_width; + uint8_t character_ascent; + uint8_t character_descent; +} __attribute__((__packed__)) pcf_compressed_metrics_t; + +typedef struct { + int16_t left_side_bearing; + int16_t right_side_bearing; + int16_t character_width; + int16_t character_ascent; + int16_t character_descent; + uint16_t character_attributes; +} __attribute__((__packed__)) pcf_default_metrics_t; + +typedef struct { + uint8_t unused_font_information[8]; + int32_t font_ascent; + int32_t font_descent; +} __attribute__((__packed__)) pcf_accelerators_t; + +typedef struct { + FILE *file; + uint32_t glyph_count; + pcf_toc_entry_t bitmap_table; + pcf_toc_entry_t metrics_table; + pcf_toc_entry_t encodings_table; + pcf_toc_entry_t accelerators_table; + pcf_encoding_t encoding; + font_metrics_t font_metrics; +} pcf_data_t; + +static inline uint32_t uint32_t_pcf2host(uint32_t val, uint32_t format) +{ + if (format & PCF_FORMAT_MSBYTE_FIRST) { + return uint32_t_be2host(val); + } + else { + return uint32_t_le2host(val); + } +} + +static inline uint16_t uint16_t_pcf2host(uint16_t val, uint32_t format) +{ + if (format & PCF_FORMAT_MSBYTE_FIRST) { + return uint16_t_be2host(val); + } + else { + return uint16_t_le2host(val); + } +} + +static inline int16_t int16_t_pcf2host(int16_t val, uint32_t format) +{ + return (int16_t) uint16_t_pcf2host((uint16_t) val, format); +} + +static inline int32_t int32_t_pcf2host(int32_t val, uint32_t format) +{ + return (int32_t) uint32_t_pcf2host((uint32_t) val, format); +} + + +static int16_t compressed2int(uint8_t compressed) +{ + int16_t ret = compressed; + ret -= 0x80; + return ret; +} + +static int pcf_resolve_glyph(void *opaque_data, const wchar_t chr, + glyph_id_t *glyph_id) +{ + pcf_data_t *data = (pcf_data_t *) opaque_data; + + /* TODO is this correct? */ + uint8_t byte1 = (chr >> 8) & 0xff; + uint8_t byte2 = chr & 0xff; + pcf_encoding_t *e = &data->encoding; + + aoff64_t entry_index = + (byte1 - e->min_byte1) * (e->max_byte2 - e->min_byte2 + 1) + + (byte2 - e->min_byte2); + + aoff64_t entry_offset = data->encodings_table.offset + + (sizeof(uint32_t) + 5 * sizeof(uint16_t)) + + entry_index * sizeof(uint16_t); + + int rc = fseek(data->file, entry_offset, SEEK_SET); + if (rc != 0) + return errno; + + uint16_t glyph = 0; + size_t records_read = fread(&glyph, sizeof(uint16_t), 1, data->file); + if (records_read != 1) + return EINVAL; + + glyph = uint16_t_pcf2host(glyph, data->encodings_table.format); + + if (glyph == 0xffff) + return ENOENT; + + *glyph_id = glyph; + + return EOK; +} + +static int load_glyph_metrics(pcf_data_t *data, uint32_t glyph_id, + pcf_toc_entry_t *table, pcf_default_metrics_t *metrics) +{ + aoff64_t offset; + int rc; + size_t records_read; + + if (table->format & PCF_FORMAT_COMPRESSED_METRICS) { + offset = table->offset + sizeof(uint32_t) + sizeof(uint16_t) + + glyph_id * sizeof(pcf_compressed_metrics_t); + + rc = fseek(data->file, offset, SEEK_SET); + if (rc != 0) + return errno; + + pcf_compressed_metrics_t compressed_metrics; + records_read = fread(&compressed_metrics, + sizeof(pcf_compressed_metrics_t), 1,data->file); + if (records_read != 1) + return EINVAL; + + metrics->left_side_bearing = + compressed2int(compressed_metrics.left_side_bearing); + metrics->right_side_bearing = + compressed2int(compressed_metrics.right_side_bearing); + metrics->character_width = + compressed2int(compressed_metrics.character_width); + metrics->character_ascent = + compressed2int(compressed_metrics.character_ascent); + metrics->character_descent = + compressed2int(compressed_metrics.character_descent); + metrics->character_attributes = 0; + } + else { + offset = table->offset + 2 * sizeof(uint32_t) + + glyph_id * sizeof(pcf_default_metrics_t); + + rc = fseek(data->file, offset, SEEK_SET); + if (rc != 0) + return errno; + + pcf_default_metrics_t uncompressed_metrics; + records_read = fread(&uncompressed_metrics, + sizeof(pcf_default_metrics_t), 1,data->file); + if (records_read != 1) + return EINVAL; + + metrics->left_side_bearing = + int16_t_pcf2host(uncompressed_metrics.left_side_bearing, + table->format); + metrics->right_side_bearing = + int16_t_pcf2host(uncompressed_metrics.right_side_bearing, + table->format); + metrics->character_width = + int16_t_pcf2host(uncompressed_metrics.character_width, + table->format); + metrics->character_ascent = + int16_t_pcf2host(uncompressed_metrics.character_ascent, + table->format); + metrics->character_descent = + int16_t_pcf2host(uncompressed_metrics.character_descent, + table->format); + metrics->character_attributes = + uint16_t_pcf2host(uncompressed_metrics.character_attributes, + table->format); + } + + return EOK; +} + +static int pcf_load_glyph_surface(void *opaque_data, glyph_id_t glyph_id, + surface_t **out_surface) +{ + pcf_data_t *data = (pcf_data_t *) opaque_data; + + pcf_default_metrics_t pcf_metrics; + memset(&pcf_metrics, 0, sizeof(pcf_default_metrics_t)); + int rc = load_glyph_metrics(data, glyph_id, &data->metrics_table, + &pcf_metrics); + if (rc != EOK) + return rc; + + aoff64_t offset = data->bitmap_table.offset + (2 * sizeof(uint32_t)) + + (glyph_id * sizeof(uint32_t)); + + rc = fseek(data->file, offset, SEEK_SET); + if (rc != 0) + return errno; + + uint32_t bitmap_offset = 0; + size_t records_read = fread(&bitmap_offset, sizeof(uint32_t), 1, + data->file); + if (records_read != 1) + return EINVAL; + bitmap_offset = uint32_t_pcf2host(bitmap_offset, + data->bitmap_table.format); + + offset = data->bitmap_table.offset + (2 * sizeof(uint32_t)) + + (data->glyph_count * sizeof(uint32_t)) + (4 * sizeof(uint32_t)) + + bitmap_offset; + + rc = fseek(data->file, offset, SEEK_SET); + if (rc != 0) + return errno; + + surface_coord_t width = pcf_metrics.character_width; + surface_coord_t height = pcf_metrics.character_ascent + + pcf_metrics.character_descent; + size_t row_padding_bytes = (1 << (data->bitmap_table.format & 3)); + size_t word_size_bytes = (1 << ((data->bitmap_table.format >> 4) & 3)); + size_t row_bytes = ALIGN_UP(ALIGN_UP(width, 8) / 8, row_padding_bytes); + size_t bitmap_bytes = height * row_bytes; + + uint8_t *bitmap = malloc(bitmap_bytes); + if (bitmap == NULL) + return ENOMEM; + + records_read = fread(bitmap, sizeof(uint8_t), bitmap_bytes, + data->file); + + surface_t *surface = surface_create(width, height, NULL, 0); + if (!surface) { + free(bitmap); + return ENOMEM; + } + + for (unsigned int y = 0; y < height; ++y) { + size_t row_offset = row_bytes * y; + for (unsigned int x = 0; x < width; ++x) { + size_t word_index = x / (word_size_bytes * 8); + size_t column_offset1 = word_index * word_size_bytes; + size_t byte_index_within_word = + (x % (word_size_bytes * 8)) / 8; + size_t column_offset2; + if (data->bitmap_table.format & PCF_FORMAT_MSBYTE_FIRST) { + column_offset2 = (word_size_bytes - 1) - byte_index_within_word; + } + else { + column_offset2 = byte_index_within_word; + } + uint8_t b = bitmap[row_offset + column_offset1 + column_offset2]; + bool set; + if (data->bitmap_table.format & PCF_FORMAT_MSBIT_FIRST) { + set = (b >> (7 - (x % 8))) & 1; + } + else { + set = (b >> (x % 8)) & 1; + } + pixel_t p = set ? PIXEL(255, 0, 0, 0) : PIXEL(0, 0, 0, 0); + surface_put_pixel(surface, x, y, p); + } + } + + *out_surface = surface; + free(bitmap); + return EOK; +} + +static int pcf_load_glyph_metrics(void *opaque_data, glyph_id_t glyph_id, + glyph_metrics_t *gm) +{ + pcf_data_t *data = (pcf_data_t *) opaque_data; + + pcf_default_metrics_t pcf_metrics; + memset(&pcf_metrics, 0, sizeof(pcf_default_metrics_t)); + int rc = load_glyph_metrics(data, glyph_id, &data->metrics_table, + &pcf_metrics); + if (rc != EOK) + return rc; + + gm->left_side_bearing = pcf_metrics.left_side_bearing; + gm->width = pcf_metrics.character_width; + gm->right_side_bearing = pcf_metrics.right_side_bearing - + pcf_metrics.character_width; + gm->height = pcf_metrics.character_descent + + pcf_metrics.character_ascent; + gm->ascender = pcf_metrics.character_ascent; + + return EOK; +} + +static void pcf_release(void *opaque_data) +{ + pcf_data_t *data = (pcf_data_t *) opaque_data; + + fclose(data->file); + free(data); +} + +bitmap_font_decoder_t fd_pcf = { + .resolve_glyph = pcf_resolve_glyph, + .load_glyph_surface = pcf_load_glyph_surface, + .load_glyph_metrics = pcf_load_glyph_metrics, + .release = pcf_release +}; + +static int pcf_read_toc(pcf_data_t *data) +{ + int rc = fseek(data->file, 0, SEEK_END); + if (rc != 0) + return errno; + + aoff64_t file_size = ftell(data->file); + + rc = fseek(data->file, 0, SEEK_SET); + if (rc != 0) + return errno; + + char header[4]; + size_t records_read = fread(header, sizeof(char), 4, data->file); + if (records_read != 4) + return EINVAL; + + if (header[0] != 1 || header[1] != 'f' || header[2] != 'c' || + header[3] != 'p') + return EINVAL; + + uint32_t table_count; + records_read = fread(&table_count, sizeof(uint32_t), 1, + data->file); + if (records_read != 1) + return EINVAL; + + table_count = uint32_t_le2host(table_count); + + bool found_bitmap_table = false; + bool found_metrics_table = false; + bool found_encodings_table = false; + bool found_accelerators_table = false; + + for (uint32_t index = 0; index < table_count; index++) { + pcf_toc_entry_t toc_entry; + records_read = fread(&toc_entry, sizeof(pcf_toc_entry_t), 1, + data->file); + toc_entry.type = uint32_t_le2host(toc_entry.type); + toc_entry.format = uint32_t_le2host(toc_entry.format); + toc_entry.size = uint32_t_le2host(toc_entry.size); + toc_entry.offset = uint32_t_le2host(toc_entry.offset); + + if (toc_entry.offset >= file_size) + continue; + + aoff64_t end = ((aoff64_t) toc_entry.offset) + ((aoff64_t) toc_entry.size); + if (end > file_size) + continue; + + if (toc_entry.type == PCF_TABLE_BITMAPS) { + if (found_bitmap_table) + return EINVAL; + found_bitmap_table = true; + data->bitmap_table = toc_entry; + } + else if (toc_entry.type == PCF_TABLE_METRICS) { + if (found_metrics_table) + return EINVAL; + found_metrics_table = true; + data->metrics_table = toc_entry; + } + else if (toc_entry.type == PCF_TABLE_ENCODINGS) { + if (found_encodings_table) + return EINVAL; + found_encodings_table = true; + data->encodings_table = toc_entry; + } + else if (toc_entry.type == PCF_TABLE_ACCELERATORS) { + if (found_accelerators_table) + return EINVAL; + found_accelerators_table = true; + data->accelerators_table = toc_entry; + } + } + + if (!found_bitmap_table || !found_metrics_table || + !found_encodings_table || !found_accelerators_table) + return EINVAL; + + return EOK; +} + +static int pcf_seek_table_header(pcf_data_t *data, pcf_toc_entry_t *table) +{ + uint32_t format; + int rc = fseek(data->file, table->offset, SEEK_SET); + if (rc != 0) + return errno; + + size_t records_read = fread(&format, sizeof(uint32_t), 1, data->file); + if (records_read != 1) + return EINVAL; + + format = uint32_t_le2host(format); + if (format != table->format) + return EINVAL; + + return EOK; +} + +static int pcf_read_bitmap_table_header(pcf_data_t *data) +{ + int rc = pcf_seek_table_header(data, &data->bitmap_table); + if (rc != EOK) + return rc; + + if ((data->bitmap_table.format & PCF_FORMAT_MASK) != PCF_FORMAT_DEFAULT) + return EINVAL; + + uint32_t glyph_count = 0; + size_t records_read = fread(&glyph_count, sizeof(uint32_t), 1, + data->file); + if (records_read != 1) + return EINVAL; + glyph_count = uint32_t_pcf2host(glyph_count, data->bitmap_table.format); + + data->glyph_count = glyph_count; + return EOK; +} + +static int pcf_read_metrics_table_header(pcf_data_t *data) +{ + int rc = pcf_seek_table_header(data, &data->metrics_table); + if (rc != EOK) + return rc; + + size_t records_read; + uint32_t metrics_count; + if (data->metrics_table.format & PCF_FORMAT_COMPRESSED_METRICS) { + uint16_t metrics_count_16; + records_read = fread(&metrics_count_16, sizeof(uint16_t), 1, + data->file); + if (records_read != 1) + return EINVAL; + metrics_count_16 = uint16_t_pcf2host(metrics_count_16, + data->metrics_table.format); + metrics_count = metrics_count_16; + } + else { + records_read = fread(&metrics_count, sizeof(uint32_t), 1, + data->file); + if (records_read != 1) + return EINVAL; + metrics_count = uint32_t_pcf2host(metrics_count, + data->metrics_table.format); + } + + if (metrics_count != data->glyph_count) + return EINVAL; + + return EOK; +} + +static int pcf_read_encodings_table_header(pcf_data_t *data) +{ + int rc = pcf_seek_table_header(data, &data->encodings_table); + if (rc != EOK) + return rc; + + pcf_encoding_t encoding; + size_t records_read = fread(&encoding, sizeof(pcf_encoding_t), 1, + data->file); + if (records_read != 1) + return EINVAL; + + encoding.min_byte1 = uint16_t_pcf2host(encoding.min_byte1, + data->encodings_table.format); + encoding.max_byte1 = uint16_t_pcf2host(encoding.max_byte1, + data->encodings_table.format); + encoding.min_byte2 = uint16_t_pcf2host(encoding.min_byte2, + data->encodings_table.format); + encoding.max_byte2 = uint16_t_pcf2host(encoding.max_byte2, + data->encodings_table.format); + encoding.default_char = uint16_t_pcf2host(encoding.default_char, + data->encodings_table.format); + + data->encoding = encoding; + return EOK; +} + +static int pcf_read_accelerators_table(pcf_data_t *data) +{ + int rc = pcf_seek_table_header(data, &data->accelerators_table); + if (rc != EOK) + return rc; + + pcf_accelerators_t accelerators; + size_t records_read = fread(&accelerators, sizeof(pcf_accelerators_t), + 1, data->file); + if (records_read != 1) + return EINVAL; + + data->font_metrics.ascender = int32_t_pcf2host(accelerators.font_ascent, + data->accelerators_table.format); + data->font_metrics.descender = int32_t_pcf2host(accelerators.font_descent, + data->accelerators_table.format); + data->font_metrics.leading = 0; + + return EOK; +} + +int pcf_font_create(font_t **font, char *filename, uint16_t points) +{ + int rc; + pcf_data_t *data = malloc(sizeof(pcf_data_t)); + if (data == NULL) + return ENOMEM; + + data->file = fopen(filename, "rb"); + if (data->file == NULL) + goto read_error; + + rc = pcf_read_toc(data); + if (rc != EOK) + goto error; + + rc = pcf_read_bitmap_table_header(data); + if (rc != EOK) + goto error; + + rc = pcf_read_metrics_table_header(data); + if (rc != EOK) + goto error; + + rc = pcf_read_encodings_table_header(data); + if (rc != EOK) + goto error; + + rc = pcf_read_accelerators_table(data); + if (rc != EOK) + goto error; + + rc = bitmap_font_create(&fd_pcf, data, data->glyph_count, + data->font_metrics, points, font); + if (rc != EOK) + goto error; + + return EOK; +read_error: + rc = EINVAL; +error: + if (data->file) + fclose(data->file); + free(data); + return rc; +} + +/** @} + */ Index: uspace/lib/draw/font/pcf.h =================================================================== --- uspace/lib/draw/font/pcf.h (revision 8d3512f119e2a44f134b45bad386692c49984b5b) +++ uspace/lib/draw/font/pcf.h (revision 8d3512f119e2a44f134b45bad386692c49984b5b) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2014 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup draw + * @{ + */ +/** + * @file + */ + +#ifndef DRAW_FONT_PBF_H_ +#define DRAW_FONT_PBF_H_ + +#include "../font.h" + +extern int pcf_font_create(font_t **, char *path, uint16_t points); + +#endif + +/** @} + */