1 | /**************************************************************************** |
2 | * |
3 | * pfrload.c |
4 | * |
5 | * FreeType PFR loader (body). |
6 | * |
7 | * Copyright (C) 2002-2023 by |
8 | * David Turner, Robert Wilhelm, and Werner Lemberg. |
9 | * |
10 | * This file is part of the FreeType project, and may only be used, |
11 | * modified, and distributed under the terms of the FreeType project |
12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute |
13 | * this file you indicate that you have read the license and |
14 | * understand and accept it fully. |
15 | * |
16 | */ |
17 | |
18 | |
19 | #include "pfrload.h" |
20 | #include <freetype/internal/ftdebug.h> |
21 | #include <freetype/internal/ftstream.h> |
22 | |
23 | #include "pfrerror.h" |
24 | |
25 | #undef FT_COMPONENT |
26 | #define FT_COMPONENT pfr |
27 | |
28 | |
29 | /* |
30 | * The overall structure of a PFR file is as follows. |
31 | * |
32 | * PFR header |
33 | * 58 bytes (contains nPhysFonts) |
34 | * |
35 | * Logical font directory (size at most 2^16 bytes) |
36 | * 2 bytes (nLogFonts) |
37 | * + nLogFonts * 5 bytes |
38 | * |
39 | * ==> nLogFonts <= 13106 |
40 | * |
41 | * Logical font section (size at most 2^24 bytes) |
42 | * nLogFonts * logFontRecord |
43 | * |
44 | * logFontRecord (size at most 2^16 bytes) |
45 | * 12 bytes (fontMatrix) |
46 | * + 1 byte (flags) |
47 | * + 0-5 bytes (depending on `flags') |
48 | * + 0-(1+255*(2+255)) = 0-65536 (depending on `flags') |
49 | * + 5 bytes (physical font info) |
50 | * + 0-1 bytes (depending on PFR header) |
51 | * |
52 | * ==> minimum size 18 bytes |
53 | * |
54 | * Physical font section (size at most 2^24 bytes) |
55 | * nPhysFonts * (physFontRecord |
56 | * + nBitmapSizes * nBmapChars * bmapCharRecord) |
57 | * |
58 | * physFontRecord (size at most 2^24 bytes) |
59 | * 14 bytes (font info) |
60 | * + 1 byte (flags) |
61 | * + 0-2 (depending on `flags') |
62 | * + 0-? (structure too complicated to be shown here; depending on |
63 | * `flags'; contains `nBitmapSizes' and `nBmapChars') |
64 | * + 3 bytes (nAuxBytes) |
65 | * + nAuxBytes |
66 | * + 1 byte (nBlueValues) |
67 | * + 2 * nBlueValues |
68 | * + 6 bytes (hinting data) |
69 | * + 2 bytes (nCharacters) |
70 | * + nCharacters * (4-10 bytes) (depending on `flags') |
71 | * |
72 | * ==> minimum size 27 bytes |
73 | * |
74 | * bmapCharRecord |
75 | * 4-7 bytes |
76 | * |
77 | * Glyph program strings (three possible types: simpleGps, compoundGps, |
78 | * and bitmapGps; size at most 2^24 bytes) |
79 | * simpleGps (size at most 2^16 bytes) |
80 | * 1 byte (flags) |
81 | * 1-2 bytes (n[XY]orus, depending on `flags') |
82 | * 0-(64+512*2) = 0-1088 bytes (depending on `n[XY]orus') |
83 | * 0-? (structure too complicated to be shown here; depending on |
84 | * `flags') |
85 | * 1-? glyph data (faintly resembling PS Type 1 charstrings) |
86 | * |
87 | * ==> minimum size 3 bytes |
88 | * |
89 | * compoundGps (size at most 2^16 bytes) |
90 | * 1 byte (nElements <= 63, flags) |
91 | * + 0-(1+255*(2+255)) = 0-65536 (depending on `flags') |
92 | * + nElements * (6-14 bytes) |
93 | * |
94 | * bitmapGps (size at most 2^16 bytes) |
95 | * 1 byte (flags) |
96 | * 3-13 bytes (position info, depending on `flags') |
97 | * 0-? bitmap data |
98 | * |
99 | * ==> minimum size 4 bytes |
100 | * |
101 | * PFR trailer |
102 | * 8 bytes |
103 | * |
104 | * |
105 | * ==> minimum size of a valid PFR: |
106 | * 58 (header) |
107 | * + 2 (nLogFonts) |
108 | * + 27 (1 physFontRecord) |
109 | * + 8 (trailer) |
110 | * ----- |
111 | * 95 bytes |
112 | * |
113 | */ |
114 | |
115 | |
116 | /*************************************************************************/ |
117 | /*************************************************************************/ |
118 | /***** *****/ |
119 | /***** EXTRA ITEMS *****/ |
120 | /***** *****/ |
121 | /*************************************************************************/ |
122 | /*************************************************************************/ |
123 | |
124 | |
125 | FT_LOCAL_DEF( FT_Error ) |
126 | ( FT_Byte* *pp, |
127 | FT_Byte* limit ) |
128 | { |
129 | return pfr_extra_items_parse( pp, limit, NULL, NULL ); |
130 | } |
131 | |
132 | |
133 | FT_LOCAL_DEF( FT_Error ) |
134 | ( FT_Byte* *pp, |
135 | FT_Byte* limit, |
136 | PFR_ExtraItem item_list, |
137 | FT_Pointer item_data ) |
138 | { |
139 | FT_Error error = FT_Err_Ok; |
140 | FT_Byte* p = *pp; |
141 | FT_UInt num_items, item_type, item_size; |
142 | |
143 | |
144 | PFR_CHECK( 1 ); |
145 | num_items = PFR_NEXT_BYTE( p ); |
146 | |
147 | for ( ; num_items > 0; num_items-- ) |
148 | { |
149 | PFR_CHECK( 2 ); |
150 | item_size = PFR_NEXT_BYTE( p ); |
151 | item_type = PFR_NEXT_BYTE( p ); |
152 | |
153 | PFR_CHECK( item_size ); |
154 | |
155 | if ( item_list ) |
156 | { |
157 | PFR_ExtraItem = item_list; |
158 | |
159 | |
160 | for ( extra = item_list; extra->parser != NULL; extra++ ) |
161 | { |
162 | if ( extra->type == item_type ) |
163 | { |
164 | error = extra->parser( p, p + item_size, item_data ); |
165 | if ( error ) |
166 | goto Exit; |
167 | |
168 | break; |
169 | } |
170 | } |
171 | } |
172 | |
173 | p += item_size; |
174 | } |
175 | |
176 | Exit: |
177 | *pp = p; |
178 | return error; |
179 | |
180 | Too_Short: |
181 | FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" )); |
182 | error = FT_THROW( Invalid_Table ); |
183 | goto Exit; |
184 | } |
185 | |
186 | |
187 | /*************************************************************************/ |
188 | /*************************************************************************/ |
189 | /***** *****/ |
190 | /***** PFR HEADER *****/ |
191 | /***** *****/ |
192 | /*************************************************************************/ |
193 | /*************************************************************************/ |
194 | |
195 | static const FT_Frame_Field [] = |
196 | { |
197 | #undef FT_STRUCTURE |
198 | #define FT_STRUCTURE PFR_HeaderRec |
199 | |
200 | FT_FRAME_START( 58 ), |
201 | FT_FRAME_ULONG ( signature ), |
202 | FT_FRAME_USHORT( version ), |
203 | FT_FRAME_USHORT( signature2 ), |
204 | FT_FRAME_USHORT( header_size ), |
205 | |
206 | FT_FRAME_USHORT( log_dir_size ), |
207 | FT_FRAME_USHORT( log_dir_offset ), |
208 | |
209 | FT_FRAME_USHORT( log_font_max_size ), |
210 | FT_FRAME_UOFF3 ( log_font_section_size ), |
211 | FT_FRAME_UOFF3 ( log_font_section_offset ), |
212 | |
213 | FT_FRAME_USHORT( phy_font_max_size ), |
214 | FT_FRAME_UOFF3 ( phy_font_section_size ), |
215 | FT_FRAME_UOFF3 ( phy_font_section_offset ), |
216 | |
217 | FT_FRAME_USHORT( gps_max_size ), |
218 | FT_FRAME_UOFF3 ( gps_section_size ), |
219 | FT_FRAME_UOFF3 ( gps_section_offset ), |
220 | |
221 | FT_FRAME_BYTE ( max_blue_values ), |
222 | FT_FRAME_BYTE ( max_x_orus ), |
223 | FT_FRAME_BYTE ( max_y_orus ), |
224 | |
225 | FT_FRAME_BYTE ( phy_font_max_size_high ), |
226 | FT_FRAME_BYTE ( color_flags ), |
227 | |
228 | FT_FRAME_UOFF3 ( bct_max_size ), |
229 | FT_FRAME_UOFF3 ( bct_set_max_size ), |
230 | FT_FRAME_UOFF3 ( phy_bct_set_max_size ), |
231 | |
232 | FT_FRAME_USHORT( num_phy_fonts ), |
233 | FT_FRAME_BYTE ( max_vert_stem_snap ), |
234 | FT_FRAME_BYTE ( max_horz_stem_snap ), |
235 | FT_FRAME_USHORT( max_chars ), |
236 | FT_FRAME_END |
237 | }; |
238 | |
239 | |
240 | FT_LOCAL_DEF( FT_Error ) |
241 | ( PFR_Header , |
242 | FT_Stream stream ) |
243 | { |
244 | FT_Error error; |
245 | |
246 | |
247 | /* read header directly */ |
248 | if ( !FT_STREAM_SEEK( 0 ) && |
249 | !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) ) |
250 | { |
251 | /* make a few adjustments to the header */ |
252 | header->phy_font_max_size += |
253 | (FT_UInt32)header->phy_font_max_size_high << 16; |
254 | } |
255 | |
256 | return error; |
257 | } |
258 | |
259 | |
260 | FT_LOCAL_DEF( FT_Bool ) |
261 | ( PFR_Header ) |
262 | { |
263 | FT_Bool result = 1; |
264 | |
265 | |
266 | /* check signature and header size */ |
267 | if ( header->signature != 0x50465230L || /* "PFR0" */ |
268 | header->version > 4 || |
269 | header->header_size < 58 || |
270 | header->signature2 != 0x0D0A ) /* CR/LF */ |
271 | result = 0; |
272 | |
273 | return result; |
274 | } |
275 | |
276 | |
277 | /***********************************************************************/ |
278 | /***********************************************************************/ |
279 | /***** *****/ |
280 | /***** PFR LOGICAL FONTS *****/ |
281 | /***** *****/ |
282 | /***********************************************************************/ |
283 | /***********************************************************************/ |
284 | |
285 | |
286 | FT_LOCAL_DEF( FT_Error ) |
287 | pfr_log_font_count( FT_Stream stream, |
288 | FT_UInt32 section_offset, |
289 | FT_Long *acount ) |
290 | { |
291 | FT_Error error; |
292 | FT_UInt count; |
293 | FT_UInt result = 0; |
294 | |
295 | |
296 | if ( FT_STREAM_SEEK( section_offset ) || |
297 | FT_READ_USHORT( count ) ) |
298 | goto Exit; |
299 | |
300 | /* check maximum value and a rough minimum size: */ |
301 | /* - no more than 13106 log fonts */ |
302 | /* - we need 5 bytes for a log header record */ |
303 | /* - we need at least 18 bytes for a log font record */ |
304 | /* - the overall size is at least 95 bytes plus the */ |
305 | /* log header and log font records */ |
306 | if ( count > ( ( 1 << 16 ) - 2 ) / 5 || |
307 | 2 + count * 5 >= stream->size - section_offset || |
308 | 95 + count * ( 5 + 18 ) >= stream->size ) |
309 | { |
310 | FT_ERROR(( "pfr_log_font_count:" |
311 | " invalid number of logical fonts\n" )); |
312 | error = FT_THROW( Invalid_Table ); |
313 | goto Exit; |
314 | } |
315 | |
316 | result = count; |
317 | |
318 | Exit: |
319 | *acount = (FT_Long)result; |
320 | return error; |
321 | } |
322 | |
323 | |
324 | FT_LOCAL_DEF( FT_Error ) |
325 | pfr_log_font_load( PFR_LogFont log_font, |
326 | FT_Stream stream, |
327 | FT_UInt idx, |
328 | FT_UInt32 section_offset, |
329 | FT_Bool size_increment ) |
330 | { |
331 | FT_UInt num_log_fonts; |
332 | FT_UInt flags; |
333 | FT_UInt32 offset; |
334 | FT_UInt32 size; |
335 | FT_Error error; |
336 | |
337 | |
338 | if ( FT_STREAM_SEEK( section_offset ) || |
339 | FT_READ_USHORT( num_log_fonts ) ) |
340 | goto Exit; |
341 | |
342 | if ( idx >= num_log_fonts ) |
343 | return FT_THROW( Invalid_Argument ); |
344 | |
345 | if ( FT_STREAM_SKIP( idx * 5 ) || |
346 | FT_READ_USHORT( size ) || |
347 | FT_READ_UOFF3 ( offset ) ) |
348 | goto Exit; |
349 | |
350 | /* save logical font size and offset */ |
351 | log_font->size = size; |
352 | log_font->offset = offset; |
353 | |
354 | /* now, check the rest of the table before loading it */ |
355 | { |
356 | FT_Byte* p; |
357 | FT_Byte* limit; |
358 | FT_UInt local; |
359 | |
360 | |
361 | if ( FT_STREAM_SEEK( offset ) || |
362 | FT_FRAME_ENTER( size ) ) |
363 | goto Exit; |
364 | |
365 | p = stream->cursor; |
366 | limit = p + size; |
367 | |
368 | PFR_CHECK( 13 ); |
369 | |
370 | log_font->matrix[0] = PFR_NEXT_LONG( p ); |
371 | log_font->matrix[1] = PFR_NEXT_LONG( p ); |
372 | log_font->matrix[2] = PFR_NEXT_LONG( p ); |
373 | log_font->matrix[3] = PFR_NEXT_LONG( p ); |
374 | |
375 | flags = PFR_NEXT_BYTE( p ); |
376 | |
377 | local = 0; |
378 | if ( flags & PFR_LOG_STROKE ) |
379 | { |
380 | local++; |
381 | if ( flags & PFR_LOG_2BYTE_STROKE ) |
382 | local++; |
383 | |
384 | if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER ) |
385 | local += 3; |
386 | } |
387 | if ( flags & PFR_LOG_BOLD ) |
388 | { |
389 | local++; |
390 | if ( flags & PFR_LOG_2BYTE_BOLD ) |
391 | local++; |
392 | } |
393 | |
394 | PFR_CHECK( local ); |
395 | |
396 | if ( flags & PFR_LOG_STROKE ) |
397 | { |
398 | log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE ) |
399 | ? PFR_NEXT_SHORT( p ) |
400 | : PFR_NEXT_BYTE( p ); |
401 | |
402 | if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER ) |
403 | log_font->miter_limit = PFR_NEXT_LONG( p ); |
404 | } |
405 | |
406 | if ( flags & PFR_LOG_BOLD ) |
407 | log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD ) |
408 | ? PFR_NEXT_SHORT( p ) |
409 | : PFR_NEXT_BYTE( p ); |
410 | |
411 | if ( flags & PFR_LOG_EXTRA_ITEMS ) |
412 | { |
413 | error = pfr_extra_items_skip( &p, limit ); |
414 | if ( error ) |
415 | goto Fail; |
416 | } |
417 | |
418 | PFR_CHECK( 5 ); |
419 | log_font->phys_size = PFR_NEXT_USHORT( p ); |
420 | log_font->phys_offset = PFR_NEXT_ULONG( p ); |
421 | if ( size_increment ) |
422 | { |
423 | PFR_CHECK( 1 ); |
424 | log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16; |
425 | } |
426 | } |
427 | |
428 | Fail: |
429 | FT_FRAME_EXIT(); |
430 | |
431 | Exit: |
432 | return error; |
433 | |
434 | Too_Short: |
435 | FT_ERROR(( "pfr_log_font_load: invalid logical font table\n" )); |
436 | error = FT_THROW( Invalid_Table ); |
437 | goto Fail; |
438 | } |
439 | |
440 | |
441 | /***********************************************************************/ |
442 | /***********************************************************************/ |
443 | /***** *****/ |
444 | /***** PFR PHYSICAL FONTS *****/ |
445 | /***** *****/ |
446 | /***********************************************************************/ |
447 | /***********************************************************************/ |
448 | |
449 | |
450 | /* load bitmap strikes lists */ |
451 | FT_CALLBACK_DEF( FT_Error ) |
452 | ( FT_Byte* p, |
453 | FT_Byte* limit, |
454 | void* phy_font_ ) |
455 | { |
456 | PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_; |
457 | FT_Memory memory = phy_font->memory; |
458 | PFR_Strike strike; |
459 | FT_UInt flags0; |
460 | FT_UInt n, count, size1; |
461 | FT_Error error = FT_Err_Ok; |
462 | |
463 | |
464 | PFR_CHECK( 5 ); |
465 | |
466 | p += 3; /* skip bctSize */ |
467 | flags0 = PFR_NEXT_BYTE( p ); |
468 | count = PFR_NEXT_BYTE( p ); |
469 | |
470 | /* re-allocate when needed */ |
471 | if ( phy_font->num_strikes + count > phy_font->max_strikes ) |
472 | { |
473 | FT_UInt new_max = FT_PAD_CEIL( phy_font->num_strikes + count, 4 ); |
474 | |
475 | |
476 | if ( FT_RENEW_ARRAY( phy_font->strikes, |
477 | phy_font->num_strikes, |
478 | new_max ) ) |
479 | goto Exit; |
480 | |
481 | phy_font->max_strikes = new_max; |
482 | } |
483 | |
484 | size1 = 1 + 1 + 1 + 2 + 2 + 1; |
485 | if ( flags0 & PFR_STRIKE_2BYTE_XPPM ) |
486 | size1++; |
487 | |
488 | if ( flags0 & PFR_STRIKE_2BYTE_YPPM ) |
489 | size1++; |
490 | |
491 | if ( flags0 & PFR_STRIKE_3BYTE_SIZE ) |
492 | size1++; |
493 | |
494 | if ( flags0 & PFR_STRIKE_3BYTE_OFFSET ) |
495 | size1++; |
496 | |
497 | if ( flags0 & PFR_STRIKE_2BYTE_COUNT ) |
498 | size1++; |
499 | |
500 | strike = phy_font->strikes + phy_font->num_strikes; |
501 | |
502 | PFR_CHECK( count * size1 ); |
503 | |
504 | for ( n = 0; n < count; n++, strike++ ) |
505 | { |
506 | strike->x_ppm = ( flags0 & PFR_STRIKE_2BYTE_XPPM ) |
507 | ? PFR_NEXT_USHORT( p ) |
508 | : PFR_NEXT_BYTE( p ); |
509 | |
510 | strike->y_ppm = ( flags0 & PFR_STRIKE_2BYTE_YPPM ) |
511 | ? PFR_NEXT_USHORT( p ) |
512 | : PFR_NEXT_BYTE( p ); |
513 | |
514 | strike->flags = PFR_NEXT_BYTE( p ); |
515 | |
516 | strike->bct_size = ( flags0 & PFR_STRIKE_3BYTE_SIZE ) |
517 | ? PFR_NEXT_ULONG( p ) |
518 | : PFR_NEXT_USHORT( p ); |
519 | |
520 | strike->bct_offset = ( flags0 & PFR_STRIKE_3BYTE_OFFSET ) |
521 | ? PFR_NEXT_ULONG( p ) |
522 | : PFR_NEXT_USHORT( p ); |
523 | |
524 | strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT ) |
525 | ? PFR_NEXT_USHORT( p ) |
526 | : PFR_NEXT_BYTE( p ); |
527 | } |
528 | |
529 | phy_font->num_strikes += count; |
530 | |
531 | Exit: |
532 | return error; |
533 | |
534 | Too_Short: |
535 | error = FT_THROW( Invalid_Table ); |
536 | FT_ERROR(( "pfr_extra_item_load_bitmap_info:" |
537 | " invalid bitmap info table\n" )); |
538 | goto Exit; |
539 | } |
540 | |
541 | |
542 | /* Load font ID. This is a so-called `unique' name that is rather |
543 | * long and descriptive (like `Tiresias ScreenFont v7.51'). |
544 | * |
545 | * Note that a PFR font's family name is contained in an *undocumented* |
546 | * string of the `auxiliary data' portion of a physical font record. This |
547 | * may also contain the `real' style name! |
548 | * |
549 | * If no family name is present, the font ID is used instead for the |
550 | * family. |
551 | */ |
552 | FT_CALLBACK_DEF( FT_Error ) |
553 | ( FT_Byte* p, |
554 | FT_Byte* limit, |
555 | void* phy_font_ ) |
556 | { |
557 | PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_; |
558 | FT_Error error = FT_Err_Ok; |
559 | FT_Memory memory = phy_font->memory; |
560 | FT_UInt len = (FT_UInt)( limit - p ); |
561 | |
562 | |
563 | if ( phy_font->font_id ) |
564 | goto Exit; |
565 | |
566 | if ( FT_QALLOC( phy_font->font_id, len + 1 ) ) |
567 | goto Exit; |
568 | |
569 | /* copy font ID name, and terminate it for safety */ |
570 | FT_MEM_COPY( phy_font->font_id, p, len ); |
571 | phy_font->font_id[len] = 0; |
572 | |
573 | Exit: |
574 | return error; |
575 | } |
576 | |
577 | |
578 | /* load stem snap tables */ |
579 | FT_CALLBACK_DEF( FT_Error ) |
580 | ( FT_Byte* p, |
581 | FT_Byte* limit, |
582 | void* phy_font_ ) |
583 | { |
584 | PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_; |
585 | FT_UInt count, num_vert, num_horz; |
586 | FT_Int* snaps = NULL; |
587 | FT_Error error = FT_Err_Ok; |
588 | FT_Memory memory = phy_font->memory; |
589 | |
590 | |
591 | if ( phy_font->vertical.stem_snaps ) |
592 | goto Exit; |
593 | |
594 | PFR_CHECK( 1 ); |
595 | count = PFR_NEXT_BYTE( p ); |
596 | |
597 | num_vert = count & 15; |
598 | num_horz = count >> 4; |
599 | count = num_vert + num_horz; |
600 | |
601 | PFR_CHECK( count * 2 ); |
602 | |
603 | if ( FT_QNEW_ARRAY( snaps, count ) ) |
604 | goto Exit; |
605 | |
606 | phy_font->vertical.stem_snaps = snaps; |
607 | phy_font->horizontal.stem_snaps = snaps + num_vert; |
608 | |
609 | for ( ; count > 0; count--, snaps++ ) |
610 | *snaps = FT_NEXT_SHORT( p ); |
611 | |
612 | Exit: |
613 | return error; |
614 | |
615 | Too_Short: |
616 | error = FT_THROW( Invalid_Table ); |
617 | FT_ERROR(( "pfr_extra_item_load_stem_snaps:" |
618 | " invalid stem snaps table\n" )); |
619 | goto Exit; |
620 | } |
621 | |
622 | |
623 | /* load kerning pair data */ |
624 | FT_CALLBACK_DEF( FT_Error ) |
625 | ( FT_Byte* p, |
626 | FT_Byte* limit, |
627 | void* phy_font_ ) |
628 | { |
629 | PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_; |
630 | PFR_KernItem item = NULL; |
631 | FT_Error error = FT_Err_Ok; |
632 | FT_Memory memory = phy_font->memory; |
633 | |
634 | |
635 | if ( FT_NEW( item ) ) |
636 | goto Exit; |
637 | |
638 | PFR_CHECK( 4 ); |
639 | |
640 | item->pair_count = PFR_NEXT_BYTE( p ); |
641 | item->base_adj = PFR_NEXT_SHORT( p ); |
642 | item->flags = PFR_NEXT_BYTE( p ); |
643 | item->offset = phy_font->offset + |
644 | (FT_Offset)( p - phy_font->cursor ); |
645 | |
646 | #ifndef PFR_CONFIG_NO_CHECKS |
647 | item->pair_size = 3; |
648 | |
649 | if ( item->flags & PFR_KERN_2BYTE_CHAR ) |
650 | item->pair_size += 2; |
651 | |
652 | if ( item->flags & PFR_KERN_2BYTE_ADJ ) |
653 | item->pair_size += 1; |
654 | |
655 | PFR_CHECK( item->pair_count * item->pair_size ); |
656 | #endif |
657 | |
658 | /* load first and last pairs into the item to speed up */ |
659 | /* lookup later... */ |
660 | if ( item->pair_count > 0 ) |
661 | { |
662 | FT_UInt char1, char2; |
663 | FT_Byte* q; |
664 | |
665 | |
666 | if ( item->flags & PFR_KERN_2BYTE_CHAR ) |
667 | { |
668 | q = p; |
669 | char1 = PFR_NEXT_USHORT( q ); |
670 | char2 = PFR_NEXT_USHORT( q ); |
671 | |
672 | item->pair1 = PFR_KERN_INDEX( char1, char2 ); |
673 | |
674 | q = p + item->pair_size * ( item->pair_count - 1 ); |
675 | char1 = PFR_NEXT_USHORT( q ); |
676 | char2 = PFR_NEXT_USHORT( q ); |
677 | |
678 | item->pair2 = PFR_KERN_INDEX( char1, char2 ); |
679 | } |
680 | else |
681 | { |
682 | q = p; |
683 | char1 = PFR_NEXT_BYTE( q ); |
684 | char2 = PFR_NEXT_BYTE( q ); |
685 | |
686 | item->pair1 = PFR_KERN_INDEX( char1, char2 ); |
687 | |
688 | q = p + item->pair_size * ( item->pair_count - 1 ); |
689 | char1 = PFR_NEXT_BYTE( q ); |
690 | char2 = PFR_NEXT_BYTE( q ); |
691 | |
692 | item->pair2 = PFR_KERN_INDEX( char1, char2 ); |
693 | } |
694 | |
695 | /* add new item to the current list */ |
696 | item->next = NULL; |
697 | *phy_font->kern_items_tail = item; |
698 | phy_font->kern_items_tail = &item->next; |
699 | phy_font->num_kern_pairs += item->pair_count; |
700 | } |
701 | else |
702 | { |
703 | /* empty item! */ |
704 | FT_FREE( item ); |
705 | } |
706 | |
707 | Exit: |
708 | return error; |
709 | |
710 | Too_Short: |
711 | FT_FREE( item ); |
712 | |
713 | error = FT_THROW( Invalid_Table ); |
714 | FT_ERROR(( "pfr_extra_item_load_kerning_pairs:" |
715 | " invalid kerning pairs table\n" )); |
716 | goto Exit; |
717 | } |
718 | |
719 | |
720 | static const PFR_ExtraItemRec [] = |
721 | { |
722 | { 1, pfr_extra_item_load_bitmap_info }, |
723 | { 2, pfr_extra_item_load_font_id }, |
724 | { 3, pfr_extra_item_load_stem_snaps }, |
725 | { 4, pfr_extra_item_load_kerning_pairs }, |
726 | { 0, NULL } |
727 | }; |
728 | |
729 | |
730 | /* |
731 | * Load a name from the auxiliary data. Since this extracts undocumented |
732 | * strings from the font file, we need to be careful here. |
733 | */ |
734 | static FT_Error |
735 | pfr_aux_name_load( FT_Byte* p, |
736 | FT_UInt len, |
737 | FT_Memory memory, |
738 | FT_String* *astring ) |
739 | { |
740 | FT_Error error = FT_Err_Ok; |
741 | FT_String* result = NULL; |
742 | FT_UInt n, ok; |
743 | |
744 | |
745 | if ( *astring ) |
746 | FT_FREE( *astring ); |
747 | |
748 | if ( len > 0 && p[len - 1] == 0 ) |
749 | len--; |
750 | |
751 | /* check that each character is ASCII */ |
752 | /* for making sure not to load garbage */ |
753 | ok = ( len > 0 ); |
754 | for ( n = 0; n < len; n++ ) |
755 | if ( p[n] < 32 || p[n] > 127 ) |
756 | { |
757 | ok = 0; |
758 | break; |
759 | } |
760 | |
761 | if ( ok ) |
762 | { |
763 | if ( FT_QALLOC( result, len + 1 ) ) |
764 | goto Exit; |
765 | |
766 | FT_MEM_COPY( result, p, len ); |
767 | result[len] = 0; |
768 | } |
769 | |
770 | Exit: |
771 | *astring = result; |
772 | return error; |
773 | } |
774 | |
775 | |
776 | FT_LOCAL_DEF( void ) |
777 | pfr_phy_font_done( PFR_PhyFont phy_font, |
778 | FT_Memory memory ) |
779 | { |
780 | FT_FREE( phy_font->font_id ); |
781 | FT_FREE( phy_font->family_name ); |
782 | FT_FREE( phy_font->style_name ); |
783 | |
784 | FT_FREE( phy_font->vertical.stem_snaps ); |
785 | phy_font->vertical.num_stem_snaps = 0; |
786 | |
787 | phy_font->horizontal.stem_snaps = NULL; |
788 | phy_font->horizontal.num_stem_snaps = 0; |
789 | |
790 | FT_FREE( phy_font->strikes ); |
791 | phy_font->num_strikes = 0; |
792 | phy_font->max_strikes = 0; |
793 | |
794 | FT_FREE( phy_font->chars ); |
795 | phy_font->num_chars = 0; |
796 | phy_font->chars_offset = 0; |
797 | |
798 | FT_FREE( phy_font->blue_values ); |
799 | phy_font->num_blue_values = 0; |
800 | |
801 | { |
802 | PFR_KernItem item, next; |
803 | |
804 | |
805 | item = phy_font->kern_items; |
806 | while ( item ) |
807 | { |
808 | next = item->next; |
809 | FT_FREE( item ); |
810 | item = next; |
811 | } |
812 | phy_font->kern_items = NULL; |
813 | phy_font->kern_items_tail = NULL; |
814 | } |
815 | |
816 | phy_font->num_kern_pairs = 0; |
817 | } |
818 | |
819 | |
820 | FT_LOCAL_DEF( FT_Error ) |
821 | pfr_phy_font_load( PFR_PhyFont phy_font, |
822 | FT_Stream stream, |
823 | FT_UInt32 offset, |
824 | FT_UInt32 size ) |
825 | { |
826 | FT_Error error; |
827 | FT_Memory memory = stream->memory; |
828 | FT_UInt flags; |
829 | FT_ULong num_aux; |
830 | FT_Byte* p; |
831 | FT_Byte* limit; |
832 | |
833 | |
834 | phy_font->memory = memory; |
835 | phy_font->offset = offset; |
836 | |
837 | phy_font->kern_items = NULL; |
838 | phy_font->kern_items_tail = &phy_font->kern_items; |
839 | |
840 | if ( FT_STREAM_SEEK( offset ) || |
841 | FT_FRAME_ENTER( size ) ) |
842 | goto Exit; |
843 | |
844 | phy_font->cursor = stream->cursor; |
845 | |
846 | p = stream->cursor; |
847 | limit = p + size; |
848 | |
849 | PFR_CHECK( 15 ); |
850 | phy_font->font_ref_number = PFR_NEXT_USHORT( p ); |
851 | phy_font->outline_resolution = PFR_NEXT_USHORT( p ); |
852 | phy_font->metrics_resolution = PFR_NEXT_USHORT( p ); |
853 | phy_font->bbox.xMin = PFR_NEXT_SHORT( p ); |
854 | phy_font->bbox.yMin = PFR_NEXT_SHORT( p ); |
855 | phy_font->bbox.xMax = PFR_NEXT_SHORT( p ); |
856 | phy_font->bbox.yMax = PFR_NEXT_SHORT( p ); |
857 | phy_font->flags = flags = PFR_NEXT_BYTE( p ); |
858 | |
859 | if ( !phy_font->outline_resolution || |
860 | !phy_font->metrics_resolution ) |
861 | { |
862 | error = FT_THROW( Invalid_Table ); |
863 | FT_ERROR(( "pfr_phy_font_load: invalid resolution\n" )); |
864 | goto Fail; |
865 | } |
866 | |
867 | /* get the standard advance for non-proportional fonts */ |
868 | if ( !( flags & PFR_PHY_PROPORTIONAL ) ) |
869 | { |
870 | PFR_CHECK( 2 ); |
871 | phy_font->standard_advance = PFR_NEXT_SHORT( p ); |
872 | } |
873 | |
874 | /* load the extra items when present */ |
875 | if ( flags & PFR_PHY_EXTRA_ITEMS ) |
876 | { |
877 | error = pfr_extra_items_parse( &p, limit, |
878 | pfr_phy_font_extra_items, phy_font ); |
879 | if ( error ) |
880 | goto Fail; |
881 | } |
882 | |
883 | /* In certain fonts, the auxiliary bytes contain interesting */ |
884 | /* information. These are not in the specification but can be */ |
885 | /* guessed by looking at the content of a few 'PFR0' fonts. */ |
886 | PFR_CHECK( 3 ); |
887 | num_aux = PFR_NEXT_ULONG( p ); |
888 | |
889 | if ( num_aux > 0 ) |
890 | { |
891 | FT_Byte* q = p; |
892 | FT_Byte* q2; |
893 | |
894 | |
895 | PFR_CHECK_SIZE( num_aux ); |
896 | p += num_aux; |
897 | |
898 | while ( num_aux > 0 ) |
899 | { |
900 | FT_UInt length, type; |
901 | |
902 | |
903 | if ( q + 4 > p ) |
904 | break; |
905 | |
906 | length = PFR_NEXT_USHORT( q ); |
907 | if ( length < 4 || length > num_aux ) |
908 | break; |
909 | |
910 | q2 = q + length - 2; |
911 | type = PFR_NEXT_USHORT( q ); |
912 | |
913 | switch ( type ) |
914 | { |
915 | case 1: |
916 | /* this seems to correspond to the font's family name, padded to */ |
917 | /* an even number of bytes with a zero byte appended if needed */ |
918 | error = pfr_aux_name_load( q, length - 4U, memory, |
919 | &phy_font->family_name ); |
920 | if ( error ) |
921 | goto Exit; |
922 | break; |
923 | |
924 | case 2: |
925 | if ( q + 32 > q2 ) |
926 | break; |
927 | |
928 | q += 10; |
929 | phy_font->ascent = PFR_NEXT_SHORT( q ); |
930 | phy_font->descent = PFR_NEXT_SHORT( q ); |
931 | phy_font->leading = PFR_NEXT_SHORT( q ); |
932 | break; |
933 | |
934 | case 3: |
935 | /* this seems to correspond to the font's style name, padded to */ |
936 | /* an even number of bytes with a zero byte appended if needed */ |
937 | error = pfr_aux_name_load( q, length - 4U, memory, |
938 | &phy_font->style_name ); |
939 | if ( error ) |
940 | goto Exit; |
941 | break; |
942 | |
943 | default: |
944 | ; |
945 | } |
946 | |
947 | q = q2; |
948 | num_aux -= length; |
949 | } |
950 | } |
951 | |
952 | /* read the blue values */ |
953 | { |
954 | FT_UInt n, count; |
955 | |
956 | |
957 | PFR_CHECK( 1 ); |
958 | phy_font->num_blue_values = count = PFR_NEXT_BYTE( p ); |
959 | |
960 | PFR_CHECK( count * 2 ); |
961 | |
962 | if ( FT_QNEW_ARRAY( phy_font->blue_values, count ) ) |
963 | goto Fail; |
964 | |
965 | for ( n = 0; n < count; n++ ) |
966 | phy_font->blue_values[n] = PFR_NEXT_SHORT( p ); |
967 | } |
968 | |
969 | PFR_CHECK( 8 ); |
970 | phy_font->blue_fuzz = PFR_NEXT_BYTE( p ); |
971 | phy_font->blue_scale = PFR_NEXT_BYTE( p ); |
972 | |
973 | phy_font->vertical.standard = PFR_NEXT_USHORT( p ); |
974 | phy_font->horizontal.standard = PFR_NEXT_USHORT( p ); |
975 | |
976 | /* read the character descriptors */ |
977 | { |
978 | FT_UInt n, count, Size; |
979 | |
980 | |
981 | phy_font->num_chars = count = PFR_NEXT_USHORT( p ); |
982 | phy_font->chars_offset = offset + (FT_Offset)( p - stream->cursor ); |
983 | |
984 | if ( !phy_font->num_chars ) |
985 | { |
986 | error = FT_THROW( Invalid_Table ); |
987 | FT_ERROR(( "pfr_phy_font_load: no glyphs\n" )); |
988 | goto Fail; |
989 | } |
990 | |
991 | Size = 1 + 1 + 2; |
992 | if ( flags & PFR_PHY_2BYTE_CHARCODE ) |
993 | Size += 1; |
994 | |
995 | if ( flags & PFR_PHY_PROPORTIONAL ) |
996 | Size += 2; |
997 | |
998 | if ( flags & PFR_PHY_ASCII_CODE ) |
999 | Size += 1; |
1000 | |
1001 | if ( flags & PFR_PHY_2BYTE_GPS_SIZE ) |
1002 | Size += 1; |
1003 | |
1004 | if ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) |
1005 | Size += 1; |
1006 | |
1007 | PFR_CHECK_SIZE( count * Size ); |
1008 | |
1009 | if ( FT_QNEW_ARRAY( phy_font->chars, count ) ) |
1010 | goto Fail; |
1011 | |
1012 | for ( n = 0; n < count; n++ ) |
1013 | { |
1014 | PFR_Char cur = &phy_font->chars[n]; |
1015 | |
1016 | |
1017 | cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE ) |
1018 | ? PFR_NEXT_USHORT( p ) |
1019 | : PFR_NEXT_BYTE( p ); |
1020 | |
1021 | cur->advance = ( flags & PFR_PHY_PROPORTIONAL ) |
1022 | ? PFR_NEXT_SHORT( p ) |
1023 | : phy_font->standard_advance; |
1024 | |
1025 | #if 0 |
1026 | cur->ascii = ( flags & PFR_PHY_ASCII_CODE ) |
1027 | ? PFR_NEXT_BYTE( p ) |
1028 | : 0; |
1029 | #else |
1030 | if ( flags & PFR_PHY_ASCII_CODE ) |
1031 | p += 1; |
1032 | #endif |
1033 | cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE ) |
1034 | ? PFR_NEXT_USHORT( p ) |
1035 | : PFR_NEXT_BYTE( p ); |
1036 | |
1037 | cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) |
1038 | ? PFR_NEXT_ULONG( p ) |
1039 | : PFR_NEXT_USHORT( p ); |
1040 | } |
1041 | } |
1042 | |
1043 | /* that's it! */ |
1044 | |
1045 | Fail: |
1046 | FT_FRAME_EXIT(); |
1047 | |
1048 | /* save position of bitmap info */ |
1049 | phy_font->bct_offset = FT_STREAM_POS(); |
1050 | phy_font->cursor = NULL; |
1051 | |
1052 | Exit: |
1053 | return error; |
1054 | |
1055 | Too_Short: |
1056 | error = FT_THROW( Invalid_Table ); |
1057 | FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" )); |
1058 | goto Fail; |
1059 | } |
1060 | |
1061 | |
1062 | /* END */ |
1063 | |