Mercurial > repos > blastem

comparison nuklear_ui/sfnt.c @ 1527:4f6e8acd7b6a nuklear_ui

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
author Michael Pavone <pavone@retrodev.com>
date Tue, 06 Mar 2018 21:27:12 -0800
parents
children 098c11aaf8f0
comparison
equal deleted inserted replaced
1526:9bea1a199f15 1527:4f6e8acd7b6a
1 #include <stddef.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include "sfnt.h"
5 #include "../util.h"
6
7 static uint32_t big32(uint8_t *src)
8 {
9 uint32_t ret = *(src++) << 24;
10 ret |= *(src++) << 16;
11 ret |= *(src++) << 8;
12 ret |= *src;
13 return ret;
14 }
15
16 static uint32_t big16(uint8_t *src)
17 {
18 uint32_t ret = *(src++) << 8;
19 ret |= *src;
20 return ret;
21 }
22
23 #define MIN_RESOURCE_MAP_SIZE (16 + 12 + 2 + 8)
24
25 sfnt_container *load_sfnt(uint8_t *buffer, uint32_t size)
26 {
27 if (size < 0x100) {
28 return NULL;
29 }
30 uint32_t sfnt_res_count, sfnt_res_offset, res_offset;
31 uint8_t type;
32 if (!memcmp(buffer, "true", 4) || !memcmp(buffer, "OTTO", 4) || !memcmp(buffer, "typ1", 4) || !memcmp(buffer, "\0\x01\0\0", 4)) {
33 type = CONTAINER_TTF;
34 } else if (!memcmp(buffer, "ttcf", 4)) {
35 type = CONTAINER_TTC;
36 } else {
37 static uint8_t all_zeroes[16];
38 uint32_t resource_map_off = big32(buffer + 4);
39 if (resource_map_off + MIN_RESOURCE_MAP_SIZE > size) {
40 return NULL;
41 }
42 //first 16 bytes of map should match header or be all zeroes
43 if (memcmp(buffer, buffer + resource_map_off, 16) && memcmp(all_zeroes, buffer + resource_map_off, 16)) {
44 return NULL;
45 }
46 uint32_t type_start_off = resource_map_off + big16(buffer + resource_map_off + 24);
47 if (type_start_off + sizeof(uint16_t) > size) {
48 return NULL;
49 }
50 uint32_t num_types = 1 + big16(buffer + type_start_off);
51 if (type_start_off + sizeof(uint16_t) + 8 * num_types > size) {
52 return NULL;
53 }
54 res_offset = big32(buffer);
55 if (res_offset > size) {
56 return NULL;
57 }
58 uint8_t *cur = buffer + type_start_off + 2;
59 sfnt_res_count = 0;
60 for (uint32_t i = 0; i < num_types; i++, cur += 8)
61 {
62 if (!memcmp("sfnt", cur, 4)) {
63 sfnt_res_count = 1 + big16(cur + 4);
64 sfnt_res_offset = type_start_off + big16(cur + 6);
65 if (sfnt_res_offset + sfnt_res_count * 12 > size) {
66 return NULL;
67 }
68 type = CONTAINER_DFONT;
69 break;
70 }
71 }
72 if (!sfnt_res_count) {
73 //No "sfnt" resources in this dfont
74 return NULL;
75 }
76 }
77 sfnt_container *sfnt = calloc(1, sizeof(sfnt_container));
78 sfnt->blob = buffer;
79 sfnt->size = size;
80 sfnt->container_type = type;
81 switch (type)
82 {
83 case CONTAINER_TTF:
84 sfnt->num_fonts = 1;
85 sfnt->tables = calloc(1, sizeof(sfnt_table));
86 sfnt->tables->container = sfnt;
87 sfnt->tables->data = buffer + 0xC;
88 sfnt->tables->num_entries = big16(buffer + 4);
89 sfnt->tables->offset = 0;
90 break;
91 case CONTAINER_TTC: {
92 sfnt->num_fonts = big32(buffer+8);
93 sfnt->tables = calloc(sfnt->num_fonts, sizeof(sfnt_table));
94 uint8_t *offsets = buffer + 0xC;
95 for (int i = 0; i < sfnt->num_fonts; i++, offsets += sizeof(uint32_t))
96 {
97 uint32_t offset = big32(offsets);
98 sfnt->tables[i].data = buffer + offset + 0xC;
99 sfnt->tables[i].container = sfnt;
100 sfnt->tables[i].num_entries = big16(buffer + offset + 4);
101 sfnt->tables[i].offset = 0;
102 }
103 break;
104 }
105 case CONTAINER_DFONT:{
106 sfnt->num_fonts = sfnt_res_count;
107 sfnt->tables = calloc(sfnt->num_fonts, sizeof(sfnt_table));
108 uint8_t *cur = buffer + sfnt_res_offset;
109 for (int i = 0; i < sfnt->num_fonts; i++, cur += 12)
110 {
111 uint32_t offset = res_offset + (big32(cur + 4) & 0xFFFFFF);
112 if (offset + 4 > size) {
113 sfnt->tables[i].num_entries = 0;
114 sfnt->tables[i].data = NULL;
115 continue;
116 }
117 uint32_t res_size = big32(buffer + offset);
118 if (offset + 4 + res_size > size || res_size < 0xC) {
119 sfnt->tables[i].num_entries = 0;
120 sfnt->tables[i].data = NULL;
121 continue;
122 }
123 sfnt->tables[i].container = sfnt;
124 sfnt->tables[i].data = buffer + offset + 4 + 0xC;
125 sfnt->tables[i].num_entries = big16(buffer + offset + 4 + 4);
126 sfnt->tables[i].offset = offset + 4;
127 }
128 break;
129 }
130 }
131 return sfnt;
132 }
133
134 uint8_t *sfnt_find_table(sfnt_table *sfnt, char *table, uint32_t *size_out)
135 {
136 uint8_t *entry = sfnt->data;
137 for (int i = 0; i < sfnt->num_entries; i++, entry += 16)
138 {
139 if (!strncmp(entry, table, 4)) {
140 if (size_out) {
141 *size_out = big32(entry + 12);
142 }
143 return sfnt->container->blob + sfnt->offset + big32(entry + 8);
144 }
145 }
146 return NULL;
147 }
148
149 char *sfnt_name(sfnt_table *sfnt, uint16_t name_type)
150 {
151 uint32_t name_size;
152 uint8_t *name_table = sfnt_find_table(sfnt, "name", &name_size);
153 if (!name_table) {
154 return NULL;
155 }
156 uint16_t num_names = big16(name_table + 2);
157 if ((6 + num_names *12) > name_size) {
158 //count is too big for the name table size, abort
159 return NULL;
160 }
161 uint8_t *entry = name_table + 6;
162 uint16_t name_length = 0, name_offset;
163 uint8_t *unicode_entry = NULL, *macroman_entry = NULL, *winunicode_entry = NULL;
164 for (uint16_t i = 0; i < num_names; i++, entry += 12)
165 {
166 if (big16(entry + 6) != name_type) {
167 continue;
168 }
169 uint16_t language_id = big16(entry + 4);
170 if (language_id >= 0x8000) {
171 //ingore language tag records
172 continue;
173 }
174 uint16_t platform_id = big16(entry);
175 if (platform_id == 0) {
176 //prefer Unicode first
177 unicode_entry = entry;
178 break;
179 } else if (platform_id == 3 && big16(entry + 2) < 2) {
180 if (!winunicode_entry || (language_id & 0xFF) == 0x09) {
181 winunicode_entry = entry;
182 }
183 } else if (platform_id == 1 && big16(entry + 2) == 0) {
184 if (!macroman_entry || (language_id == 0)) {
185 macroman_entry = entry;
186 }
187 }
188 }
189 entry = unicode_entry ? unicode_entry : winunicode_entry ? winunicode_entry : macroman_entry;
190 if (entry) {
191 name_length = big16(entry + 8);
192 name_offset = big16(entry + 10);
193 }
194 if (!name_length) {
195 return NULL;
196 }
197 uint32_t full_off = name_offset + big16(name_table + 4);
198 if ((full_off + name_length) > name_size) {
199 return NULL;
200 }
201 if (entry == macroman_entry) {
202 //TODO: convert these properly to UTF-8
203 char *ret = malloc(name_size + 1);
204 memcpy(ret, name_table + full_off, name_length);
205 ret[name_size] = 0;
206 return ret;
207 } else {
208 return utf16be_to_utf8(name_table + full_off, name_length/2);
209 }
210 }
211
212 uint8_t *sfnt_flatten(sfnt_table *sfnt, uint32_t *size_out)
213 {
214 uint8_t *ret = NULL;;
215 sfnt_container *cont = sfnt->container;
216 switch(cont->container_type)
217 {
218 case CONTAINER_TTF:
219 ret = cont->blob;
220 if (size_out) {
221 *size_out = cont->size;
222 }
223 break;
224 case CONTAINER_TTC:
225 memmove(cont->blob, sfnt->data - 0xC, 0xC + sfnt->num_entries * 12);
226 ret = cont->blob;
227 if (size_out) {
228 *size_out = cont->size;
229 }
230 break;
231 case CONTAINER_DFONT:{
232 uint8_t * start = sfnt->data - 0xC;
233 uint32_t size = big32(start - 4);
234 if (size + (start-cont->blob) > cont->size) {
235 size = cont->size - (start-cont->blob);
236 }
237 ret = malloc(size);
238 memcpy(ret, start, size);
239 free(cont->blob);
240 if (size_out) {
241 *size_out = size;
242 }
243 break;
244 }
245 }
246 free(cont->tables);
247 free(cont);
248 return ret;
249 }
250
251 sfnt_table *sfnt_subfamily_by_names(sfnt_container *sfnt, const char **names)
252 {
253 for (int i = 0; i < sfnt->num_fonts; i++)
254 {
255 for (const char **name = names; *name; name++)
256 {
257 char *font_subfam = sfnt_name(sfnt->tables + i, SFNT_SUBFAMILY);
258 if (font_subfam && !strcasecmp(*name, font_subfam)) {
259 free(font_subfam);
260 return sfnt->tables + i;
261 }
262 free(font_subfam);
263 }
264 }
265 return NULL;
266 }
267
268 void sfnt_free(sfnt_container *sfnt)
269 {
270 free(sfnt->tables);
271 free(sfnt->blob);
272 free(sfnt);
273 }