1 /***************************************************************************/ |
|
2 /* */ |
|
3 /* ftlcdfil.c */ |
|
4 /* */ |
|
5 /* FreeType API for color filtering of subpixel bitmap glyphs (body). */ |
|
6 /* */ |
|
7 /* Copyright 2006, 2008, 2009, 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 <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_SetLcdFilterWeights( FT_Library library, |
|
271 unsigned char *weights ) |
|
272 { |
|
273 if ( !library || !weights ) |
|
274 return FT_Err_Invalid_Argument; |
|
275 |
|
276 ft_memcpy( library->lcd_weights, weights, 5 ); |
|
277 |
|
278 return FT_Err_Ok; |
|
279 } |
|
280 |
|
281 |
|
282 FT_EXPORT_DEF( FT_Error ) |
|
283 FT_Library_SetLcdFilter( FT_Library library, |
|
284 FT_LcdFilter filter ) |
|
285 { |
|
286 static const FT_Byte light_filter[5] = |
|
287 { 0x00, 0x55, 0x56, 0x55, 0x00 }; |
|
288 /* the values here sum up to a value larger than 256, */ |
|
289 /* providing a cheap gamma correction */ |
|
290 static const FT_Byte default_filter[5] = |
|
291 { 0x10, 0x40, 0x70, 0x40, 0x10 }; |
|
292 |
|
293 |
|
294 if ( !library ) |
|
295 return FT_Err_Invalid_Argument; |
|
296 |
|
297 switch ( filter ) |
|
298 { |
|
299 case FT_LCD_FILTER_NONE: |
|
300 library->lcd_filter_func = NULL; |
|
301 library->lcd_extra = 0; |
|
302 break; |
|
303 |
|
304 case FT_LCD_FILTER_DEFAULT: |
|
305 #if defined( FT_FORCE_LEGACY_LCD_FILTER ) |
|
306 |
|
307 library->lcd_filter_func = _ft_lcd_filter_legacy; |
|
308 library->lcd_extra = 0; |
|
309 |
|
310 #elif defined( FT_FORCE_LIGHT_LCD_FILTER ) |
|
311 |
|
312 ft_memcpy( library->lcd_weights, light_filter, 5 ); |
|
313 library->lcd_filter_func = _ft_lcd_filter_fir; |
|
314 library->lcd_extra = 2; |
|
315 |
|
316 #else |
|
317 |
|
318 ft_memcpy( library->lcd_weights, default_filter, 5 ); |
|
319 library->lcd_filter_func = _ft_lcd_filter_fir; |
|
320 library->lcd_extra = 2; |
|
321 |
|
322 #endif |
|
323 |
|
324 break; |
|
325 |
|
326 case FT_LCD_FILTER_LIGHT: |
|
327 ft_memcpy( library->lcd_weights, light_filter, 5 ); |
|
328 library->lcd_filter_func = _ft_lcd_filter_fir; |
|
329 library->lcd_extra = 2; |
|
330 break; |
|
331 |
|
332 #ifdef USE_LEGACY |
|
333 |
|
334 case FT_LCD_FILTER_LEGACY: |
|
335 library->lcd_filter_func = _ft_lcd_filter_legacy; |
|
336 library->lcd_extra = 0; |
|
337 break; |
|
338 |
|
339 #endif |
|
340 |
|
341 default: |
|
342 return FT_Err_Invalid_Argument; |
|
343 } |
|
344 |
|
345 library->lcd_filter = filter; |
|
346 |
|
347 return FT_Err_Ok; |
|
348 } |
|
349 |
|
350 #else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ |
|
351 |
|
352 FT_EXPORT_DEF( FT_Error ) |
|
353 FT_Library_SetLcdFilterWeights( FT_Library library, |
|
354 unsigned char *weights ) |
|
355 { |
|
356 FT_UNUSED( library ); |
|
357 FT_UNUSED( weights ); |
|
358 |
|
359 return FT_Err_Unimplemented_Feature; |
|
360 } |
|
361 |
|
362 |
|
363 FT_EXPORT_DEF( FT_Error ) |
|
364 FT_Library_SetLcdFilter( FT_Library library, |
|
365 FT_LcdFilter filter ) |
|
366 { |
|
367 FT_UNUSED( library ); |
|
368 FT_UNUSED( filter ); |
|
369 |
|
370 return FT_Err_Unimplemented_Feature; |
|
371 } |
|
372 |
|
373 #endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ |
|
374 |
|
375 |
|
376 /* END */ |
|