Context Navigation

source: trunk/poppler/freetype2/src/base/ftlcdfil.c @ 262

Last change on this file since 262 was 262, checked in by Eugene Romanenko, 12 years ago
PDF plugin: freetype library updated to version 2.3.8
File size: 9.4 KB

Line
1	/***************************************************************************/
2	/* */
3	/* ftlcdfil.c */
4	/* */
5	/* FreeType API for color filtering of subpixel bitmap glyphs (body). */
6	/* */
7	/* Copyright 2006, 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
19	#include <ft2build.h>
20	#include FT_LCD_FILTER_H
21	#include FT_IMAGE_H
22	#include FT_INTERNAL_OBJECTS_H
23
24
25	#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
26
27	/* define USE_LEGACY to implement the legacy filter */
28	#define USE_LEGACY
29
30	/* FIR filter used by the default and light filters */
31	static void
32	_ft_lcd_filter_fir( FT_Bitmap* bitmap,
33	FT_Render_Mode mode,
34	FT_Library library )
35	{
36	FT_Byte* weights = library->lcd_weights;
37	FT_UInt width = (FT_UInt)bitmap->width;
38	FT_UInt height = (FT_UInt)bitmap->rows;
39
40
41	/* horizontal in-place FIR filter */
42	if ( mode == FT_RENDER_MODE_LCD && width >= 4 )
43	{
44	FT_Byte* line = bitmap->buffer;
45
46
47	for ( ; height > 0; height--, line += bitmap->pitch )
48	{
49	FT_UInt fir[5];
50	FT_UInt val1, xx;
51
52
53	val1 = line[0];
54	fir[0] = weights[2] * val1;
55	fir[1] = weights[3] * val1;
56	fir[2] = weights[4] * val1;
57	fir[3] = 0;
58	fir[4] = 0;
59
60	val1 = line[1];
61	fir[0] += weights[1] * val1;
62	fir[1] += weights[2] * val1;
63	fir[2] += weights[3] * val1;
64	fir[3] += weights[4] * val1;
65
66	for ( xx = 2; xx < width; xx++ )
67	{
68	FT_UInt val, pix;
69
70
71	val = line[xx];
72	pix = fir[0] + weights[0] * val;
73	fir[0] = fir[1] + weights[1] * val;
74	fir[1] = fir[2] + weights[2] * val;
75	fir[2] = fir[3] + weights[3] * val;
76	fir[3] = weights[4] * val;
77
78	pix >>= 8;
79	pix \|= -( pix >> 8 );
80	line[xx - 2] = (FT_Byte)pix;
81	}
82
83	{
84	FT_UInt pix;
85
86
87	pix = fir[0] >> 8;
88	pix \|= -( pix >> 8 );
89	line[xx - 2] = (FT_Byte)pix;
90
91	pix = fir[1] >> 8;
92	pix \|= -( pix >> 8 );
93	line[xx - 1] = (FT_Byte)pix;
94	}
95	}
96	}
97
98	/* vertical in-place FIR filter */
99	else if ( mode == FT_RENDER_MODE_LCD_V && height >= 4 )
100	{
101	FT_Byte* column = bitmap->buffer;
102	FT_Int pitch = bitmap->pitch;
103
104
105	for ( ; width > 0; width--, column++ )
106	{
107	FT_Byte* col = column;
108	FT_UInt fir[5];
109	FT_UInt val1, yy;
110
111
112	val1 = col[0];
113	fir[0] = weights[2] * val1;
114	fir[1] = weights[3] * val1;
115	fir[2] = weights[4] * val1;
116	fir[3] = 0;
117	fir[4] = 0;
118	col += pitch;
119
120	val1 = col[0];
121	fir[0] += weights[1] * val1;
122	fir[1] += weights[2] * val1;
123	fir[2] += weights[3] * val1;
124	fir[3] += weights[4] * val1;
125	col += pitch;
126
127	for ( yy = 2; yy < height; yy++ )
128	{
129	FT_UInt val, pix;
130
131
132	val = col[0];
133	pix = fir[0] + weights[0] * val;
134	fir[0] = fir[1] + weights[1] * val;
135	fir[1] = fir[2] + weights[2] * val;
136	fir[2] = fir[3] + weights[3] * val;
137	fir[3] = weights[4] * val;
138
139	pix >>= 8;
140	pix \|= -( pix >> 8 );
141	col[-2 * pitch] = (FT_Byte)pix;
142	col += pitch;
143	}
144
145	{
146	FT_UInt pix;
147
148
149	pix = fir[0] >> 8;
150	pix \|= -( pix >> 8 );
151	col[-2 * pitch] = (FT_Byte)pix;
152
153	pix = fir[1] >> 8;
154	pix \|= -( pix >> 8 );
155	col[-pitch] = (FT_Byte)pix;
156	}
157	}
158	}
159	}
160
161
162	#ifdef USE_LEGACY
163
164	/* intra-pixel filter used by the legacy filter */
165	static void
166	_ft_lcd_filter_legacy( FT_Bitmap* bitmap,
167	FT_Render_Mode mode,
168	FT_Library library )
169	{
170	FT_UInt width = (FT_UInt)bitmap->width;
171	FT_UInt height = (FT_UInt)bitmap->rows;
172	FT_Int pitch = bitmap->pitch;
173
174	static const int filters[3][3] =
175	{
176	{ 65538 * 9/13, 65538 * 1/6, 65538 * 1/13 },
177	{ 65538 * 3/13, 65538 * 4/6, 65538 * 3/13 },
178	{ 65538 * 1/13, 65538 * 1/6, 65538 * 9/13 }
179	};
180
181	FT_UNUSED( library );
182
183
184	/* horizontal in-place intra-pixel filter */
185	if ( mode == FT_RENDER_MODE_LCD && width >= 3 )
186	{
187	FT_Byte* line = bitmap->buffer;
188
189
190	for ( ; height > 0; height--, line += pitch )
191	{
192	FT_UInt xx;
193
194
195	for ( xx = 0; xx < width; xx += 3 )
196	{
197	FT_UInt r = 0;
198	FT_UInt g = 0;
199	FT_UInt b = 0;
200	FT_UInt p;
201
202
203	p = line[xx];
204	r += filters[0][0] * p;
205	g += filters[0][1] * p;
206	b += filters[0][2] * p;
207
208	p = line[xx + 1];
209	r += filters[1][0] * p;
210	g += filters[1][1] * p;
211	b += filters[1][2] * p;
212
213	p = line[xx + 2];
214	r += filters[2][0] * p;
215	g += filters[2][1] * p;
216	b += filters[2][2] * p;
217
218	line[xx] = (FT_Byte)( r / 65536 );
219	line[xx + 1] = (FT_Byte)( g / 65536 );
220	line[xx + 2] = (FT_Byte)( b / 65536 );
221	}
222	}
223	}
224	else if ( mode == FT_RENDER_MODE_LCD_V && height >= 3 )
225	{
226	FT_Byte* column = bitmap->buffer;
227
228
229	for ( ; width > 0; width--, column++ )
230	{
231	FT_Byte* col = column;
232	FT_Byte* col_end = col + height * pitch;
233
234
235	for ( ; col < col_end; col += 3 * pitch )
236	{
237	FT_UInt r = 0;
238	FT_UInt g = 0;
239	FT_UInt b = 0;
240	FT_UInt p;
241
242
243	p = col[0];
244	r += filters[0][0] * p;
245	g += filters[0][1] * p;
246	b += filters[0][2] * p;
247
248	p = col[pitch];
249	r += filters[1][0] * p;
250	g += filters[1][1] * p;
251	b += filters[1][2] * p;
252
253	p = col[pitch * 2];
254	r += filters[2][0] * p;
255	g += filters[2][1] * p;
256	b += filters[2][2] * p;
257
258	col[0] = (FT_Byte)( r / 65536 );
259	col[pitch] = (FT_Byte)( g / 65536 );
260	col[2 * pitch] = (FT_Byte)( b / 65536 );
261	}
262	}
263	}
264	}
265
266	#endif /* USE_LEGACY */
267
268
269	FT_EXPORT_DEF( FT_Error )
270	FT_Library_SetLcdFilter( FT_Library library,
271	FT_LcdFilter filter )
272	{
273	static const FT_Byte light_filter[5] =
274	{ 0, 85, 86, 85, 0 };
275	/* the values here sum up to a value larger than 256, */
276	/* providing a cheap gamma correction */
277	static const FT_Byte default_filter[5] =
278	{ 0x10, 0x40, 0x70, 0x40, 0x10 };
279
280
281	if ( library == NULL )
282	return FT_Err_Invalid_Argument;
283
284	switch ( filter )
285	{
286	case FT_LCD_FILTER_NONE:
287	library->lcd_filter_func = NULL;
288	library->lcd_extra = 0;
289	break;
290
291	case FT_LCD_FILTER_DEFAULT:
292	#if defined( FT_FORCE_LEGACY_LCD_FILTER )
293
294	library->lcd_filter_func = _ft_lcd_filter_legacy;
295	library->lcd_extra = 0;
296
297	#elif defined( FT_FORCE_LIGHT_LCD_FILTER )
298
299	ft_memcpy( library->lcd_weights, light_filter, 5 );
300	library->lcd_filter_func = _ft_lcd_filter_fir;
301	library->lcd_extra = 2;
302
303	#else
304
305	ft_memcpy( library->lcd_weights, default_filter, 5 );
306	library->lcd_filter_func = _ft_lcd_filter_fir;
307	library->lcd_extra = 2;
308
309	#endif
310
311	break;
312
313	case FT_LCD_FILTER_LIGHT:
314	ft_memcpy( library->lcd_weights, light_filter, 5 );
315	library->lcd_filter_func = _ft_lcd_filter_fir;
316	library->lcd_extra = 2;
317	break;
318
319	#ifdef USE_LEGACY
320
321	case FT_LCD_FILTER_LEGACY:
322	library->lcd_filter_func = _ft_lcd_filter_legacy;
323	library->lcd_extra = 0;
324	break;
325
326	#endif
327
328	default:
329	return FT_Err_Invalid_Argument;
330	}
331
332	library->lcd_filter = filter;
333	return 0;
334	}
335
336	#else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
337
338	FT_EXPORT_DEF( FT_Error )
339	FT_Library_SetLcdFilter( FT_Library library,
340	FT_LcdFilter filter )
341	{
342	FT_UNUSED( library );
343	FT_UNUSED( filter );
344
345	return FT_Err_Unimplemented_Feature;
346	}
347
348	#endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
349
350
351	/* END */

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

Download in other formats: