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