Context Navigation

ttsbit.c

Last change on this file was 2, checked in by jglee, 11 years ago
first commit
File size: 52.6 KB

Line
1	/***************************************************************************/
2	/* */
3	/* ttsbit.c */
4	/* */
5	/* TrueType and OpenType embedded bitmap support (body). */
6	/* */
7	/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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	#include <ft2build.h>
19	#include FT_INTERNAL_DEBUG_H
20	#include FT_INTERNAL_STREAM_H
21	#include FT_TRUETYPE_TAGS_H
22
23	/*
24	* Alas, the memory-optimized sbit loader can't be used when implementing
25	* the `old internals' hack
26	*/
27	#ifndef FT_CONFIG_OPTION_OLD_INTERNALS
28
29	#include "ttsbit0.c"
30
31	#else /* FT_CONFIG_OPTION_OLD_INTERNALS */
32
33	#include <ft2build.h>
34	#include FT_INTERNAL_DEBUG_H
35	#include FT_INTERNAL_STREAM_H
36	#include FT_TRUETYPE_TAGS_H
37	#include "ttsbit.h"
38
39	#include "sferrors.h"
40
41
42	/*************************************************************************/
43	/* */
44	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
45	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
46	/* messages during execution. */
47	/* */
48	#undef FT_COMPONENT
49	#define FT_COMPONENT trace_ttsbit
50
51
52	/*************************************************************************/
53	/* */
54	/* <Function> */
55	/* blit_sbit */
56	/* */
57	/* <Description> */
58	/* Blits a bitmap from an input stream into a given target. Supports */
59	/* x and y offsets as well as byte padded lines. */
60	/* */
61	/* <Input> */
62	/* target :: The target bitmap/pixmap. */
63	/* */
64	/* source :: The input packed bitmap data. */
65	/* */
66	/* line_bits :: The number of bits per line. */
67	/* */
68	/* byte_padded :: A flag which is true if lines are byte-padded. */
69	/* */
70	/* x_offset :: The horizontal offset. */
71	/* */
72	/* y_offset :: The vertical offset. */
73	/* */
74	/* <Note> */
75	/* IMPORTANT: The x and y offsets are relative to the top corner of */
76	/* the target bitmap (unlike the normal TrueType */
77	/* convention). A positive y offset indicates a downwards */
78	/* direction! */
79	/* */
80	static void
81	blit_sbit( FT_Bitmap* target,
82	FT_Byte* source,
83	FT_Int line_bits,
84	FT_Bool byte_padded,
85	FT_Int x_offset,
86	FT_Int y_offset,
87	FT_Int source_height )
88	{
89	FT_Byte* line_buff;
90	FT_Int line_incr;
91	FT_Int height;
92
93	FT_UShort acc;
94	FT_UInt loaded;
95
96
97	/* first of all, compute starting write position */
98	line_incr = target->pitch;
99	line_buff = target->buffer;
100
101	if ( line_incr < 0 )
102	line_buff -= line_incr * ( target->rows - 1 );
103
104	line_buff += ( x_offset >> 3 ) + y_offset * line_incr;
105
106	/***********************************************************************/
107	/* */
108	/* We use the extra-classic `accumulator' trick to extract the bits */
109	/* from the source byte stream. */
110	/* */
111	/* Namely, the variable `acc' is a 16-bit accumulator containing the */
112	/* last `loaded' bits from the input stream. The bits are shifted to */
113	/* the upmost position in `acc'. */
114	/* */
115	/***********************************************************************/
116
117	acc = 0; /* clear accumulator */
118	loaded = 0; /* no bits were loaded */
119
120	for ( height = source_height; height > 0; height-- )
121	{
122	FT_Byte* cur = line_buff; /* current write cursor */
123	FT_Int count = line_bits; /* # of bits to extract per line */
124	FT_Byte shift = (FT_Byte)( x_offset & 7 ); /* current write shift */
125	FT_Byte space = (FT_Byte)( 8 - shift );
126
127
128	/* first of all, read individual source bytes */
129	if ( count >= 8 )
130	{
131	count -= 8;
132	{
133	do
134	{
135	FT_Byte val;
136
137
138	/* ensure that there are at least 8 bits in the accumulator */
139	if ( loaded < 8 )
140	{
141	acc \|= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded ));
142	loaded += 8;
143	}
144
145	/* now write one byte */
146	val = (FT_Byte)( acc >> 8 );
147	if ( shift )
148	{
149	cur[0] \|= (FT_Byte)( val >> shift );
150	cur[1] \|= (FT_Byte)( val << space );
151	}
152	else
153	cur[0] \|= val;
154
155	cur++;
156	acc <<= 8; /* remove bits from accumulator */
157	loaded -= 8;
158	count -= 8;
159
160	} while ( count >= 0 );
161	}
162
163	/* restore `count' to correct value */
164	count += 8;
165	}
166
167	/* now write remaining bits (count < 8) */
168	if ( count > 0 )
169	{
170	FT_Byte val;
171
172
173	/* ensure that there are at least `count' bits in the accumulator */
174	if ( (FT_Int)loaded < count )
175	{
176	acc \|= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded ));
177	loaded += 8;
178	}
179
180	/* now write remaining bits */
181	val = (FT_Byte)( ( (FT_Byte)( acc >> 8 ) ) & ~( 0xFF >> count ) );
182	cur[0] \|= (FT_Byte)( val >> shift );
183
184	if ( count > space )
185	cur[1] \|= (FT_Byte)( val << space );
186
187	acc <<= count;
188	loaded -= count;
189	}
190
191	/* now, skip to next line */
192	if ( byte_padded )
193	{
194	acc = 0;
195	loaded = 0; /* clear accumulator on byte-padded lines */
196	}
197
198	line_buff += line_incr;
199	}
200	}
201
202
203	static const FT_Frame_Field sbit_metrics_fields[] =
204	{
205	#undef FT_STRUCTURE
206	#define FT_STRUCTURE TT_SBit_MetricsRec
207
208	FT_FRAME_START( 8 ),
209	FT_FRAME_BYTE( height ),
210	FT_FRAME_BYTE( width ),
211
212	FT_FRAME_CHAR( horiBearingX ),
213	FT_FRAME_CHAR( horiBearingY ),
214	FT_FRAME_BYTE( horiAdvance ),
215
216	FT_FRAME_CHAR( vertBearingX ),
217	FT_FRAME_CHAR( vertBearingY ),
218	FT_FRAME_BYTE( vertAdvance ),
219	FT_FRAME_END
220	};
221
222
223	/*************************************************************************/
224	/* */
225	/* <Function> */
226	/* Load_SBit_Const_Metrics */
227	/* */
228	/* <Description> */
229	/* Loads the metrics for `EBLC' index tables format 2 and 5. */
230	/* */
231	/* <Input> */
232	/* range :: The target range. */
233	/* */
234	/* stream :: The input stream. */
235	/* */
236	/* <Return> */
237	/* FreeType error code. 0 means success. */
238	/* */
239	static FT_Error
240	Load_SBit_Const_Metrics( TT_SBit_Range range,
241	FT_Stream stream )
242	{
243	FT_Error error;
244
245
246	if ( FT_READ_ULONG( range->image_size ) )
247	return error;
248
249	return FT_STREAM_READ_FIELDS( sbit_metrics_fields, &range->metrics );
250	}
251
252
253	/*************************************************************************/
254	/* */
255	/* <Function> */
256	/* Load_SBit_Range_Codes */
257	/* */
258	/* <Description> */
259	/* Loads the range codes for `EBLC' index tables format 4 and 5. */
260	/* */
261	/* <Input> */
262	/* range :: The target range. */
263	/* */
264	/* stream :: The input stream. */
265	/* */
266	/* load_offsets :: A flag whether to load the glyph offset table. */
267	/* */
268	/* <Return> */
269	/* FreeType error code. 0 means success. */
270	/* */
271	static FT_Error
272	Load_SBit_Range_Codes( TT_SBit_Range range,
273	FT_Stream stream,
274	FT_Bool load_offsets )
275	{
276	FT_Error error;
277	FT_ULong count, n, size;
278	FT_Memory memory = stream->memory;
279
280
281	if ( FT_READ_ULONG( count ) )
282	goto Exit;
283
284	range->num_glyphs = count;
285
286	/* Allocate glyph offsets table if needed */
287	if ( load_offsets )
288	{
289	if ( FT_NEW_ARRAY( range->glyph_offsets, count ) )
290	goto Exit;
291
292	size = count * 4L;
293	}
294	else
295	size = count * 2L;
296
297	/* Allocate glyph codes table and access frame */
298	if ( FT_NEW_ARRAY ( range->glyph_codes, count ) \|\|
299	FT_FRAME_ENTER( size ) )
300	goto Exit;
301
302	for ( n = 0; n < count; n++ )
303	{
304	range->glyph_codes[n] = FT_GET_USHORT();
305
306	if ( load_offsets )
307	range->glyph_offsets[n] = (FT_ULong)range->image_offset +
308	FT_GET_USHORT();
309	}
310
311	FT_FRAME_EXIT();
312
313	Exit:
314	return error;
315	}
316
317
318	/*************************************************************************/
319	/* */
320	/* <Function> */
321	/* Load_SBit_Range */
322	/* */
323	/* <Description> */
324	/* Loads a given `EBLC' index/range table. */
325	/* */
326	/* <Input> */
327	/* range :: The target range. */
328	/* */
329	/* stream :: The input stream. */
330	/* */
331	/* <Return> */
332	/* FreeType error code. 0 means success. */
333	/* */
334	static FT_Error
335	Load_SBit_Range( TT_SBit_Range range,
336	FT_Stream stream )
337	{
338	FT_Error error;
339	FT_Memory memory = stream->memory;
340
341
342	switch( range->index_format )
343	{
344	case 1: /* variable metrics with 4-byte offsets */
345	case 3: /* variable metrics with 2-byte offsets */
346	{
347	FT_ULong num_glyphs, n;
348	FT_Int size_elem;
349	FT_Bool large = FT_BOOL( range->index_format == 1 );
350
351
352
353	if ( range->last_glyph < range->first_glyph )
354	{
355	error = SFNT_Err_Invalid_File_Format;
356	goto Exit;
357	}
358
359	num_glyphs = range->last_glyph - range->first_glyph + 1L;
360	range->num_glyphs = num_glyphs;
361	num_glyphs++; /* XXX: BEWARE - see spec */
362
363	size_elem = large ? 4 : 2;
364
365	if ( FT_NEW_ARRAY( range->glyph_offsets, num_glyphs ) \|\|
366	FT_FRAME_ENTER( num_glyphs * size_elem ) )
367	goto Exit;
368
369	for ( n = 0; n < num_glyphs; n++ )
370	range->glyph_offsets[n] = (FT_ULong)( range->image_offset +
371	( large ? FT_GET_ULONG()
372	: FT_GET_USHORT() ) );
373	FT_FRAME_EXIT();
374	}
375	break;
376
377	case 2: /* all glyphs have identical metrics */
378	error = Load_SBit_Const_Metrics( range, stream );
379	break;
380
381	case 4:
382	error = Load_SBit_Range_Codes( range, stream, 1 );
383	break;
384
385	case 5:
386	error = Load_SBit_Const_Metrics( range, stream );
387	if ( !error )
388	error = Load_SBit_Range_Codes( range, stream, 0 );
389	break;
390
391	default:
392	error = SFNT_Err_Invalid_File_Format;
393	}
394
395	Exit:
396	return error;
397	}
398
399
400	/*************************************************************************/
401	/* */
402	/* <Function> */
403	/* tt_face_load_eblc */
404	/* */
405	/* <Description> */
406	/* Loads the table of embedded bitmap sizes for this face. */
407	/* */
408	/* <Input> */
409	/* face :: The target face object. */
410	/* */
411	/* stream :: The input stream. */
412	/* */
413	/* <Return> */
414	/* FreeType error code. 0 means success. */
415	/* */
416	FT_LOCAL_DEF( FT_Error )
417	tt_face_load_eblc( TT_Face face,
418	FT_Stream stream )
419	{
420	FT_Error error = 0;
421	FT_Memory memory = stream->memory;
422	FT_Fixed version;
423	FT_ULong num_strikes;
424	FT_ULong table_base;
425
426	static const FT_Frame_Field sbit_line_metrics_fields[] =
427	{
428	#undef FT_STRUCTURE
429	#define FT_STRUCTURE TT_SBit_LineMetricsRec
430
431	/* no FT_FRAME_START */
432	FT_FRAME_CHAR( ascender ),
433	FT_FRAME_CHAR( descender ),
434	FT_FRAME_BYTE( max_width ),
435
436	FT_FRAME_CHAR( caret_slope_numerator ),
437	FT_FRAME_CHAR( caret_slope_denominator ),
438	FT_FRAME_CHAR( caret_offset ),
439
440	FT_FRAME_CHAR( min_origin_SB ),
441	FT_FRAME_CHAR( min_advance_SB ),
442	FT_FRAME_CHAR( max_before_BL ),
443	FT_FRAME_CHAR( min_after_BL ),
444	FT_FRAME_CHAR( pads[0] ),
445	FT_FRAME_CHAR( pads[1] ),
446	FT_FRAME_END
447	};
448
449	static const FT_Frame_Field strike_start_fields[] =
450	{
451	#undef FT_STRUCTURE
452	#define FT_STRUCTURE TT_SBit_StrikeRec
453
454	/* no FT_FRAME_START */
455	FT_FRAME_ULONG( ranges_offset ),
456	FT_FRAME_SKIP_LONG,
457	FT_FRAME_ULONG( num_ranges ),
458	FT_FRAME_ULONG( color_ref ),
459	FT_FRAME_END
460	};
461
462	static const FT_Frame_Field strike_end_fields[] =
463	{
464	/* no FT_FRAME_START */
465	FT_FRAME_USHORT( start_glyph ),
466	FT_FRAME_USHORT( end_glyph ),
467	FT_FRAME_BYTE ( x_ppem ),
468	FT_FRAME_BYTE ( y_ppem ),
469	FT_FRAME_BYTE ( bit_depth ),
470	FT_FRAME_CHAR ( flags ),
471	FT_FRAME_END
472	};
473
474
475	face->num_sbit_strikes = 0;
476
477	/* this table is optional */
478	error = face->goto_table( face, TTAG_EBLC, stream, 0 );
479	if ( error )
480	error = face->goto_table( face, TTAG_bloc, stream, 0 );
481	if ( error )
482	goto Exit;
483
484	table_base = FT_STREAM_POS();
485	if ( FT_FRAME_ENTER( 8L ) )
486	goto Exit;
487
488	version = FT_GET_LONG();
489	num_strikes = FT_GET_ULONG();
490
491	FT_FRAME_EXIT();
492
493	/* check version number and strike count */
494	if ( version != 0x00020000L \|\|
495	num_strikes >= 0x10000L )
496	{
497	FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version!\n" ));
498	error = SFNT_Err_Invalid_File_Format;
499
500	goto Exit;
501	}
502
503	/* allocate the strikes table */
504	if ( FT_NEW_ARRAY( face->sbit_strikes, num_strikes ) )
505	goto Exit;
506
507	face->num_sbit_strikes = num_strikes;
508
509	/* now read each strike table separately */
510	{
511	TT_SBit_Strike strike = face->sbit_strikes;
512	FT_ULong count = num_strikes;
513
514
515	if ( FT_FRAME_ENTER( 48L * num_strikes ) )
516	goto Exit;
517
518	while ( count > 0 )
519	{
520	if ( FT_STREAM_READ_FIELDS( strike_start_fields, strike ) \|\|
521	FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->hori ) \|\|
522	FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->vert ) \|\|
523	FT_STREAM_READ_FIELDS( strike_end_fields, strike ) )
524	break;
525
526	count--;
527	strike++;
528	}
529
530	FT_FRAME_EXIT();
531	}
532
533	/* allocate the index ranges for each strike table */
534	{
535	TT_SBit_Strike strike = face->sbit_strikes;
536	FT_ULong count = num_strikes;
537
538
539	while ( count > 0 )
540	{
541	TT_SBit_Range range;
542	FT_ULong count2 = strike->num_ranges;
543
544
545	/* read each range */
546	if ( FT_STREAM_SEEK( table_base + strike->ranges_offset ) \|\|
547	FT_FRAME_ENTER( strike->num_ranges * 8L ) )
548	goto Exit;
549
550	if ( FT_NEW_ARRAY( strike->sbit_ranges, strike->num_ranges ) )
551	goto Exit;
552
553	range = strike->sbit_ranges;
554	while ( count2 > 0 )
555	{
556	range->first_glyph = FT_GET_USHORT();
557	range->last_glyph = FT_GET_USHORT();
558	range->table_offset = table_base + strike->ranges_offset +
559	FT_GET_ULONG();
560	count2--;
561	range++;
562	}
563
564	FT_FRAME_EXIT();
565
566	/* Now, read each index table */
567	count2 = strike->num_ranges;
568	range = strike->sbit_ranges;
569	while ( count2 > 0 )
570	{
571	/* Read the header */
572	if ( FT_STREAM_SEEK( range->table_offset ) \|\|
573	FT_FRAME_ENTER( 8L ) )
574	goto Exit;
575
576	range->index_format = FT_GET_USHORT();
577	range->image_format = FT_GET_USHORT();
578	range->image_offset = FT_GET_ULONG();
579
580	FT_FRAME_EXIT();
581
582	error = Load_SBit_Range( range, stream );
583	if ( error )
584	goto Exit;
585
586	count2--;
587	range++;
588	}
589
590	count--;
591	strike++;
592	}
593	}
594
595	Exit:
596	return error;
597	}
598
599
600	/*************************************************************************/
601	/* */
602	/* <Function> */
603	/* tt_face_free_eblc */
604	/* */
605	/* <Description> */
606	/* Releases the embedded bitmap tables. */
607	/* */
608	/* <Input> */
609	/* face :: The target face object. */
610	/* */
611	FT_LOCAL_DEF( void )
612	tt_face_free_eblc( TT_Face face )
613	{
614	FT_Memory memory = face->root.memory;
615	TT_SBit_Strike strike = face->sbit_strikes;
616	TT_SBit_Strike strike_limit = strike + face->num_sbit_strikes;
617
618
619	if ( strike )
620	{
621	for ( ; strike < strike_limit; strike++ )
622	{
623	TT_SBit_Range range = strike->sbit_ranges;
624	TT_SBit_Range range_limit = range + strike->num_ranges;
625
626
627	if ( range )
628	{
629	for ( ; range < range_limit; range++ )
630	{
631	/* release the glyph offsets and codes tables */
632	/* where appropriate */
633	FT_FREE( range->glyph_offsets );
634	FT_FREE( range->glyph_codes );
635	}
636	}
637	FT_FREE( strike->sbit_ranges );
638	strike->num_ranges = 0;
639	}
640	FT_FREE( face->sbit_strikes );
641	}
642	face->num_sbit_strikes = 0;
643	}
644
645
646	FT_LOCAL_DEF( FT_Error )
647	tt_face_set_sbit_strike( TT_Face face,
648	FT_Size_Request req,
649	FT_ULong* astrike_index )
650	{
651	return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
652	}
653
654
655	FT_LOCAL_DEF( FT_Error )
656	tt_face_load_strike_metrics( TT_Face face,
657	FT_ULong strike_index,
658	FT_Size_Metrics* metrics )
659	{
660	TT_SBit_Strike strike;
661
662
663	if ( strike_index >= face->num_sbit_strikes )
664	return SFNT_Err_Invalid_Argument;
665
666	strike = face->sbit_strikes + strike_index;
667
668	metrics->x_ppem = strike->x_ppem;
669	metrics->y_ppem = strike->y_ppem;
670
671	metrics->ascender = strike->hori.ascender << 6;
672	metrics->descender = strike->hori.descender << 6;
673
674	/* XXX: Is this correct? */
675	metrics->max_advance = ( strike->hori.min_origin_SB +
676	strike->hori.max_width +
677	strike->hori.min_advance_SB ) << 6;
678
679	metrics->height = metrics->ascender - metrics->descender;
680
681	return SFNT_Err_Ok;
682	}
683
684
685	/*************************************************************************/
686	/* */
687	/* <Function> */
688	/* find_sbit_range */
689	/* */
690	/* <Description> */
691	/* Scans a given strike's ranges and return, for a given glyph */
692	/* index, the corresponding sbit range, and `EBDT' offset. */
693	/* */
694	/* <Input> */
695	/* glyph_index :: The glyph index. */
696	/* */
697	/* strike :: The source/current sbit strike. */
698	/* */
699	/* <Output> */
700	/* arange :: The sbit range containing the glyph index. */
701	/* */
702	/* aglyph_offset :: The offset of the glyph data in `EBDT' table. */
703	/* */
704	/* <Return> */
705	/* FreeType error code. 0 means the glyph index was found. */
706	/* */
707	static FT_Error
708	find_sbit_range( FT_UInt glyph_index,
709	TT_SBit_Strike strike,
710	TT_SBit_Range *arange,
711	FT_ULong *aglyph_offset )
712	{
713	TT_SBit_RangeRec range, range_limit;
714
715
716	/* check whether the glyph index is within this strike's */
717	/* glyph range */
718	if ( glyph_index < (FT_UInt)strike->start_glyph \|\|
719	glyph_index > (FT_UInt)strike->end_glyph )
720	goto Fail;
721
722	/* scan all ranges in strike */
723	range = strike->sbit_ranges;
724	range_limit = range + strike->num_ranges;
725	if ( !range )
726	goto Fail;
727
728	for ( ; range < range_limit; range++ )
729	{
730	if ( glyph_index >= (FT_UInt)range->first_glyph &&
731	glyph_index <= (FT_UInt)range->last_glyph )
732	{
733	FT_UShort delta = (FT_UShort)( glyph_index - range->first_glyph );
734
735
736	switch ( range->index_format )
737	{
738	case 1:
739	case 3:
740	*aglyph_offset = range->glyph_offsets[delta];
741	break;
742
743	case 2:
744	*aglyph_offset = range->image_offset +
745	range->image_size * delta;
746	break;
747
748	case 4:
749	case 5:
750	{
751	FT_ULong n;
752
753
754	for ( n = 0; n < range->num_glyphs; n++ )
755	{
756	if ( (FT_UInt)range->glyph_codes[n] == glyph_index )
757	{
758	if ( range->index_format == 4 )
759	*aglyph_offset = range->glyph_offsets[n];
760	else
761	*aglyph_offset = range->image_offset +
762	n * range->image_size;
763	goto Found;
764	}
765	}
766	}
767
768	/* fall-through */
769	default:
770	goto Fail;
771	}
772
773	Found:
774	/* return successfully! */
775	*arange = range;
776	return SFNT_Err_Ok;
777	}
778	}
779
780	Fail:
781	*arange = 0;
782	*aglyph_offset = 0;
783
784	return SFNT_Err_Invalid_Argument;
785	}
786
787
788	/*************************************************************************/
789	/* */
790	/* <Function> */
791	/* tt_find_sbit_image */
792	/* */
793	/* <Description> */
794	/* Checks whether an embedded bitmap (an `sbit') exists for a given */
795	/* glyph, at a given strike. */
796	/* */
797	/* <Input> */
798	/* face :: The target face object. */
799	/* */
800	/* glyph_index :: The glyph index. */
801	/* */
802	/* strike_index :: The current strike index. */
803	/* */
804	/* <Output> */
805	/* arange :: The SBit range containing the glyph index. */
806	/* */
807	/* astrike :: The SBit strike containing the glyph index. */
808	/* */
809	/* aglyph_offset :: The offset of the glyph data in `EBDT' table. */
810	/* */
811	/* <Return> */
812	/* FreeType error code. 0 means success. Returns */
813	/* SFNT_Err_Invalid_Argument if no sbit exists for the requested */
814	/* glyph. */
815	/* */
816	FT_LOCAL( FT_Error )
817	tt_find_sbit_image( TT_Face face,
818	FT_UInt glyph_index,
819	FT_ULong strike_index,
820	TT_SBit_Range *arange,
821	TT_SBit_Strike *astrike,
822	FT_ULong *aglyph_offset )
823	{
824	FT_Error error;
825	TT_SBit_Strike strike;
826
827
828	if ( !face->sbit_strikes \|\|
829	( face->num_sbit_strikes <= strike_index ) )
830	goto Fail;
831
832	strike = &face->sbit_strikes[strike_index];
833
834	error = find_sbit_range( glyph_index, strike,
835	arange, aglyph_offset );
836	if ( error )
837	goto Fail;
838
839	*astrike = strike;
840
841	return SFNT_Err_Ok;
842
843	Fail:
844	/* no embedded bitmap for this glyph in face */
845	*arange = 0;
846	*astrike = 0;
847	*aglyph_offset = 0;
848
849	return SFNT_Err_Invalid_Argument;
850	}
851
852
853	/*************************************************************************/
854	/* */
855	/* <Function> */
856	/* tt_load_sbit_metrics */
857	/* */
858	/* <Description> */
859	/* Gets the big metrics for a given SBit. */
860	/* */
861	/* <Input> */
862	/* stream :: The input stream. */
863	/* */
864	/* range :: The SBit range containing the glyph. */
865	/* */
866	/* <Output> */
867	/* big_metrics :: A big SBit metrics structure for the glyph. */
868	/* */
869	/* <Return> */
870	/* FreeType error code. 0 means success. */
871	/* */
872	/* <Note> */
873	/* The stream cursor must be positioned at the glyph's offset within */
874	/* the `EBDT' table before the call. */
875	/* */
876	/* If the image format uses variable metrics, the stream cursor is */
877	/* positioned just after the metrics header in the `EBDT' table on */
878	/* function exit. */
879	/* */
880	FT_LOCAL( FT_Error )
881	tt_load_sbit_metrics( FT_Stream stream,
882	TT_SBit_Range range,
883	TT_SBit_Metrics metrics )
884	{
885	FT_Error error = SFNT_Err_Ok;
886
887
888	switch ( range->image_format )
889	{
890	case 1:
891	case 2:
892	case 8:
893	/* variable small metrics */
894	{
895	TT_SBit_SmallMetricsRec smetrics;
896
897	static const FT_Frame_Field sbit_small_metrics_fields[] =
898	{
899	#undef FT_STRUCTURE
900	#define FT_STRUCTURE TT_SBit_SmallMetricsRec
901
902	FT_FRAME_START( 5 ),
903	FT_FRAME_BYTE( height ),
904	FT_FRAME_BYTE( width ),
905	FT_FRAME_CHAR( bearingX ),
906	FT_FRAME_CHAR( bearingY ),
907	FT_FRAME_BYTE( advance ),
908	FT_FRAME_END
909	};
910
911
912	/* read small metrics */
913	if ( FT_STREAM_READ_FIELDS( sbit_small_metrics_fields, &smetrics ) )
914	goto Exit;
915
916	/* convert it to a big metrics */
917	metrics->height = smetrics.height;
918	metrics->width = smetrics.width;
919	metrics->horiBearingX = smetrics.bearingX;
920	metrics->horiBearingY = smetrics.bearingY;
921	metrics->horiAdvance = smetrics.advance;
922
923	/* these metrics are made up at a higher level when */
924	/* needed. */
925	metrics->vertBearingX = 0;
926	metrics->vertBearingY = 0;
927	metrics->vertAdvance = 0;
928	}
929	break;
930
931	case 6:
932	case 7:
933	case 9:
934	/* variable big metrics */
935	if ( FT_STREAM_READ_FIELDS( sbit_metrics_fields, metrics ) )
936	goto Exit;
937	break;
938
939	case 5:
940	default: /* constant metrics */
941	if ( range->index_format == 2 \|\| range->index_format == 5 )
942	*metrics = range->metrics;
943	else
944	return SFNT_Err_Invalid_File_Format;
945	}
946
947	Exit:
948	return error;
949	}
950
951
952	/*************************************************************************/
953	/* */
954	/* <Function> */
955	/* crop_bitmap */
956	/* */
957	/* <Description> */
958	/* Crops a bitmap to its tightest bounding box, and adjusts its */
959	/* metrics. */
960	/* */
961	/* <InOut> */
962	/* map :: The bitmap. */
963	/* */
964	/* metrics :: The corresponding metrics structure. */
965	/* */
966	static void
967	crop_bitmap( FT_Bitmap* map,
968	TT_SBit_Metrics metrics )
969	{
970	/***********************************************************************/
971	/* */
972	/* In this situation, some bounding boxes of embedded bitmaps are too */
973	/* large. We need to crop it to a reasonable size. */
974	/* */
975	/* --------- */
976	/* \| \| ----- */
977	/* \| * \| \|\| /
978	/* \| * \| \| * \| */
979	/* \| * \| ------> \| * \| */
980	/* \| * \| \| * \| */
981	/* \| * \| \| * \| */
982	/* \| * \| \|\| /
983	/* --------- ----- */
984	/* */
985	/***********************************************************************/
986
987	FT_Int rows, count;
988	FT_Long line_len;
989	FT_Byte* line;
990
991
992	/***********************************************************************/
993	/* */
994	/* first of all, check the top-most lines of the bitmap, and remove */
995	/* them if they're empty. */
996	/* */
997	{
998	line = (FT_Byte*)map->buffer;
999	rows = map->rows;
1000	line_len = map->pitch;
1001
1002
1003	for ( count = 0; count < rows; count++ )
1004	{
1005	FT_Byte* cur = line;
1006	FT_Byte* limit = line + line_len;
1007
1008
1009	for ( ; cur < limit; cur++ )
1010	if ( cur[0] )
1011	goto Found_Top;
1012
1013	/* the current line was empty - skip to next one */
1014	line = limit;
1015	}
1016
1017	Found_Top:
1018	/* check that we have at least one filled line */
1019	if ( count >= rows )
1020	goto Empty_Bitmap;
1021
1022	/* now, crop the empty upper lines */
1023	if ( count > 0 )
1024	{
1025	line = (FT_Byte*)map->buffer;
1026
1027	FT_MEM_MOVE( line, line + count * line_len,
1028	( rows - count ) * line_len );
1029
1030	metrics->height = (FT_Byte)( metrics->height - count );
1031	metrics->horiBearingY = (FT_Char)( metrics->horiBearingY - count );
1032	metrics->vertBearingY = (FT_Char)( metrics->vertBearingY - count );
1033
1034	map->rows -= count;
1035	rows -= count;
1036	}
1037	}
1038
1039	/***********************************************************************/
1040	/* */
1041	/* second, crop the lower lines */
1042	/* */
1043	{
1044	line = (FT_Byte)map->buffer + ( rows - 1 ) line_len;
1045
1046	for ( count = 0; count < rows; count++ )
1047	{
1048	FT_Byte* cur = line;
1049	FT_Byte* limit = line + line_len;
1050
1051
1052	for ( ; cur < limit; cur++ )
1053	if ( cur[0] )
1054	goto Found_Bottom;
1055
1056	/* the current line was empty - skip to previous one */
1057	line -= line_len;
1058	}
1059
1060	Found_Bottom:
1061	if ( count > 0 )
1062	{
1063	metrics->height = (FT_Byte)( metrics->height - count );
1064	rows -= count;
1065	map->rows -= count;
1066	}
1067	}
1068
1069	/***********************************************************************/
1070	/* */
1071	/* third, get rid of the space on the left side of the glyph */
1072	/* */
1073	do
1074	{
1075	FT_Byte* limit;
1076
1077
1078	line = (FT_Byte*)map->buffer;
1079	limit = line + rows * line_len;
1080
1081	for ( ; line < limit; line += line_len )
1082	if ( line[0] & 0x80 )
1083	goto Found_Left;
1084
1085	/* shift the whole glyph one pixel to the left */
1086	line = (FT_Byte*)map->buffer;
1087	limit = line + rows * line_len;
1088
1089	for ( ; line < limit; line += line_len )
1090	{
1091	FT_Int n, width = map->width;
1092	FT_Byte old;
1093	FT_Byte* cur = line;
1094
1095
1096	old = (FT_Byte)(cur[0] << 1);
1097	for ( n = 8; n < width; n += 8 )
1098	{
1099	FT_Byte val;
1100
1101
1102	val = cur[1];
1103	cur[0] = (FT_Byte)( old \| ( val >> 7 ) );
1104	old = (FT_Byte)( val << 1 );
1105	cur++;
1106	}
1107	cur[0] = old;
1108	}
1109
1110	map->width--;
1111	metrics->horiBearingX++;
1112	metrics->vertBearingX++;
1113	metrics->width--;
1114
1115	} while ( map->width > 0 );
1116
1117	Found_Left:
1118
1119	/***********************************************************************/
1120	/* */
1121	/* finally, crop the bitmap width to get rid of the space on the right */
1122	/* side of the glyph. */
1123	/* */
1124	do
1125	{
1126	FT_Int right = map->width - 1;
1127	FT_Byte* limit;
1128	FT_Byte mask;
1129
1130
1131	line = (FT_Byte*)map->buffer + ( right >> 3 );
1132	limit = line + rows * line_len;
1133	mask = (FT_Byte)( 0x80 >> ( right & 7 ) );
1134
1135	for ( ; line < limit; line += line_len )
1136	if ( line[0] & mask )
1137	goto Found_Right;
1138
1139	/* crop the whole glyph to the right */
1140	map->width--;
1141	metrics->width--;
1142
1143	} while ( map->width > 0 );
1144
1145	Found_Right:
1146	/* all right, the bitmap was cropped */
1147	return;
1148
1149	Empty_Bitmap:
1150	map->width = 0;
1151	map->rows = 0;
1152	map->pitch = 0;
1153	map->pixel_mode = FT_PIXEL_MODE_MONO;
1154	}
1155
1156
1157	static FT_Error
1158	Load_SBit_Single( FT_Bitmap* map,
1159	FT_Int x_offset,
1160	FT_Int y_offset,
1161	FT_Int pix_bits,
1162	FT_UShort image_format,
1163	TT_SBit_Metrics metrics,
1164	FT_Stream stream )
1165	{
1166	FT_Error error;
1167
1168
1169	/* check that the source bitmap fits into the target pixmap */
1170	if ( x_offset < 0 \|\| x_offset + metrics->width > map->width \|\|
1171	y_offset < 0 \|\| y_offset + metrics->height > map->rows )
1172	{
1173	error = SFNT_Err_Invalid_Argument;
1174
1175	goto Exit;
1176	}
1177
1178	{
1179	FT_Int glyph_width = metrics->width;
1180	FT_Int glyph_height = metrics->height;
1181	FT_Int glyph_size;
1182	FT_Int line_bits = pix_bits * glyph_width;
1183	FT_Bool pad_bytes = 0;
1184
1185
1186	/* compute size of glyph image */
1187	switch ( image_format )
1188	{
1189	case 1: /* byte-padded formats */
1190	case 6:
1191	{
1192	FT_Int line_length;
1193
1194
1195	switch ( pix_bits )
1196	{
1197	case 1:
1198	line_length = ( glyph_width + 7 ) >> 3;
1199	break;
1200	case 2:
1201	line_length = ( glyph_width + 3 ) >> 2;
1202	break;
1203	case 4:
1204	line_length = ( glyph_width + 1 ) >> 1;
1205	break;
1206	default:
1207	line_length = glyph_width;
1208	}
1209
1210	glyph_size = glyph_height * line_length;
1211	pad_bytes = 1;
1212	}
1213	break;
1214
1215	case 2:
1216	case 5:
1217	case 7:
1218	line_bits = glyph_width * pix_bits;
1219	glyph_size = ( glyph_height * line_bits + 7 ) >> 3;
1220	break;
1221
1222	default: /* invalid format */
1223	return SFNT_Err_Invalid_File_Format;
1224	}
1225
1226	/* Now read data and draw glyph into target pixmap */
1227	if ( FT_FRAME_ENTER( glyph_size ) )
1228	goto Exit;
1229
1230	/* don't forget to multiply `x_offset' by `map->pix_bits' as */
1231	/* the sbit blitter doesn't make a difference between pixmap */
1232	/* depths. */
1233	blit_sbit( map, (FT_Byte*)stream->cursor, line_bits, pad_bytes,
1234	x_offset * pix_bits, y_offset, metrics->height );
1235
1236	FT_FRAME_EXIT();
1237	}
1238
1239	Exit:
1240	return error;
1241	}
1242
1243
1244	static FT_Error
1245	Load_SBit_Image( TT_SBit_Strike strike,
1246	TT_SBit_Range range,
1247	FT_ULong ebdt_pos,
1248	FT_ULong glyph_offset,
1249	FT_GlyphSlot slot,
1250	FT_Int x_offset,
1251	FT_Int y_offset,
1252	FT_Stream stream,
1253	TT_SBit_Metrics metrics,
1254	FT_Int depth )
1255	{
1256	FT_Memory memory = stream->memory;
1257	FT_Bitmap* map = &slot->bitmap;
1258	FT_Error error;
1259
1260
1261	/* place stream at beginning of glyph data and read metrics */
1262	if ( FT_STREAM_SEEK( ebdt_pos + glyph_offset ) )
1263	goto Exit;
1264
1265	error = tt_load_sbit_metrics( stream, range, metrics );
1266	if ( error )
1267	goto Exit;
1268
1269	/* This function is recursive. At the top-level call, we */
1270	/* compute the dimensions of the higher-level glyph to */
1271	/* allocate the final pixmap buffer. */
1272	if ( depth == 0 )
1273	{
1274	FT_Long size;
1275
1276
1277	map->width = metrics->width;
1278	map->rows = metrics->height;
1279
1280	switch ( strike->bit_depth )
1281	{
1282	case 1:
1283	map->pixel_mode = FT_PIXEL_MODE_MONO;
1284	map->pitch = ( map->width + 7 ) >> 3;
1285	break;
1286
1287	case 2:
1288	map->pixel_mode = FT_PIXEL_MODE_GRAY2;
1289	map->pitch = ( map->width + 3 ) >> 2;
1290	break;
1291
1292	case 4:
1293	map->pixel_mode = FT_PIXEL_MODE_GRAY4;
1294	map->pitch = ( map->width + 1 ) >> 1;
1295	break;
1296
1297	case 8:
1298	map->pixel_mode = FT_PIXEL_MODE_GRAY;
1299	map->pitch = map->width;
1300	break;
1301
1302	default:
1303	return SFNT_Err_Invalid_File_Format;
1304	}
1305
1306	size = map->rows * map->pitch;
1307
1308	/* check that there is no empty image */
1309	if ( size == 0 )
1310	goto Exit; /* exit successfully! */
1311
1312	error = ft_glyphslot_alloc_bitmap( slot, size );
1313	if (error)
1314	goto Exit;
1315	}
1316
1317	switch ( range->image_format )
1318	{
1319	case 1: /* single sbit image - load it */
1320	case 2:
1321	case 5:
1322	case 6:
1323	case 7:
1324	return Load_SBit_Single( map, x_offset, y_offset, strike->bit_depth,
1325	range->image_format, metrics, stream );
1326
1327	case 8: /* compound format */
1328	if ( FT_STREAM_SKIP( 1L ) )
1329	{
1330	error = SFNT_Err_Invalid_Stream_Skip;
1331	goto Exit;
1332	}
1333	/* fallthrough */
1334
1335	case 9:
1336	break;
1337
1338	default: /* invalid image format */
1339	return SFNT_Err_Invalid_File_Format;
1340	}
1341
1342	/* All right, we have a compound format. First of all, read */
1343	/* the array of elements. */
1344	{
1345	TT_SBit_Component components;
1346	TT_SBit_Component comp;
1347	FT_UShort num_components, count;
1348
1349
1350	if ( FT_READ_USHORT( num_components ) \|\|
1351	FT_NEW_ARRAY( components, num_components ) )
1352	goto Exit;
1353
1354	count = num_components;
1355
1356	if ( FT_FRAME_ENTER( 4L * num_components ) )
1357	goto Fail_Memory;
1358
1359	for ( comp = components; count > 0; count--, comp++ )
1360	{
1361	comp->glyph_code = FT_GET_USHORT();
1362	comp->x_offset = FT_GET_CHAR();
1363	comp->y_offset = FT_GET_CHAR();
1364	}
1365
1366	FT_FRAME_EXIT();
1367
1368	/* Now recursively load each element glyph */
1369	count = num_components;
1370	comp = components;
1371	for ( ; count > 0; count--, comp++ )
1372	{
1373	TT_SBit_Range elem_range;
1374	TT_SBit_MetricsRec elem_metrics;
1375	FT_ULong elem_offset;
1376
1377
1378	/* find the range for this element */
1379	error = find_sbit_range( comp->glyph_code,
1380	strike,
1381	&elem_range,
1382	&elem_offset );
1383	if ( error )
1384	goto Fail_Memory;
1385
1386	/* now load the element, recursively */
1387	error = Load_SBit_Image( strike,
1388	elem_range,
1389	ebdt_pos,
1390	elem_offset,
1391	slot,
1392	x_offset + comp->x_offset,
1393	y_offset + comp->y_offset,
1394	stream,
1395	&elem_metrics,
1396	depth + 1 );
1397	if ( error )
1398	goto Fail_Memory;
1399	}
1400
1401	Fail_Memory:
1402	FT_FREE( components );
1403	}
1404
1405	Exit:
1406	return error;
1407	}
1408
1409
1410	/*************************************************************************/
1411	/* */
1412	/* <Function> */
1413	/* tt_face_load_sbit_image */
1414	/* */
1415	/* <Description> */
1416	/* Loads a given glyph sbit image from the font resource. This also */
1417	/* returns its metrics. */
1418	/* */
1419	/* <Input> */
1420	/* face :: The target face object. */
1421	/* */
1422	/* strike_index :: The current strike index. */
1423	/* */
1424	/* glyph_index :: The current glyph index. */
1425	/* */
1426	/* load_flags :: The glyph load flags (the code checks for the flag */
1427	/* FT_LOAD_CROP_BITMAP). */
1428	/* */
1429	/* stream :: The input stream. */
1430	/* */
1431	/* <Output> */
1432	/* map :: The target pixmap. */
1433	/* */
1434	/* metrics :: A big sbit metrics structure for the glyph image. */
1435	/* */
1436	/* <Return> */
1437	/* FreeType error code. 0 means success. Returns an error if no */
1438	/* glyph sbit exists for the index. */
1439	/* */
1440	/* <Note> */
1441	/* The `map.buffer' field is always freed before the glyph is loaded. */
1442	/* */
1443	FT_LOCAL_DEF( FT_Error )
1444	tt_face_load_sbit_image( TT_Face face,
1445	FT_ULong strike_index,
1446	FT_UInt glyph_index,
1447	FT_UInt load_flags,
1448	FT_Stream stream,
1449	FT_Bitmap *map,
1450	TT_SBit_MetricsRec *metrics )
1451	{
1452	FT_Error error;
1453	FT_ULong ebdt_pos, glyph_offset;
1454
1455	TT_SBit_Strike strike;
1456	TT_SBit_Range range;
1457
1458
1459	/* Check whether there is a glyph sbit for the current index */
1460	error = tt_find_sbit_image( face, glyph_index, strike_index,
1461	&range, &strike, &glyph_offset );
1462	if ( error )
1463	goto Exit;
1464
1465	/* now, find the location of the `EBDT' table in */
1466	/* the font file */
1467	error = face->goto_table( face, TTAG_EBDT, stream, 0 );
1468	if ( error )
1469	error = face->goto_table( face, TTAG_bdat, stream, 0 );
1470	if ( error )
1471	goto Exit;
1472
1473	ebdt_pos = FT_STREAM_POS();
1474
1475	error = Load_SBit_Image( strike, range, ebdt_pos, glyph_offset,
1476	face->root.glyph, 0, 0, stream, metrics, 0 );
1477	if ( error )
1478	goto Exit;
1479
1480	/* setup vertical metrics if needed */
1481	if ( strike->flags & 1 )
1482	{
1483	/* in case of a horizontal strike only */
1484	FT_Int advance;
1485
1486
1487	advance = strike->hori.ascender - strike->hori.descender;
1488
1489	/* some heuristic values */
1490
1491	metrics->vertBearingX = (FT_Char)(-metrics->width / 2 );
1492	metrics->vertBearingY = (FT_Char)( ( advance - metrics->height ) / 2 );
1493	metrics->vertAdvance = (FT_Char)( advance * 12 / 10 );
1494	}
1495
1496	/* Crop the bitmap now, unless specified otherwise */
1497	if ( load_flags & FT_LOAD_CROP_BITMAP )
1498	crop_bitmap( map, metrics );
1499
1500	Exit:
1501	return error;
1502	}
1503
1504	#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
1505
1506
1507	/* END */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/trunk/zasc/freetype-2.3.9/ttsbit.c

Download in other formats: