projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[FREETYPE] Update to v2.5.5. CORE-8888
[reactos.git] / reactos / lib / 3rdparty / freetype / src / pcf / pcfread.c
1 /* pcfread.c
2
3 FreeType font driver for pcf fonts
4
5 Copyright 2000-2010, 2012-2014 by
6 Francesco Zappa Nardelli
7
8 Permission is hereby granted, free of charge, to any person obtaining a copy
9 of this software and associated documentation files (the "Software"), to deal
10 in the Software without restriction, including without limitation the rights
11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 copies of the Software, and to permit persons to whom the Software is
13 furnished to do so, subject to the following conditions:
14
15 The above copyright notice and this permission notice shall be included in
16 all copies or substantial portions of the Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 THE SOFTWARE.
25 */
26
27
28 #include <ft2build.h>
29
30 #include FT_INTERNAL_DEBUG_H
31 #include FT_INTERNAL_STREAM_H
32 #include FT_INTERNAL_OBJECTS_H
33
34 #include "pcf.h"
35 #include "pcfread.h"
36
37 #include "pcferror.h"
38
39
40 /*************************************************************************/
41 /* */
42 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
43 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
44 /* messages during execution. */
45 /* */
46 #undef FT_COMPONENT
47 #define FT_COMPONENT trace_pcfread
48
49
50 #ifdef FT_DEBUG_LEVEL_TRACE
51 static const char* const tableNames[] =
52 {
53 "prop", "accl", "mtrcs", "bmps", "imtrcs",
54 "enc", "swidth", "names", "accel"
55 };
56 #endif
57
58
59 static
60 const FT_Frame_Field pcf_toc_header[] =
61 {
62 #undef FT_STRUCTURE
63 #define FT_STRUCTURE PCF_TocRec
64
65 FT_FRAME_START( 8 ),
66 FT_FRAME_ULONG_LE( version ),
67 FT_FRAME_ULONG_LE( count ),
68 FT_FRAME_END
69 };
70
71
72 static
73 const FT_Frame_Field pcf_table_header[] =
74 {
75 #undef FT_STRUCTURE
76 #define FT_STRUCTURE PCF_TableRec
77
78 FT_FRAME_START( 16 ),
79 FT_FRAME_ULONG_LE( type ),
80 FT_FRAME_ULONG_LE( format ),
81 FT_FRAME_ULONG_LE( size ), /* rounded up to a multiple of 4 */
82 FT_FRAME_ULONG_LE( offset ),
83 FT_FRAME_END
84 };
85
86
87 static FT_Error
88 pcf_read_TOC( FT_Stream stream,
89 PCF_Face face )
90 {
91 FT_Error error;
92 PCF_Toc toc = &face->toc;
93 PCF_Table tables;
94
95 FT_Memory memory = FT_FACE( face )->memory;
96 FT_UInt n;
97
98 FT_ULong size;
99
100
101 if ( FT_STREAM_SEEK( 0 ) ||
102 FT_STREAM_READ_FIELDS( pcf_toc_header, toc ) )
103 return FT_THROW( Cannot_Open_Resource );
104
105 if ( toc->version != PCF_FILE_VERSION ||
106 toc->count > FT_ARRAY_MAX( face->toc.tables ) ||
107 toc->count == 0 )
108 return FT_THROW( Invalid_File_Format );
109
110 if ( FT_NEW_ARRAY( face->toc.tables, toc->count ) )
111 return FT_THROW( Out_Of_Memory );
112
113 tables = face->toc.tables;
114 for ( n = 0; n < toc->count; n++ )
115 {
116 if ( FT_STREAM_READ_FIELDS( pcf_table_header, tables ) )
117 goto Exit;
118 tables++;
119 }
120
121 /* Sort tables and check for overlaps. Because they are almost */
122 /* always ordered already, an in-place bubble sort with simultaneous */
123 /* boundary checking seems appropriate. */
124 tables = face->toc.tables;
125
126 for ( n = 0; n < toc->count - 1; n++ )
127 {
128 FT_UInt i, have_change;
129
130
131 have_change = 0;
132
133 for ( i = 0; i < toc->count - 1 - n; i++ )
134 {
135 PCF_TableRec tmp;
136
137
138 if ( tables[i].offset > tables[i + 1].offset )
139 {
140 tmp = tables[i];
141 tables[i] = tables[i + 1];
142 tables[i + 1] = tmp;
143
144 have_change = 1;
145 }
146
147 if ( ( tables[i].size > tables[i + 1].offset ) ||
148 ( tables[i].offset > tables[i + 1].offset - tables[i].size ) )
149 {
150 error = FT_THROW( Invalid_Offset );
151 goto Exit;
152 }
153 }
154
155 if ( !have_change )
156 break;
157 }
158
159 /*
160 * We now check whether the `size' and `offset' values are reasonable:
161 * `offset' + `size' must not exceed the stream size.
162 *
163 * Note, however, that X11's `pcfWriteFont' routine (used by the
164 * `bdftopcf' program to create PDF font files) has two special
165 * features.
166 *
167 * - It always assigns the accelerator table a size of 100 bytes in the
168 * TOC, regardless of its real size, which can vary between 34 and 72
169 * bytes.
170 *
171 * - Due to the way the routine is designed, it ships out the last font
172 * table with its real size, ignoring the TOC's size value. Since
173 * the TOC size values are always rounded up to a multiple of 4, the
174 * difference can be up to three bytes for all tables except the
175 * accelerator table, for which the difference can be as large as 66
176 * bytes.
177 *
178 */
179
180 tables = face->toc.tables;
181 size = stream->size;
182
183 for ( n = 0; n < toc->count - 1; n++ )
184 {
185 /* we need two checks to avoid overflow */
186 if ( ( tables->size > size ) ||
187 ( tables->offset > size - tables->size ) )
188 {
189 error = FT_THROW( Invalid_Table );
190 goto Exit;
191 }
192 tables++;
193 }
194
195 /* only check `tables->offset' for last table element ... */
196 if ( ( tables->offset > size ) )
197 {
198 error = FT_THROW( Invalid_Table );
199 goto Exit;
200 }
201 /* ... and adjust `tables->size' to the real value if necessary */
202 if ( tables->size > size - tables->offset )
203 tables->size = size - tables->offset;
204
205 #ifdef FT_DEBUG_LEVEL_TRACE
206
207 {
208 FT_UInt i, j;
209 const char* name = "?";
210
211
212 FT_TRACE4(( "pcf_read_TOC:\n" ));
213
214 FT_TRACE4(( " number of tables: %ld\n", face->toc.count ));
215
216 tables = face->toc.tables;
217 for ( i = 0; i < toc->count; i++ )
218 {
219 for ( j = 0; j < sizeof ( tableNames ) / sizeof ( tableNames[0] );
220 j++ )
221 if ( tables[i].type == (FT_UInt)( 1 << j ) )
222 name = tableNames[j];
223
224 FT_TRACE4(( " %d: type=%s, format=0x%X, "
225 "size=%ld (0x%lX), offset=%ld (0x%lX)\n",
226 i, name,
227 tables[i].format,
228 tables[i].size, tables[i].size,
229 tables[i].offset, tables[i].offset ));
230 }
231 }
232
233 #endif
234
235 return FT_Err_Ok;
236
237 Exit:
238 FT_FREE( face->toc.tables );
239 return error;
240 }
241
242
243 #define PCF_METRIC_SIZE 12
244
245 static
246 const FT_Frame_Field pcf_metric_header[] =
247 {
248 #undef FT_STRUCTURE
249 #define FT_STRUCTURE PCF_MetricRec
250
251 FT_FRAME_START( PCF_METRIC_SIZE ),
252 FT_FRAME_SHORT_LE( leftSideBearing ),
253 FT_FRAME_SHORT_LE( rightSideBearing ),
254 FT_FRAME_SHORT_LE( characterWidth ),
255 FT_FRAME_SHORT_LE( ascent ),
256 FT_FRAME_SHORT_LE( descent ),
257 FT_FRAME_SHORT_LE( attributes ),
258 FT_FRAME_END
259 };
260
261
262 static
263 const FT_Frame_Field pcf_metric_msb_header[] =
264 {
265 #undef FT_STRUCTURE
266 #define FT_STRUCTURE PCF_MetricRec
267
268 FT_FRAME_START( PCF_METRIC_SIZE ),
269 FT_FRAME_SHORT( leftSideBearing ),
270 FT_FRAME_SHORT( rightSideBearing ),
271 FT_FRAME_SHORT( characterWidth ),
272 FT_FRAME_SHORT( ascent ),
273 FT_FRAME_SHORT( descent ),
274 FT_FRAME_SHORT( attributes ),
275 FT_FRAME_END
276 };
277
278
279 #define PCF_COMPRESSED_METRIC_SIZE 5
280
281 static
282 const FT_Frame_Field pcf_compressed_metric_header[] =
283 {
284 #undef FT_STRUCTURE
285 #define FT_STRUCTURE PCF_Compressed_MetricRec
286
287 FT_FRAME_START( PCF_COMPRESSED_METRIC_SIZE ),
288 FT_FRAME_BYTE( leftSideBearing ),
289 FT_FRAME_BYTE( rightSideBearing ),
290 FT_FRAME_BYTE( characterWidth ),
291 FT_FRAME_BYTE( ascent ),
292 FT_FRAME_BYTE( descent ),
293 FT_FRAME_END
294 };
295
296
297 static FT_Error
298 pcf_get_metric( FT_Stream stream,
299 FT_ULong format,
300 PCF_Metric metric )
301 {
302 FT_Error error = FT_Err_Ok;
303
304
305 if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
306 {
307 const FT_Frame_Field* fields;
308
309
310 /* parsing normal metrics */
311 fields = PCF_BYTE_ORDER( format ) == MSBFirst
312 ? pcf_metric_msb_header
313 : pcf_metric_header;
314
315 /* the following sets `error' but doesn't return in case of failure */
316 (void)FT_STREAM_READ_FIELDS( fields, metric );
317 }
318 else
319 {
320 PCF_Compressed_MetricRec compr;
321
322
323 /* parsing compressed metrics */
324 if ( FT_STREAM_READ_FIELDS( pcf_compressed_metric_header, &compr ) )
325 goto Exit;
326
327 metric->leftSideBearing = (FT_Short)( compr.leftSideBearing - 0x80 );
328 metric->rightSideBearing = (FT_Short)( compr.rightSideBearing - 0x80 );
329 metric->characterWidth = (FT_Short)( compr.characterWidth - 0x80 );
330 metric->ascent = (FT_Short)( compr.ascent - 0x80 );
331 metric->descent = (FT_Short)( compr.descent - 0x80 );
332 metric->attributes = 0;
333 }
334
335 Exit:
336 return error;
337 }
338
339
340 static FT_Error
341 pcf_seek_to_table_type( FT_Stream stream,
342 PCF_Table tables,
343 FT_ULong ntables, /* same as PCF_Toc->count */
344 FT_ULong type,
345 FT_ULong *aformat,
346 FT_ULong *asize )
347 {
348 FT_Error error = FT_ERR( Invalid_File_Format );
349 FT_ULong i;
350
351
352 for ( i = 0; i < ntables; i++ )
353 if ( tables[i].type == type )
354 {
355 if ( stream->pos > tables[i].offset )
356 {
357 error = FT_THROW( Invalid_Stream_Skip );
358 goto Fail;
359 }
360
361 if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) )
362 {
363 error = FT_THROW( Invalid_Stream_Skip );
364 goto Fail;
365 }
366
367 *asize = tables[i].size;
368 *aformat = tables[i].format;
369
370 return FT_Err_Ok;
371 }
372
373 Fail:
374 *asize = 0;
375 return error;
376 }
377
378
379 static FT_Bool
380 pcf_has_table_type( PCF_Table tables,
381 FT_ULong ntables, /* same as PCF_Toc->count */
382 FT_ULong type )
383 {
384 FT_ULong i;
385
386
387 for ( i = 0; i < ntables; i++ )
388 if ( tables[i].type == type )
389 return TRUE;
390
391 return FALSE;
392 }
393
394
395 #define PCF_PROPERTY_SIZE 9
396
397 static
398 const FT_Frame_Field pcf_property_header[] =
399 {
400 #undef FT_STRUCTURE
401 #define FT_STRUCTURE PCF_ParsePropertyRec
402
403 FT_FRAME_START( PCF_PROPERTY_SIZE ),
404 FT_FRAME_LONG_LE( name ),
405 FT_FRAME_BYTE ( isString ),
406 FT_FRAME_LONG_LE( value ),
407 FT_FRAME_END
408 };
409
410
411 static
412 const FT_Frame_Field pcf_property_msb_header[] =
413 {
414 #undef FT_STRUCTURE
415 #define FT_STRUCTURE PCF_ParsePropertyRec
416
417 FT_FRAME_START( PCF_PROPERTY_SIZE ),
418 FT_FRAME_LONG( name ),
419 FT_FRAME_BYTE( isString ),
420 FT_FRAME_LONG( value ),
421 FT_FRAME_END
422 };
423
424
425 FT_LOCAL_DEF( PCF_Property )
426 pcf_find_property( PCF_Face face,
427 const FT_String* prop )
428 {
429 PCF_Property properties = face->properties;
430 FT_Bool found = 0;
431 int i;
432
433
434 for ( i = 0 ; i < face->nprops && !found; i++ )
435 {
436 if ( !ft_strcmp( properties[i].name, prop ) )
437 found = 1;
438 }
439
440 if ( found )
441 return properties + i - 1;
442 else
443 return NULL;
444 }
445
446
447 static FT_Error
448 pcf_get_properties( FT_Stream stream,
449 PCF_Face face )
450 {
451 PCF_ParseProperty props = 0;
452 PCF_Property properties = NULL;
453 FT_ULong nprops, i;
454 FT_ULong format, size;
455 FT_Error error;
456 FT_Memory memory = FT_FACE( face )->memory;
457 FT_ULong string_size;
458 FT_String* strings = 0;
459
460
461 error = pcf_seek_to_table_type( stream,
462 face->toc.tables,
463 face->toc.count,
464 PCF_PROPERTIES,
465 &format,
466 &size );
467 if ( error )
468 goto Bail;
469
470 if ( FT_READ_ULONG_LE( format ) )
471 goto Bail;
472
473 FT_TRACE4(( "pcf_get_properties:\n" ));
474
475 FT_TRACE4(( " format = %ld\n", format ));
476
477 if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
478 goto Bail;
479
480 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
481 (void)FT_READ_ULONG( nprops );
482 else
483 (void)FT_READ_ULONG_LE( nprops );
484 if ( error )
485 goto Bail;
486
487 FT_TRACE4(( " nprop = %d (truncate %d props)\n",
488 (int)nprops, nprops - (int)nprops ));
489
490 nprops = (int)nprops;
491
492 /* rough estimate */
493 if ( nprops > size / PCF_PROPERTY_SIZE )
494 {
495 error = FT_THROW( Invalid_Table );
496 goto Bail;
497 }
498
499 face->nprops = (int)nprops;
500
501 if ( FT_NEW_ARRAY( props, nprops ) )
502 goto Bail;
503
504 for ( i = 0; i < nprops; i++ )
505 {
506 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
507 {
508 if ( FT_STREAM_READ_FIELDS( pcf_property_msb_header, props + i ) )
509 goto Bail;
510 }
511 else
512 {
513 if ( FT_STREAM_READ_FIELDS( pcf_property_header, props + i ) )
514 goto Bail;
515 }
516 }
517
518 /* pad the property array */
519 /* */
520 /* clever here - nprops is the same as the number of odd-units read, */
521 /* as only isStringProp are odd length (Keith Packard) */
522 /* */
523 if ( nprops & 3 )
524 {
525 i = 4 - ( nprops & 3 );
526 if ( FT_STREAM_SKIP( i ) )
527 {
528 error = FT_THROW( Invalid_Stream_Skip );
529 goto Bail;
530 }
531 }
532
533 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
534 (void)FT_READ_ULONG( string_size );
535 else
536 (void)FT_READ_ULONG_LE( string_size );
537 if ( error )
538 goto Bail;
539
540 FT_TRACE4(( " string_size = %ld\n", string_size ));
541
542 /* rough estimate */
543 if ( string_size > size - nprops * PCF_PROPERTY_SIZE )
544 {
545 error = FT_THROW( Invalid_Table );
546 goto Bail;
547 }
548
549 /* allocate one more byte so that we have a final null byte */
550 if ( FT_NEW_ARRAY( strings, string_size + 1 ) )
551 goto Bail;
552
553 error = FT_Stream_Read( stream, (FT_Byte*)strings, string_size );
554 if ( error )
555 goto Bail;
556
557 if ( FT_NEW_ARRAY( properties, nprops ) )
558 goto Bail;
559
560 face->properties = properties;
561
562 for ( i = 0; i < nprops; i++ )
563 {
564 FT_Long name_offset = props[i].name;
565
566
567 if ( ( name_offset < 0 ) ||
568 ( (FT_ULong)name_offset > string_size ) )
569 {
570 error = FT_THROW( Invalid_Offset );
571 goto Bail;
572 }
573
574 if ( FT_STRDUP( properties[i].name, strings + name_offset ) )
575 goto Bail;
576
577 FT_TRACE4(( " %s:", properties[i].name ));
578
579 properties[i].isString = props[i].isString;
580
581 if ( props[i].isString )
582 {
583 FT_Long value_offset = props[i].value;
584
585
586 if ( ( value_offset < 0 ) ||
587 ( (FT_ULong)value_offset > string_size ) )
588 {
589 error = FT_THROW( Invalid_Offset );
590 goto Bail;
591 }
592
593 if ( FT_STRDUP( properties[i].value.atom, strings + value_offset ) )
594 goto Bail;
595
596 FT_TRACE4(( " `%s'\n", properties[i].value.atom ));
597 }
598 else
599 {
600 properties[i].value.l = props[i].value;
601
602 FT_TRACE4(( " %d\n", properties[i].value.l ));
603 }
604 }
605
606 error = FT_Err_Ok;
607
608 Bail:
609 FT_FREE( props );
610 FT_FREE( strings );
611
612 return error;
613 }
614
615
616 static FT_Error
617 pcf_get_metrics( FT_Stream stream,
618 PCF_Face face )
619 {
620 FT_Error error;
621 FT_Memory memory = FT_FACE( face )->memory;
622 FT_ULong format, size;
623 PCF_Metric metrics = 0;
624 FT_ULong nmetrics, i;
625
626
627 error = pcf_seek_to_table_type( stream,
628 face->toc.tables,
629 face->toc.count,
630 PCF_METRICS,
631 &format,
632 &size );
633 if ( error )
634 return error;
635
636 if ( FT_READ_ULONG_LE( format ) )
637 goto Bail;
638
639 if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) &&
640 !PCF_FORMAT_MATCH( format, PCF_COMPRESSED_METRICS ) )
641 return FT_THROW( Invalid_File_Format );
642
643 if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
644 {
645 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
646 (void)FT_READ_ULONG( nmetrics );
647 else
648 (void)FT_READ_ULONG_LE( nmetrics );
649 }
650 else
651 {
652 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
653 (void)FT_READ_USHORT( nmetrics );
654 else
655 (void)FT_READ_USHORT_LE( nmetrics );
656 }
657 if ( error )
658 return FT_THROW( Invalid_File_Format );
659
660 face->nmetrics = nmetrics;
661
662 if ( !nmetrics )
663 return FT_THROW( Invalid_Table );
664
665 FT_TRACE4(( "pcf_get_metrics:\n" ));
666
667 FT_TRACE4(( " number of metrics: %d\n", nmetrics ));
668
669 /* rough estimate */
670 if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
671 {
672 if ( nmetrics > size / PCF_METRIC_SIZE )
673 return FT_THROW( Invalid_Table );
674 }
675 else
676 {
677 if ( nmetrics > size / PCF_COMPRESSED_METRIC_SIZE )
678 return FT_THROW( Invalid_Table );
679 }
680
681 if ( FT_NEW_ARRAY( face->metrics, nmetrics ) )
682 return FT_THROW( Out_Of_Memory );
683
684 metrics = face->metrics;
685 for ( i = 0; i < nmetrics; i++, metrics++ )
686 {
687 error = pcf_get_metric( stream, format, metrics );
688
689 metrics->bits = 0;
690
691 FT_TRACE5(( " idx %d: width=%d, "
692 "lsb=%d, rsb=%d, ascent=%d, descent=%d, swidth=%d\n",
693 i,
694 metrics->characterWidth,
695 metrics->leftSideBearing,
696 metrics->rightSideBearing,
697 metrics->ascent,
698 metrics->descent,
699 metrics->attributes ));
700
701 if ( error )
702 break;
703
704 /* sanity checks -- those values are used in `PCF_Glyph_Load' to */
705 /* compute a glyph's bitmap dimensions, thus setting them to zero in */
706 /* case of an error disables this particular glyph only */
707 if ( metrics->rightSideBearing < metrics->leftSideBearing ||
708 metrics->ascent + metrics->descent < 0 )
709 {
710 metrics->characterWidth = 0;
711 metrics->leftSideBearing = 0;
712 metrics->rightSideBearing = 0;
713 metrics->ascent = 0;
714 metrics->descent = 0;
715
716 FT_TRACE0(( "pcf_get_metrics:"
717 " invalid metrics for glyph %d\n", i ));
718 }
719 }
720
721 if ( error )
722 FT_FREE( face->metrics );
723
724 Bail:
725 return error;
726 }
727
728
729 static FT_Error
730 pcf_get_bitmaps( FT_Stream stream,
731 PCF_Face face )
732 {
733 FT_Error error;
734 FT_Memory memory = FT_FACE( face )->memory;
735 FT_Long* offsets = NULL;
736 FT_Long bitmapSizes[GLYPHPADOPTIONS];
737 FT_ULong format, size;
738 FT_ULong nbitmaps, i, sizebitmaps = 0;
739
740
741 error = pcf_seek_to_table_type( stream,
742 face->toc.tables,
743 face->toc.count,
744 PCF_BITMAPS,
745 &format,
746 &size );
747 if ( error )
748 return error;
749
750 error = FT_Stream_EnterFrame( stream, 8 );
751 if ( error )
752 return error;
753
754 format = FT_GET_ULONG_LE();
755 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
756 nbitmaps = FT_GET_ULONG();
757 else
758 nbitmaps = FT_GET_ULONG_LE();
759
760 FT_Stream_ExitFrame( stream );
761
762 if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
763 return FT_THROW( Invalid_File_Format );
764
765 FT_TRACE4(( "pcf_get_bitmaps:\n" ));
766
767 FT_TRACE4(( " number of bitmaps: %d\n", nbitmaps ));
768
769 /* XXX: PCF_Face->nmetrics is signed FT_Long, see pcf.h */
770 if ( face->nmetrics < 0 || nbitmaps != (FT_ULong)face->nmetrics )
771 return FT_THROW( Invalid_File_Format );
772
773 if ( FT_NEW_ARRAY( offsets, nbitmaps ) )
774 return error;
775
776 for ( i = 0; i < nbitmaps; i++ )
777 {
778 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
779 (void)FT_READ_LONG( offsets[i] );
780 else
781 (void)FT_READ_LONG_LE( offsets[i] );
782
783 FT_TRACE5(( " bitmap %d: offset %ld (0x%lX)\n",
784 i, offsets[i], offsets[i] ));
785 }
786 if ( error )
787 goto Bail;
788
789 for ( i = 0; i < GLYPHPADOPTIONS; i++ )
790 {
791 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
792 (void)FT_READ_LONG( bitmapSizes[i] );
793 else
794 (void)FT_READ_LONG_LE( bitmapSizes[i] );
795 if ( error )
796 goto Bail;
797
798 sizebitmaps = bitmapSizes[PCF_GLYPH_PAD_INDEX( format )];
799
800 FT_TRACE4(( " padding %d implies a size of %ld\n", i, bitmapSizes[i] ));
801 }
802
803 FT_TRACE4(( " %d bitmaps, padding index %ld\n",
804 nbitmaps,
805 PCF_GLYPH_PAD_INDEX( format ) ));
806 FT_TRACE4(( " bitmap size = %d\n", sizebitmaps ));
807
808 FT_UNUSED( sizebitmaps ); /* only used for debugging */
809
810 for ( i = 0; i < nbitmaps; i++ )
811 {
812 /* rough estimate */
813 if ( ( offsets[i] < 0 ) ||
814 ( (FT_ULong)offsets[i] > size ) )
815 {
816 FT_TRACE0(( "pcf_get_bitmaps:"
817 " invalid offset to bitmap data of glyph %d\n", i ));
818 }
819 else
820 face->metrics[i].bits = stream->pos + offsets[i];
821 }
822
823 face->bitmapsFormat = format;
824
825 Bail:
826 FT_FREE( offsets );
827 return error;
828 }
829
830
831 static FT_Error
832 pcf_get_encodings( FT_Stream stream,
833 PCF_Face face )
834 {
835 FT_Error error;
836 FT_Memory memory = FT_FACE( face )->memory;
837 FT_ULong format, size;
838 int firstCol, lastCol;
839 int firstRow, lastRow;
840 int nencoding, encodingOffset;
841 int i, j, k;
842 PCF_Encoding encoding = NULL;
843
844
845 error = pcf_seek_to_table_type( stream,
846 face->toc.tables,
847 face->toc.count,
848 PCF_BDF_ENCODINGS,
849 &format,
850 &size );
851 if ( error )
852 return error;
853
854 error = FT_Stream_EnterFrame( stream, 14 );
855 if ( error )
856 return error;
857
858 format = FT_GET_ULONG_LE();
859
860 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
861 {
862 firstCol = FT_GET_SHORT();
863 lastCol = FT_GET_SHORT();
864 firstRow = FT_GET_SHORT();
865 lastRow = FT_GET_SHORT();
866 face->defaultChar = FT_GET_SHORT();
867 }
868 else
869 {
870 firstCol = FT_GET_SHORT_LE();
871 lastCol = FT_GET_SHORT_LE();
872 firstRow = FT_GET_SHORT_LE();
873 lastRow = FT_GET_SHORT_LE();
874 face->defaultChar = FT_GET_SHORT_LE();
875 }
876
877 FT_Stream_ExitFrame( stream );
878
879 if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
880 return FT_THROW( Invalid_File_Format );
881
882 /* sanity checks */
883 if ( firstCol < 0 ||
884 firstCol > lastCol ||
885 lastCol > 0xFF ||
886 firstRow < 0 ||
887 firstRow > lastRow ||
888 lastRow > 0xFF )
889 return FT_THROW( Invalid_Table );
890
891 FT_TRACE4(( "pdf_get_encodings:\n" ));
892
893 FT_TRACE4(( " firstCol %d, lastCol %d, firstRow %d, lastRow %d\n",
894 firstCol, lastCol, firstRow, lastRow ));
895
896 nencoding = ( lastCol - firstCol + 1 ) * ( lastRow - firstRow + 1 );
897
898 if ( FT_NEW_ARRAY( encoding, nencoding ) )
899 return FT_THROW( Out_Of_Memory );
900
901 error = FT_Stream_EnterFrame( stream, 2 * nencoding );
902 if ( error )
903 goto Bail;
904
905 k = 0;
906 for ( i = firstRow; i <= lastRow; i++ )
907 {
908 for ( j = firstCol; j <= lastCol; j++ )
909 {
910 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
911 encodingOffset = FT_GET_SHORT();
912 else
913 encodingOffset = FT_GET_SHORT_LE();
914
915 if ( encodingOffset != -1 )
916 {
917 encoding[k].enc = i * 256 + j;
918 encoding[k].glyph = (FT_Short)encodingOffset;
919
920 FT_TRACE5(( " code %d (0x%04X): idx %d\n",
921 encoding[k].enc, encoding[k].enc, encoding[k].glyph ));
922
923 k++;
924 }
925 }
926 }
927 FT_Stream_ExitFrame( stream );
928
929 if ( FT_RENEW_ARRAY( encoding, nencoding, k ) )
930 goto Bail;
931
932 face->nencodings = k;
933 face->encodings = encoding;
934
935 return error;
936
937 Bail:
938 FT_FREE( encoding );
939 return error;
940 }
941
942
943 static
944 const FT_Frame_Field pcf_accel_header[] =
945 {
946 #undef FT_STRUCTURE
947 #define FT_STRUCTURE PCF_AccelRec
948
949 FT_FRAME_START( 20 ),
950 FT_FRAME_BYTE ( noOverlap ),
951 FT_FRAME_BYTE ( constantMetrics ),
952 FT_FRAME_BYTE ( terminalFont ),
953 FT_FRAME_BYTE ( constantWidth ),
954 FT_FRAME_BYTE ( inkInside ),
955 FT_FRAME_BYTE ( inkMetrics ),
956 FT_FRAME_BYTE ( drawDirection ),
957 FT_FRAME_SKIP_BYTES( 1 ),
958 FT_FRAME_LONG_LE ( fontAscent ),
959 FT_FRAME_LONG_LE ( fontDescent ),
960 FT_FRAME_LONG_LE ( maxOverlap ),
961 FT_FRAME_END
962 };
963
964
965 static
966 const FT_Frame_Field pcf_accel_msb_header[] =
967 {
968 #undef FT_STRUCTURE
969 #define FT_STRUCTURE PCF_AccelRec
970
971 FT_FRAME_START( 20 ),
972 FT_FRAME_BYTE ( noOverlap ),
973 FT_FRAME_BYTE ( constantMetrics ),
974 FT_FRAME_BYTE ( terminalFont ),
975 FT_FRAME_BYTE ( constantWidth ),
976 FT_FRAME_BYTE ( inkInside ),
977 FT_FRAME_BYTE ( inkMetrics ),
978 FT_FRAME_BYTE ( drawDirection ),
979 FT_FRAME_SKIP_BYTES( 1 ),
980 FT_FRAME_LONG ( fontAscent ),
981 FT_FRAME_LONG ( fontDescent ),
982 FT_FRAME_LONG ( maxOverlap ),
983 FT_FRAME_END
984 };
985
986
987 static FT_Error
988 pcf_get_accel( FT_Stream stream,
989 PCF_Face face,
990 FT_ULong type )
991 {
992 FT_ULong format, size;
993 FT_Error error;
994 PCF_Accel accel = &face->accel;
995
996
997 error = pcf_seek_to_table_type( stream,
998 face->toc.tables,
999 face->toc.count,
1000 type,
1001 &format,
1002 &size );
1003 if ( error )
1004 goto Bail;
1005
1006 if ( FT_READ_ULONG_LE( format ) )
1007 goto Bail;
1008
1009 if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) &&
1010 !PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
1011 goto Bail;
1012
1013 if ( PCF_BYTE_ORDER( format ) == MSBFirst )
1014 {
1015 if ( FT_STREAM_READ_FIELDS( pcf_accel_msb_header, accel ) )
1016 goto Bail;
1017 }
1018 else
1019 {
1020 if ( FT_STREAM_READ_FIELDS( pcf_accel_header, accel ) )
1021 goto Bail;
1022 }
1023
1024 error = pcf_get_metric( stream,
1025 format & ( ~PCF_FORMAT_MASK ),
1026 &(accel->minbounds) );
1027 if ( error )
1028 goto Bail;
1029
1030 error = pcf_get_metric( stream,
1031 format & ( ~PCF_FORMAT_MASK ),
1032 &(accel->maxbounds) );
1033 if ( error )
1034 goto Bail;
1035
1036 if ( PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
1037 {
1038 error = pcf_get_metric( stream,
1039 format & ( ~PCF_FORMAT_MASK ),
1040 &(accel->ink_minbounds) );
1041 if ( error )
1042 goto Bail;
1043
1044 error = pcf_get_metric( stream,
1045 format & ( ~PCF_FORMAT_MASK ),
1046 &(accel->ink_maxbounds) );
1047 if ( error )
1048 goto Bail;
1049 }
1050 else
1051 {
1052 accel->ink_minbounds = accel->minbounds; /* I'm not sure about this */
1053 accel->ink_maxbounds = accel->maxbounds;
1054 }
1055
1056 Bail:
1057 return error;
1058 }
1059
1060
1061 static FT_Error
1062 pcf_interpret_style( PCF_Face pcf )
1063 {
1064 FT_Error error = FT_Err_Ok;
1065 FT_Face face = FT_FACE( pcf );
1066 FT_Memory memory = face->memory;
1067
1068 PCF_Property prop;
1069
1070 size_t nn, len;
1071 char* strings[4] = { NULL, NULL, NULL, NULL };
1072 size_t lengths[4];
1073
1074
1075 face->style_flags = 0;
1076
1077 prop = pcf_find_property( pcf, "SLANT" );
1078 if ( prop && prop->isString &&
1079 ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' ||
1080 *(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) )
1081 {
1082 face->style_flags |= FT_STYLE_FLAG_ITALIC;
1083 strings[2] = ( *(prop->value.atom) == 'O' ||
1084 *(prop->value.atom) == 'o' ) ? (char *)"Oblique"
1085 : (char *)"Italic";
1086 }
1087
1088 prop = pcf_find_property( pcf, "WEIGHT_NAME" );
1089 if ( prop && prop->isString &&
1090 ( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) )
1091 {
1092 face->style_flags |= FT_STYLE_FLAG_BOLD;
1093 strings[1] = (char*)"Bold";
1094 }
1095
1096 prop = pcf_find_property( pcf, "SETWIDTH_NAME" );
1097 if ( prop && prop->isString &&
1098 *(prop->value.atom) &&
1099 !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
1100 strings[3] = (char*)( prop->value.atom );
1101
1102 prop = pcf_find_property( pcf, "ADD_STYLE_NAME" );
1103 if ( prop && prop->isString &&
1104 *(prop->value.atom) &&
1105 !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
1106 strings[0] = (char*)( prop->value.atom );
1107
1108 for ( len = 0, nn = 0; nn < 4; nn++ )
1109 {
1110 lengths[nn] = 0;
1111 if ( strings[nn] )
1112 {
1113 lengths[nn] = ft_strlen( strings[nn] );
1114 len += lengths[nn] + 1;
1115 }
1116 }
1117
1118 if ( len == 0 )
1119 {
1120 strings[0] = (char*)"Regular";
1121 lengths[0] = ft_strlen( strings[0] );
1122 len = lengths[0] + 1;
1123 }
1124
1125 {
1126 char* s;
1127
1128
1129 if ( FT_ALLOC( face->style_name, len ) )
1130 return error;
1131
1132 s = face->style_name;
1133
1134 for ( nn = 0; nn < 4; nn++ )
1135 {
1136 char* src = strings[nn];
1137
1138
1139 len = lengths[nn];
1140
1141 if ( src == NULL )
1142 continue;
1143
1144 /* separate elements with a space */
1145 if ( s != face->style_name )
1146 *s++ = ' ';
1147
1148 ft_memcpy( s, src, len );
1149
1150 /* need to convert spaces to dashes for */
1151 /* add_style_name and setwidth_name */
1152 if ( nn == 0 || nn == 3 )
1153 {
1154 size_t mm;
1155
1156
1157 for ( mm = 0; mm < len; mm++ )
1158 if ( s[mm] == ' ' )
1159 s[mm] = '-';
1160 }
1161
1162 s += len;
1163 }
1164 *s = 0;
1165 }
1166
1167 return error;
1168 }
1169
1170
1171 FT_LOCAL_DEF( FT_Error )
1172 pcf_load_font( FT_Stream stream,
1173 PCF_Face face )
1174 {
1175 FT_Error error;
1176 FT_Memory memory = FT_FACE( face )->memory;
1177 FT_Bool hasBDFAccelerators;
1178
1179
1180 error = pcf_read_TOC( stream, face );
1181 if ( error )
1182 goto Exit;
1183
1184 error = pcf_get_properties( stream, face );
1185 if ( error )
1186 goto Exit;
1187
1188 /* Use the old accelerators if no BDF accelerators are in the file. */
1189 hasBDFAccelerators = pcf_has_table_type( face->toc.tables,
1190 face->toc.count,
1191 PCF_BDF_ACCELERATORS );
1192 if ( !hasBDFAccelerators )
1193 {
1194 error = pcf_get_accel( stream, face, PCF_ACCELERATORS );
1195 if ( error )
1196 goto Exit;
1197 }
1198
1199 /* metrics */
1200 error = pcf_get_metrics( stream, face );
1201 if ( error )
1202 goto Exit;
1203
1204 /* bitmaps */
1205 error = pcf_get_bitmaps( stream, face );
1206 if ( error )
1207 goto Exit;
1208
1209 /* encodings */
1210 error = pcf_get_encodings( stream, face );
1211 if ( error )
1212 goto Exit;
1213
1214 /* BDF style accelerators (i.e. bounds based on encoded glyphs) */
1215 if ( hasBDFAccelerators )
1216 {
1217 error = pcf_get_accel( stream, face, PCF_BDF_ACCELERATORS );
1218 if ( error )
1219 goto Exit;
1220 }
1221
1222 /* XXX: TO DO: inkmetrics and glyph_names are missing */
1223
1224 /* now construct the face object */
1225 {
1226 FT_Face root = FT_FACE( face );
1227 PCF_Property prop;
1228
1229
1230 root->num_faces = 1;
1231 root->face_index = 0;
1232
1233 root->face_flags |= FT_FACE_FLAG_FIXED_SIZES |
1234 FT_FACE_FLAG_HORIZONTAL |
1235 FT_FACE_FLAG_FAST_GLYPHS;
1236
1237 if ( face->accel.constantWidth )
1238 root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
1239
1240 if ( ( error = pcf_interpret_style( face ) ) != 0 )
1241 goto Exit;
1242
1243 prop = pcf_find_property( face, "FAMILY_NAME" );
1244 if ( prop && prop->isString )
1245 {
1246 if ( FT_STRDUP( root->family_name, prop->value.atom ) )
1247 goto Exit;
1248 }
1249 else
1250 root->family_name = NULL;
1251
1252 /*
1253 * Note: We shift all glyph indices by +1 since we must
1254 * respect the convention that glyph 0 always corresponds
1255 * to the `missing glyph'.
1256 *
1257 * This implies bumping the number of `available' glyphs by 1.
1258 */
1259 root->num_glyphs = face->nmetrics + 1;
1260
1261 root->num_fixed_sizes = 1;
1262 if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
1263 goto Exit;
1264
1265 {
1266 FT_Bitmap_Size* bsize = root->available_sizes;
1267 FT_Short resolution_x = 0, resolution_y = 0;
1268
1269
1270 FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
1271
1272 #if 0
1273 bsize->height = face->accel.maxbounds.ascent << 6;
1274 #endif
1275 bsize->height = (FT_Short)( face->accel.fontAscent +
1276 face->accel.fontDescent );
1277
1278 prop = pcf_find_property( face, "AVERAGE_WIDTH" );
1279 if ( prop )
1280 bsize->width = (FT_Short)( ( prop->value.l + 5 ) / 10 );
1281 else
1282 bsize->width = (FT_Short)( bsize->height * 2/3 );
1283
1284 prop = pcf_find_property( face, "POINT_SIZE" );
1285 if ( prop )
1286 /* convert from 722.7 decipoints to 72 points per inch */
1287 bsize->size =
1288 (FT_Pos)( ( prop->value.l * 64 * 7200 + 36135L ) / 72270L );
1289
1290 prop = pcf_find_property( face, "PIXEL_SIZE" );
1291 if ( prop )
1292 bsize->y_ppem = (FT_Short)prop->value.l << 6;
1293
1294 prop = pcf_find_property( face, "RESOLUTION_X" );
1295 if ( prop )
1296 resolution_x = (FT_Short)prop->value.l;
1297
1298 prop = pcf_find_property( face, "RESOLUTION_Y" );
1299 if ( prop )
1300 resolution_y = (FT_Short)prop->value.l;
1301
1302 if ( bsize->y_ppem == 0 )
1303 {
1304 bsize->y_ppem = bsize->size;
1305 if ( resolution_y )
1306 bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
1307 }
1308 if ( resolution_x && resolution_y )
1309 bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
1310 else
1311 bsize->x_ppem = bsize->y_ppem;
1312 }
1313
1314 /* set up charset */
1315 {
1316 PCF_Property charset_registry = 0, charset_encoding = 0;
1317
1318
1319 charset_registry = pcf_find_property( face, "CHARSET_REGISTRY" );
1320 charset_encoding = pcf_find_property( face, "CHARSET_ENCODING" );
1321
1322 if ( charset_registry && charset_registry->isString &&
1323 charset_encoding && charset_encoding->isString )
1324 {
1325 if ( FT_STRDUP( face->charset_encoding,
1326 charset_encoding->value.atom ) ||
1327 FT_STRDUP( face->charset_registry,
1328 charset_registry->value.atom ) )
1329 goto Exit;
1330 }
1331 }
1332 }
1333
1334 Exit:
1335 if ( error )
1336 {
1337 /* This is done to respect the behaviour of the original */
1338 /* PCF font driver. */
1339 error = FT_THROW( Invalid_File_Format );
1340 }
1341
1342 return error;
1343 }
1344
1345
1346 /* END */
A free Windows-compatible Operating System