1 /***************************************************************************/ |
|
2 /* */ |
|
3 /* pfrgload.c */ |
|
4 /* */ |
|
5 /* FreeType PFR glyph loader (body). */ |
|
6 /* */ |
|
7 /* Copyright 2002, 2003, 2005, 2007, 2010 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 "pfrgload.h" |
|
20 #include "pfrsbit.h" |
|
21 #include "pfrload.h" /* for macro definitions */ |
|
22 #include FT_INTERNAL_DEBUG_H |
|
23 |
|
24 #include "pfrerror.h" |
|
25 |
|
26 #undef FT_COMPONENT |
|
27 #define FT_COMPONENT trace_pfr |
|
28 |
|
29 |
|
30 /*************************************************************************/ |
|
31 /*************************************************************************/ |
|
32 /***** *****/ |
|
33 /***** PFR GLYPH BUILDER *****/ |
|
34 /***** *****/ |
|
35 /*************************************************************************/ |
|
36 /*************************************************************************/ |
|
37 |
|
38 |
|
39 FT_LOCAL_DEF( void ) |
|
40 pfr_glyph_init( PFR_Glyph glyph, |
|
41 FT_GlyphLoader loader ) |
|
42 { |
|
43 FT_ZERO( glyph ); |
|
44 |
|
45 glyph->loader = loader; |
|
46 glyph->path_begun = 0; |
|
47 |
|
48 FT_GlyphLoader_Rewind( loader ); |
|
49 } |
|
50 |
|
51 |
|
52 FT_LOCAL_DEF( void ) |
|
53 pfr_glyph_done( PFR_Glyph glyph ) |
|
54 { |
|
55 FT_Memory memory = glyph->loader->memory; |
|
56 |
|
57 |
|
58 FT_FREE( glyph->x_control ); |
|
59 glyph->y_control = NULL; |
|
60 |
|
61 glyph->max_xy_control = 0; |
|
62 #if 0 |
|
63 glyph->num_x_control = 0; |
|
64 glyph->num_y_control = 0; |
|
65 #endif |
|
66 |
|
67 FT_FREE( glyph->subs ); |
|
68 |
|
69 glyph->max_subs = 0; |
|
70 glyph->num_subs = 0; |
|
71 |
|
72 glyph->loader = NULL; |
|
73 glyph->path_begun = 0; |
|
74 } |
|
75 |
|
76 |
|
77 /* close current contour, if any */ |
|
78 static void |
|
79 pfr_glyph_close_contour( PFR_Glyph glyph ) |
|
80 { |
|
81 FT_GlyphLoader loader = glyph->loader; |
|
82 FT_Outline* outline = &loader->current.outline; |
|
83 FT_Int last, first; |
|
84 |
|
85 |
|
86 if ( !glyph->path_begun ) |
|
87 return; |
|
88 |
|
89 /* compute first and last point indices in current glyph outline */ |
|
90 last = outline->n_points - 1; |
|
91 first = 0; |
|
92 if ( outline->n_contours > 0 ) |
|
93 first = outline->contours[outline->n_contours - 1]; |
|
94 |
|
95 /* if the last point falls on the same location than the first one */ |
|
96 /* we need to delete it */ |
|
97 if ( last > first ) |
|
98 { |
|
99 FT_Vector* p1 = outline->points + first; |
|
100 FT_Vector* p2 = outline->points + last; |
|
101 |
|
102 |
|
103 if ( p1->x == p2->x && p1->y == p2->y ) |
|
104 { |
|
105 outline->n_points--; |
|
106 last--; |
|
107 } |
|
108 } |
|
109 |
|
110 /* don't add empty contours */ |
|
111 if ( last >= first ) |
|
112 outline->contours[outline->n_contours++] = (short)last; |
|
113 |
|
114 glyph->path_begun = 0; |
|
115 } |
|
116 |
|
117 |
|
118 /* reset glyph to start the loading of a new glyph */ |
|
119 static void |
|
120 pfr_glyph_start( PFR_Glyph glyph ) |
|
121 { |
|
122 glyph->path_begun = 0; |
|
123 } |
|
124 |
|
125 |
|
126 static FT_Error |
|
127 pfr_glyph_line_to( PFR_Glyph glyph, |
|
128 FT_Vector* to ) |
|
129 { |
|
130 FT_GlyphLoader loader = glyph->loader; |
|
131 FT_Outline* outline = &loader->current.outline; |
|
132 FT_Error error; |
|
133 |
|
134 |
|
135 /* check that we have begun a new path */ |
|
136 if ( !glyph->path_begun ) |
|
137 { |
|
138 error = PFR_Err_Invalid_Table; |
|
139 FT_ERROR(( "pfr_glyph_line_to: invalid glyph data\n" )); |
|
140 goto Exit; |
|
141 } |
|
142 |
|
143 error = FT_GLYPHLOADER_CHECK_POINTS( loader, 1, 0 ); |
|
144 if ( !error ) |
|
145 { |
|
146 FT_UInt n = outline->n_points; |
|
147 |
|
148 |
|
149 outline->points[n] = *to; |
|
150 outline->tags [n] = FT_CURVE_TAG_ON; |
|
151 |
|
152 outline->n_points++; |
|
153 } |
|
154 |
|
155 Exit: |
|
156 return error; |
|
157 } |
|
158 |
|
159 |
|
160 static FT_Error |
|
161 pfr_glyph_curve_to( PFR_Glyph glyph, |
|
162 FT_Vector* control1, |
|
163 FT_Vector* control2, |
|
164 FT_Vector* to ) |
|
165 { |
|
166 FT_GlyphLoader loader = glyph->loader; |
|
167 FT_Outline* outline = &loader->current.outline; |
|
168 FT_Error error; |
|
169 |
|
170 |
|
171 /* check that we have begun a new path */ |
|
172 if ( !glyph->path_begun ) |
|
173 { |
|
174 error = PFR_Err_Invalid_Table; |
|
175 FT_ERROR(( "pfr_glyph_line_to: invalid glyph data\n" )); |
|
176 goto Exit; |
|
177 } |
|
178 |
|
179 error = FT_GLYPHLOADER_CHECK_POINTS( loader, 3, 0 ); |
|
180 if ( !error ) |
|
181 { |
|
182 FT_Vector* vec = outline->points + outline->n_points; |
|
183 FT_Byte* tag = (FT_Byte*)outline->tags + outline->n_points; |
|
184 |
|
185 |
|
186 vec[0] = *control1; |
|
187 vec[1] = *control2; |
|
188 vec[2] = *to; |
|
189 tag[0] = FT_CURVE_TAG_CUBIC; |
|
190 tag[1] = FT_CURVE_TAG_CUBIC; |
|
191 tag[2] = FT_CURVE_TAG_ON; |
|
192 |
|
193 outline->n_points = (FT_Short)( outline->n_points + 3 ); |
|
194 } |
|
195 |
|
196 Exit: |
|
197 return error; |
|
198 } |
|
199 |
|
200 |
|
201 static FT_Error |
|
202 pfr_glyph_move_to( PFR_Glyph glyph, |
|
203 FT_Vector* to ) |
|
204 { |
|
205 FT_GlyphLoader loader = glyph->loader; |
|
206 FT_Error error; |
|
207 |
|
208 |
|
209 /* close current contour if any */ |
|
210 pfr_glyph_close_contour( glyph ); |
|
211 |
|
212 /* indicate that a new contour has started */ |
|
213 glyph->path_begun = 1; |
|
214 |
|
215 /* check that there is space for a new contour and a new point */ |
|
216 error = FT_GLYPHLOADER_CHECK_POINTS( loader, 1, 1 ); |
|
217 if ( !error ) |
|
218 /* add new start point */ |
|
219 error = pfr_glyph_line_to( glyph, to ); |
|
220 |
|
221 return error; |
|
222 } |
|
223 |
|
224 |
|
225 static void |
|
226 pfr_glyph_end( PFR_Glyph glyph ) |
|
227 { |
|
228 /* close current contour if any */ |
|
229 pfr_glyph_close_contour( glyph ); |
|
230 |
|
231 /* merge the current glyph into the stack */ |
|
232 FT_GlyphLoader_Add( glyph->loader ); |
|
233 } |
|
234 |
|
235 |
|
236 /*************************************************************************/ |
|
237 /*************************************************************************/ |
|
238 /***** *****/ |
|
239 /***** PFR GLYPH LOADER *****/ |
|
240 /***** *****/ |
|
241 /*************************************************************************/ |
|
242 /*************************************************************************/ |
|
243 |
|
244 |
|
245 /* load a simple glyph */ |
|
246 static FT_Error |
|
247 pfr_glyph_load_simple( PFR_Glyph glyph, |
|
248 FT_Byte* p, |
|
249 FT_Byte* limit ) |
|
250 { |
|
251 FT_Error error = PFR_Err_Ok; |
|
252 FT_Memory memory = glyph->loader->memory; |
|
253 FT_UInt flags, x_count, y_count, i, count, mask; |
|
254 FT_Int x; |
|
255 |
|
256 |
|
257 PFR_CHECK( 1 ); |
|
258 flags = PFR_NEXT_BYTE( p ); |
|
259 |
|
260 /* test for composite glyphs */ |
|
261 if ( flags & PFR_GLYPH_IS_COMPOUND ) |
|
262 goto Failure; |
|
263 |
|
264 x_count = 0; |
|
265 y_count = 0; |
|
266 |
|
267 if ( flags & PFR_GLYPH_1BYTE_XYCOUNT ) |
|
268 { |
|
269 PFR_CHECK( 1 ); |
|
270 count = PFR_NEXT_BYTE( p ); |
|
271 x_count = count & 15; |
|
272 y_count = count >> 4; |
|
273 } |
|
274 else |
|
275 { |
|
276 if ( flags & PFR_GLYPH_XCOUNT ) |
|
277 { |
|
278 PFR_CHECK( 1 ); |
|
279 x_count = PFR_NEXT_BYTE( p ); |
|
280 } |
|
281 |
|
282 if ( flags & PFR_GLYPH_YCOUNT ) |
|
283 { |
|
284 PFR_CHECK( 1 ); |
|
285 y_count = PFR_NEXT_BYTE( p ); |
|
286 } |
|
287 } |
|
288 |
|
289 count = x_count + y_count; |
|
290 |
|
291 /* re-allocate array when necessary */ |
|
292 if ( count > glyph->max_xy_control ) |
|
293 { |
|
294 FT_UInt new_max = FT_PAD_CEIL( count, 8 ); |
|
295 |
|
296 |
|
297 if ( FT_RENEW_ARRAY( glyph->x_control, |
|
298 glyph->max_xy_control, |
|
299 new_max ) ) |
|
300 goto Exit; |
|
301 |
|
302 glyph->max_xy_control = new_max; |
|
303 } |
|
304 |
|
305 glyph->y_control = glyph->x_control + x_count; |
|
306 |
|
307 mask = 0; |
|
308 x = 0; |
|
309 |
|
310 for ( i = 0; i < count; i++ ) |
|
311 { |
|
312 if ( ( i & 7 ) == 0 ) |
|
313 { |
|
314 PFR_CHECK( 1 ); |
|
315 mask = PFR_NEXT_BYTE( p ); |
|
316 } |
|
317 |
|
318 if ( mask & 1 ) |
|
319 { |
|
320 PFR_CHECK( 2 ); |
|
321 x = PFR_NEXT_SHORT( p ); |
|
322 } |
|
323 else |
|
324 { |
|
325 PFR_CHECK( 1 ); |
|
326 x += PFR_NEXT_BYTE( p ); |
|
327 } |
|
328 |
|
329 glyph->x_control[i] = x; |
|
330 |
|
331 mask >>= 1; |
|
332 } |
|
333 |
|
334 /* XXX: for now we ignore the secondary stroke and edge definitions */ |
|
335 /* since we don't want to support native PFR hinting */ |
|
336 /* */ |
|
337 if ( flags & PFR_GLYPH_EXTRA_ITEMS ) |
|
338 { |
|
339 error = pfr_extra_items_skip( &p, limit ); |
|
340 if ( error ) |
|
341 goto Exit; |
|
342 } |
|
343 |
|
344 pfr_glyph_start( glyph ); |
|
345 |
|
346 /* now load a simple glyph */ |
|
347 { |
|
348 FT_Vector pos[4]; |
|
349 FT_Vector* cur; |
|
350 |
|
351 |
|
352 pos[0].x = pos[0].y = 0; |
|
353 pos[3] = pos[0]; |
|
354 |
|
355 for (;;) |
|
356 { |
|
357 FT_UInt format, format_low, args_format = 0, args_count, n; |
|
358 |
|
359 |
|
360 /***************************************************************/ |
|
361 /* read instruction */ |
|
362 /* */ |
|
363 PFR_CHECK( 1 ); |
|
364 format = PFR_NEXT_BYTE( p ); |
|
365 format_low = format & 15; |
|
366 |
|
367 switch ( format >> 4 ) |
|
368 { |
|
369 case 0: /* end glyph */ |
|
370 FT_TRACE6(( "- end glyph" )); |
|
371 args_count = 0; |
|
372 break; |
|
373 |
|
374 case 1: /* general line operation */ |
|
375 FT_TRACE6(( "- general line" )); |
|
376 goto Line1; |
|
377 |
|
378 case 4: /* move to inside contour */ |
|
379 FT_TRACE6(( "- move to inside" )); |
|
380 goto Line1; |
|
381 |
|
382 case 5: /* move to outside contour */ |
|
383 FT_TRACE6(( "- move to outside" )); |
|
384 Line1: |
|
385 args_format = format_low; |
|
386 args_count = 1; |
|
387 break; |
|
388 |
|
389 case 2: /* horizontal line to */ |
|
390 FT_TRACE6(( "- horizontal line to cx.%d", format_low )); |
|
391 if ( format_low >= x_count ) |
|
392 goto Failure; |
|
393 pos[0].x = glyph->x_control[format_low]; |
|
394 pos[0].y = pos[3].y; |
|
395 pos[3] = pos[0]; |
|
396 args_count = 0; |
|
397 break; |
|
398 |
|
399 case 3: /* vertical line to */ |
|
400 FT_TRACE6(( "- vertical line to cy.%d", format_low )); |
|
401 if ( format_low >= y_count ) |
|
402 goto Failure; |
|
403 pos[0].x = pos[3].x; |
|
404 pos[0].y = glyph->y_control[format_low]; |
|
405 pos[3] = pos[0]; |
|
406 args_count = 0; |
|
407 break; |
|
408 |
|
409 case 6: /* horizontal to vertical curve */ |
|
410 FT_TRACE6(( "- hv curve " )); |
|
411 args_format = 0xB8E; |
|
412 args_count = 3; |
|
413 break; |
|
414 |
|
415 case 7: /* vertical to horizontal curve */ |
|
416 FT_TRACE6(( "- vh curve" )); |
|
417 args_format = 0xE2B; |
|
418 args_count = 3; |
|
419 break; |
|
420 |
|
421 default: /* general curve to */ |
|
422 FT_TRACE6(( "- general curve" )); |
|
423 args_count = 4; |
|
424 args_format = format_low; |
|
425 } |
|
426 |
|
427 /***********************************************************/ |
|
428 /* now read arguments */ |
|
429 /* */ |
|
430 cur = pos; |
|
431 for ( n = 0; n < args_count; n++ ) |
|
432 { |
|
433 FT_UInt idx; |
|
434 FT_Int delta; |
|
435 |
|
436 |
|
437 /* read the X argument */ |
|
438 switch ( args_format & 3 ) |
|
439 { |
|
440 case 0: /* 8-bit index */ |
|
441 PFR_CHECK( 1 ); |
|
442 idx = PFR_NEXT_BYTE( p ); |
|
443 if ( idx >= x_count ) |
|
444 goto Failure; |
|
445 cur->x = glyph->x_control[idx]; |
|
446 FT_TRACE7(( " cx#%d", idx )); |
|
447 break; |
|
448 |
|
449 case 1: /* 16-bit value */ |
|
450 PFR_CHECK( 2 ); |
|
451 cur->x = PFR_NEXT_SHORT( p ); |
|
452 FT_TRACE7(( " x.%d", cur->x )); |
|
453 break; |
|
454 |
|
455 case 2: /* 8-bit delta */ |
|
456 PFR_CHECK( 1 ); |
|
457 delta = PFR_NEXT_INT8( p ); |
|
458 cur->x = pos[3].x + delta; |
|
459 FT_TRACE7(( " dx.%d", delta )); |
|
460 break; |
|
461 |
|
462 default: |
|
463 FT_TRACE7(( " |" )); |
|
464 cur->x = pos[3].x; |
|
465 } |
|
466 |
|
467 /* read the Y argument */ |
|
468 switch ( ( args_format >> 2 ) & 3 ) |
|
469 { |
|
470 case 0: /* 8-bit index */ |
|
471 PFR_CHECK( 1 ); |
|
472 idx = PFR_NEXT_BYTE( p ); |
|
473 if ( idx >= y_count ) |
|
474 goto Failure; |
|
475 cur->y = glyph->y_control[idx]; |
|
476 FT_TRACE7(( " cy#%d", idx )); |
|
477 break; |
|
478 |
|
479 case 1: /* 16-bit absolute value */ |
|
480 PFR_CHECK( 2 ); |
|
481 cur->y = PFR_NEXT_SHORT( p ); |
|
482 FT_TRACE7(( " y.%d", cur->y )); |
|
483 break; |
|
484 |
|
485 case 2: /* 8-bit delta */ |
|
486 PFR_CHECK( 1 ); |
|
487 delta = PFR_NEXT_INT8( p ); |
|
488 cur->y = pos[3].y + delta; |
|
489 FT_TRACE7(( " dy.%d", delta )); |
|
490 break; |
|
491 |
|
492 default: |
|
493 FT_TRACE7(( " -" )); |
|
494 cur->y = pos[3].y; |
|
495 } |
|
496 |
|
497 /* read the additional format flag for the general curve */ |
|
498 if ( n == 0 && args_count == 4 ) |
|
499 { |
|
500 PFR_CHECK( 1 ); |
|
501 args_format = PFR_NEXT_BYTE( p ); |
|
502 args_count--; |
|
503 } |
|
504 else |
|
505 args_format >>= 4; |
|
506 |
|
507 /* save the previous point */ |
|
508 pos[3] = cur[0]; |
|
509 cur++; |
|
510 } |
|
511 |
|
512 FT_TRACE7(( "\n" )); |
|
513 |
|
514 /***********************************************************/ |
|
515 /* finally, execute instruction */ |
|
516 /* */ |
|
517 switch ( format >> 4 ) |
|
518 { |
|
519 case 0: /* end glyph => EXIT */ |
|
520 pfr_glyph_end( glyph ); |
|
521 goto Exit; |
|
522 |
|
523 case 1: /* line operations */ |
|
524 case 2: |
|
525 case 3: |
|
526 error = pfr_glyph_line_to( glyph, pos ); |
|
527 goto Test_Error; |
|
528 |
|
529 case 4: /* move to inside contour */ |
|
530 case 5: /* move to outside contour */ |
|
531 error = pfr_glyph_move_to( glyph, pos ); |
|
532 goto Test_Error; |
|
533 |
|
534 default: /* curve operations */ |
|
535 error = pfr_glyph_curve_to( glyph, pos, pos + 1, pos + 2 ); |
|
536 |
|
537 Test_Error: /* test error condition */ |
|
538 if ( error ) |
|
539 goto Exit; |
|
540 } |
|
541 } /* for (;;) */ |
|
542 } |
|
543 |
|
544 Exit: |
|
545 return error; |
|
546 |
|
547 Failure: |
|
548 Too_Short: |
|
549 error = PFR_Err_Invalid_Table; |
|
550 FT_ERROR(( "pfr_glyph_load_simple: invalid glyph data\n" )); |
|
551 goto Exit; |
|
552 } |
|
553 |
|
554 |
|
555 /* load a composite/compound glyph */ |
|
556 static FT_Error |
|
557 pfr_glyph_load_compound( PFR_Glyph glyph, |
|
558 FT_Byte* p, |
|
559 FT_Byte* limit ) |
|
560 { |
|
561 FT_Error error = PFR_Err_Ok; |
|
562 FT_GlyphLoader loader = glyph->loader; |
|
563 FT_Memory memory = loader->memory; |
|
564 PFR_SubGlyph subglyph; |
|
565 FT_UInt flags, i, count, org_count; |
|
566 FT_Int x_pos, y_pos; |
|
567 |
|
568 |
|
569 PFR_CHECK( 1 ); |
|
570 flags = PFR_NEXT_BYTE( p ); |
|
571 |
|
572 /* test for composite glyphs */ |
|
573 if ( !( flags & PFR_GLYPH_IS_COMPOUND ) ) |
|
574 goto Failure; |
|
575 |
|
576 count = flags & 0x3F; |
|
577 |
|
578 /* ignore extra items when present */ |
|
579 /* */ |
|
580 if ( flags & PFR_GLYPH_EXTRA_ITEMS ) |
|
581 { |
|
582 error = pfr_extra_items_skip( &p, limit ); |
|
583 if (error) goto Exit; |
|
584 } |
|
585 |
|
586 /* we can't rely on the FT_GlyphLoader to load sub-glyphs, because */ |
|
587 /* the PFR format is dumb, using direct file offsets to point to the */ |
|
588 /* sub-glyphs (instead of glyph indices). Sigh. */ |
|
589 /* */ |
|
590 /* For now, we load the list of sub-glyphs into a different array */ |
|
591 /* but this will prevent us from using the auto-hinter at its best */ |
|
592 /* quality. */ |
|
593 /* */ |
|
594 org_count = glyph->num_subs; |
|
595 |
|
596 if ( org_count + count > glyph->max_subs ) |
|
597 { |
|
598 FT_UInt new_max = ( org_count + count + 3 ) & (FT_UInt)-4; |
|
599 |
|
600 |
|
601 /* we arbitrarily limit the number of subglyphs */ |
|
602 /* to avoid endless recursion */ |
|
603 if ( new_max > 64 ) |
|
604 { |
|
605 error = PFR_Err_Invalid_Table; |
|
606 FT_ERROR(( "pfr_glyph_load_compound:" |
|
607 " too many compound glyphs components\n" )); |
|
608 goto Exit; |
|
609 } |
|
610 |
|
611 if ( FT_RENEW_ARRAY( glyph->subs, glyph->max_subs, new_max ) ) |
|
612 goto Exit; |
|
613 |
|
614 glyph->max_subs = new_max; |
|
615 } |
|
616 |
|
617 subglyph = glyph->subs + org_count; |
|
618 |
|
619 for ( i = 0; i < count; i++, subglyph++ ) |
|
620 { |
|
621 FT_UInt format; |
|
622 |
|
623 |
|
624 x_pos = 0; |
|
625 y_pos = 0; |
|
626 |
|
627 PFR_CHECK( 1 ); |
|
628 format = PFR_NEXT_BYTE( p ); |
|
629 |
|
630 /* read scale when available */ |
|
631 subglyph->x_scale = 0x10000L; |
|
632 if ( format & PFR_SUBGLYPH_XSCALE ) |
|
633 { |
|
634 PFR_CHECK( 2 ); |
|
635 subglyph->x_scale = PFR_NEXT_SHORT( p ) << 4; |
|
636 } |
|
637 |
|
638 subglyph->y_scale = 0x10000L; |
|
639 if ( format & PFR_SUBGLYPH_YSCALE ) |
|
640 { |
|
641 PFR_CHECK( 2 ); |
|
642 subglyph->y_scale = PFR_NEXT_SHORT( p ) << 4; |
|
643 } |
|
644 |
|
645 /* read offset */ |
|
646 switch ( format & 3 ) |
|
647 { |
|
648 case 1: |
|
649 PFR_CHECK( 2 ); |
|
650 x_pos = PFR_NEXT_SHORT( p ); |
|
651 break; |
|
652 |
|
653 case 2: |
|
654 PFR_CHECK( 1 ); |
|
655 x_pos += PFR_NEXT_INT8( p ); |
|
656 break; |
|
657 |
|
658 default: |
|
659 ; |
|
660 } |
|
661 |
|
662 switch ( ( format >> 2 ) & 3 ) |
|
663 { |
|
664 case 1: |
|
665 PFR_CHECK( 2 ); |
|
666 y_pos = PFR_NEXT_SHORT( p ); |
|
667 break; |
|
668 |
|
669 case 2: |
|
670 PFR_CHECK( 1 ); |
|
671 y_pos += PFR_NEXT_INT8( p ); |
|
672 break; |
|
673 |
|
674 default: |
|
675 ; |
|
676 } |
|
677 |
|
678 subglyph->x_delta = x_pos; |
|
679 subglyph->y_delta = y_pos; |
|
680 |
|
681 /* read glyph position and size now */ |
|
682 if ( format & PFR_SUBGLYPH_2BYTE_SIZE ) |
|
683 { |
|
684 PFR_CHECK( 2 ); |
|
685 subglyph->gps_size = PFR_NEXT_USHORT( p ); |
|
686 } |
|
687 else |
|
688 { |
|
689 PFR_CHECK( 1 ); |
|
690 subglyph->gps_size = PFR_NEXT_BYTE( p ); |
|
691 } |
|
692 |
|
693 if ( format & PFR_SUBGLYPH_3BYTE_OFFSET ) |
|
694 { |
|
695 PFR_CHECK( 3 ); |
|
696 subglyph->gps_offset = PFR_NEXT_LONG( p ); |
|
697 } |
|
698 else |
|
699 { |
|
700 PFR_CHECK( 2 ); |
|
701 subglyph->gps_offset = PFR_NEXT_USHORT( p ); |
|
702 } |
|
703 |
|
704 glyph->num_subs++; |
|
705 } |
|
706 |
|
707 Exit: |
|
708 return error; |
|
709 |
|
710 Failure: |
|
711 Too_Short: |
|
712 error = PFR_Err_Invalid_Table; |
|
713 FT_ERROR(( "pfr_glyph_load_compound: invalid glyph data\n" )); |
|
714 goto Exit; |
|
715 } |
|
716 |
|
717 |
|
718 static FT_Error |
|
719 pfr_glyph_load_rec( PFR_Glyph glyph, |
|
720 FT_Stream stream, |
|
721 FT_ULong gps_offset, |
|
722 FT_ULong offset, |
|
723 FT_ULong size ) |
|
724 { |
|
725 FT_Error error; |
|
726 FT_Byte* p; |
|
727 FT_Byte* limit; |
|
728 |
|
729 |
|
730 if ( FT_STREAM_SEEK( gps_offset + offset ) || |
|
731 FT_FRAME_ENTER( size ) ) |
|
732 goto Exit; |
|
733 |
|
734 p = (FT_Byte*)stream->cursor; |
|
735 limit = p + size; |
|
736 |
|
737 if ( size > 0 && *p & PFR_GLYPH_IS_COMPOUND ) |
|
738 { |
|
739 FT_Int n, old_count, count; |
|
740 FT_GlyphLoader loader = glyph->loader; |
|
741 FT_Outline* base = &loader->base.outline; |
|
742 |
|
743 |
|
744 old_count = glyph->num_subs; |
|
745 |
|
746 /* this is a compound glyph - load it */ |
|
747 error = pfr_glyph_load_compound( glyph, p, limit ); |
|
748 |
|
749 FT_FRAME_EXIT(); |
|
750 |
|
751 if ( error ) |
|
752 goto Exit; |
|
753 |
|
754 count = glyph->num_subs - old_count; |
|
755 |
|
756 FT_TRACE4(( "compound glyph with %d elements (offset %lu):\n", |
|
757 count, offset )); |
|
758 |
|
759 /* now, load each individual glyph */ |
|
760 for ( n = 0; n < count; n++ ) |
|
761 { |
|
762 FT_Int i, old_points, num_points; |
|
763 PFR_SubGlyph subglyph; |
|
764 |
|
765 |
|
766 FT_TRACE4(( "subglyph %d:\n", n )); |
|
767 |
|
768 subglyph = glyph->subs + old_count + n; |
|
769 old_points = base->n_points; |
|
770 |
|
771 error = pfr_glyph_load_rec( glyph, stream, gps_offset, |
|
772 subglyph->gps_offset, |
|
773 subglyph->gps_size ); |
|
774 if ( error ) |
|
775 break; |
|
776 |
|
777 /* note that `glyph->subs' might have been re-allocated */ |
|
778 subglyph = glyph->subs + old_count + n; |
|
779 num_points = base->n_points - old_points; |
|
780 |
|
781 /* translate and eventually scale the new glyph points */ |
|
782 if ( subglyph->x_scale != 0x10000L || subglyph->y_scale != 0x10000L ) |
|
783 { |
|
784 FT_Vector* vec = base->points + old_points; |
|
785 |
|
786 |
|
787 for ( i = 0; i < num_points; i++, vec++ ) |
|
788 { |
|
789 vec->x = FT_MulFix( vec->x, subglyph->x_scale ) + |
|
790 subglyph->x_delta; |
|
791 vec->y = FT_MulFix( vec->y, subglyph->y_scale ) + |
|
792 subglyph->y_delta; |
|
793 } |
|
794 } |
|
795 else |
|
796 { |
|
797 FT_Vector* vec = loader->base.outline.points + old_points; |
|
798 |
|
799 |
|
800 for ( i = 0; i < num_points; i++, vec++ ) |
|
801 { |
|
802 vec->x += subglyph->x_delta; |
|
803 vec->y += subglyph->y_delta; |
|
804 } |
|
805 } |
|
806 |
|
807 /* proceed to next sub-glyph */ |
|
808 } |
|
809 |
|
810 FT_TRACE4(( "end compound glyph with %d elements\n", count )); |
|
811 } |
|
812 else |
|
813 { |
|
814 FT_TRACE4(( "simple glyph (offset %lu)\n", offset )); |
|
815 |
|
816 /* load a simple glyph */ |
|
817 error = pfr_glyph_load_simple( glyph, p, limit ); |
|
818 |
|
819 FT_FRAME_EXIT(); |
|
820 } |
|
821 |
|
822 Exit: |
|
823 return error; |
|
824 } |
|
825 |
|
826 |
|
827 FT_LOCAL_DEF( FT_Error ) |
|
828 pfr_glyph_load( PFR_Glyph glyph, |
|
829 FT_Stream stream, |
|
830 FT_ULong gps_offset, |
|
831 FT_ULong offset, |
|
832 FT_ULong size ) |
|
833 { |
|
834 /* initialize glyph loader */ |
|
835 FT_GlyphLoader_Rewind( glyph->loader ); |
|
836 |
|
837 glyph->num_subs = 0; |
|
838 |
|
839 /* load the glyph, recursively when needed */ |
|
840 return pfr_glyph_load_rec( glyph, stream, gps_offset, offset, size ); |
|
841 } |
|
842 |
|
843 |
|
844 /* END */ |
|