1 | /**************************************************************************** |
2 | * |
3 | * ftlcdfil.c |
4 | * |
5 | * FreeType API for color filtering of subpixel bitmap glyphs (body). |
6 | * |
7 | * Copyright (C) 2006-2023 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 <freetype/internal/ftdebug.h> |
20 | |
21 | #include <freetype/ftlcdfil.h> |
22 | #include <freetype/ftimage.h> |
23 | #include <freetype/internal/ftobjs.h> |
24 | |
25 | |
26 | #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING |
27 | |
28 | /* define USE_LEGACY to implement the legacy filter */ |
29 | #define USE_LEGACY |
30 | |
31 | #define FT_SHIFTCLAMP( x ) ( x >>= 8, (FT_Byte)( x > 255 ? 255 : x ) ) |
32 | |
33 | |
34 | /* add padding according to filter weights */ |
35 | FT_BASE_DEF( void ) |
36 | ft_lcd_padding( FT_BBox* cbox, |
37 | FT_GlyphSlot slot, |
38 | FT_Render_Mode mode ) |
39 | { |
40 | FT_Byte* lcd_weights; |
41 | FT_Bitmap_LcdFilterFunc lcd_filter_func; |
42 | |
43 | |
44 | /* Per-face LCD filtering takes priority if set up. */ |
45 | if ( slot->face && slot->face->internal->lcd_filter_func ) |
46 | { |
47 | lcd_weights = slot->face->internal->lcd_weights; |
48 | lcd_filter_func = slot->face->internal->lcd_filter_func; |
49 | } |
50 | else |
51 | { |
52 | lcd_weights = slot->library->lcd_weights; |
53 | lcd_filter_func = slot->library->lcd_filter_func; |
54 | } |
55 | |
56 | if ( lcd_filter_func == ft_lcd_filter_fir ) |
57 | { |
58 | if ( mode == FT_RENDER_MODE_LCD ) |
59 | { |
60 | cbox->xMin -= lcd_weights[0] ? 43 : |
61 | lcd_weights[1] ? 22 : 0; |
62 | cbox->xMax += lcd_weights[4] ? 43 : |
63 | lcd_weights[3] ? 22 : 0; |
64 | } |
65 | else if ( mode == FT_RENDER_MODE_LCD_V ) |
66 | { |
67 | cbox->yMin -= lcd_weights[0] ? 43 : |
68 | lcd_weights[1] ? 22 : 0; |
69 | cbox->yMax += lcd_weights[4] ? 43 : |
70 | lcd_weights[3] ? 22 : 0; |
71 | } |
72 | } |
73 | } |
74 | |
75 | |
76 | /* FIR filter used by the default and light filters */ |
77 | FT_BASE_DEF( void ) |
78 | ft_lcd_filter_fir( FT_Bitmap* bitmap, |
79 | FT_LcdFiveTapFilter weights ) |
80 | { |
81 | FT_UInt width = (FT_UInt)bitmap->width; |
82 | FT_UInt height = (FT_UInt)bitmap->rows; |
83 | FT_Int pitch = bitmap->pitch; |
84 | FT_Byte* origin = bitmap->buffer; |
85 | FT_Byte mode = bitmap->pixel_mode; |
86 | |
87 | |
88 | /* take care of bitmap flow */ |
89 | if ( pitch > 0 && height > 0 ) |
90 | origin += pitch * (FT_Int)( height - 1 ); |
91 | |
92 | /* horizontal in-place FIR filter */ |
93 | if ( mode == FT_PIXEL_MODE_LCD && width >= 2 ) |
94 | { |
95 | FT_Byte* line = origin; |
96 | |
97 | |
98 | /* `fir' must be at least 32 bit wide, since the sum of */ |
99 | /* the values in `weights' can exceed 0xFF */ |
100 | |
101 | for ( ; height > 0; height--, line -= pitch ) |
102 | { |
103 | FT_UInt fir[5]; |
104 | FT_UInt val, xx; |
105 | |
106 | |
107 | val = line[0]; |
108 | fir[2] = weights[2] * val; |
109 | fir[3] = weights[3] * val; |
110 | fir[4] = weights[4] * val; |
111 | |
112 | val = line[1]; |
113 | fir[1] = fir[2] + weights[1] * val; |
114 | fir[2] = fir[3] + weights[2] * val; |
115 | fir[3] = fir[4] + weights[3] * val; |
116 | fir[4] = weights[4] * val; |
117 | |
118 | for ( xx = 2; xx < width; xx++ ) |
119 | { |
120 | val = line[xx]; |
121 | fir[0] = fir[1] + weights[0] * val; |
122 | fir[1] = fir[2] + weights[1] * val; |
123 | fir[2] = fir[3] + weights[2] * val; |
124 | fir[3] = fir[4] + weights[3] * val; |
125 | fir[4] = weights[4] * val; |
126 | |
127 | line[xx - 2] = FT_SHIFTCLAMP( fir[0] ); |
128 | } |
129 | |
130 | line[xx - 2] = FT_SHIFTCLAMP( fir[1] ); |
131 | line[xx - 1] = FT_SHIFTCLAMP( fir[2] ); |
132 | } |
133 | } |
134 | |
135 | /* vertical in-place FIR filter */ |
136 | else if ( mode == FT_PIXEL_MODE_LCD_V && height >= 2 ) |
137 | { |
138 | FT_Byte* column = origin; |
139 | |
140 | |
141 | for ( ; width > 0; width--, column++ ) |
142 | { |
143 | FT_Byte* col = column; |
144 | FT_UInt fir[5]; |
145 | FT_UInt val, yy; |
146 | |
147 | |
148 | val = col[0]; |
149 | fir[2] = weights[2] * val; |
150 | fir[3] = weights[3] * val; |
151 | fir[4] = weights[4] * val; |
152 | col -= pitch; |
153 | |
154 | val = col[0]; |
155 | fir[1] = fir[2] + weights[1] * val; |
156 | fir[2] = fir[3] + weights[2] * val; |
157 | fir[3] = fir[4] + weights[3] * val; |
158 | fir[4] = weights[4] * val; |
159 | col -= pitch; |
160 | |
161 | for ( yy = 2; yy < height; yy++, col -= pitch ) |
162 | { |
163 | val = col[0]; |
164 | fir[0] = fir[1] + weights[0] * val; |
165 | fir[1] = fir[2] + weights[1] * val; |
166 | fir[2] = fir[3] + weights[2] * val; |
167 | fir[3] = fir[4] + weights[3] * val; |
168 | fir[4] = weights[4] * val; |
169 | |
170 | col[pitch * 2] = FT_SHIFTCLAMP( fir[0] ); |
171 | } |
172 | |
173 | col[pitch * 2] = FT_SHIFTCLAMP( fir[1] ); |
174 | col[pitch] = FT_SHIFTCLAMP( fir[2] ); |
175 | } |
176 | } |
177 | } |
178 | |
179 | |
180 | #ifdef USE_LEGACY |
181 | |
182 | /* intra-pixel filter used by the legacy filter */ |
183 | static void |
184 | _ft_lcd_filter_legacy( FT_Bitmap* bitmap, |
185 | FT_Byte* weights ) |
186 | { |
187 | FT_UInt width = (FT_UInt)bitmap->width; |
188 | FT_UInt height = (FT_UInt)bitmap->rows; |
189 | FT_Int pitch = bitmap->pitch; |
190 | FT_Byte* origin = bitmap->buffer; |
191 | FT_Byte mode = bitmap->pixel_mode; |
192 | |
193 | static const unsigned int filters[3][3] = |
194 | { |
195 | { 65538 * 9/13, 65538 * 1/6, 65538 * 1/13 }, |
196 | { 65538 * 3/13, 65538 * 4/6, 65538 * 3/13 }, |
197 | { 65538 * 1/13, 65538 * 1/6, 65538 * 9/13 } |
198 | }; |
199 | |
200 | FT_UNUSED( weights ); |
201 | |
202 | |
203 | /* take care of bitmap flow */ |
204 | if ( pitch > 0 && height > 0 ) |
205 | origin += pitch * (FT_Int)( height - 1 ); |
206 | |
207 | /* horizontal in-place intra-pixel filter */ |
208 | if ( mode == FT_PIXEL_MODE_LCD && width >= 3 ) |
209 | { |
210 | FT_Byte* line = origin; |
211 | |
212 | |
213 | for ( ; height > 0; height--, line -= pitch ) |
214 | { |
215 | FT_UInt xx; |
216 | |
217 | |
218 | for ( xx = 0; xx < width; xx += 3 ) |
219 | { |
220 | FT_UInt r, g, b; |
221 | FT_UInt p; |
222 | |
223 | |
224 | p = line[xx]; |
225 | r = filters[0][0] * p; |
226 | g = filters[0][1] * p; |
227 | b = filters[0][2] * p; |
228 | |
229 | p = line[xx + 1]; |
230 | r += filters[1][0] * p; |
231 | g += filters[1][1] * p; |
232 | b += filters[1][2] * p; |
233 | |
234 | p = line[xx + 2]; |
235 | r += filters[2][0] * p; |
236 | g += filters[2][1] * p; |
237 | b += filters[2][2] * p; |
238 | |
239 | line[xx] = (FT_Byte)( r / 65536 ); |
240 | line[xx + 1] = (FT_Byte)( g / 65536 ); |
241 | line[xx + 2] = (FT_Byte)( b / 65536 ); |
242 | } |
243 | } |
244 | } |
245 | else if ( mode == FT_PIXEL_MODE_LCD_V && height >= 3 ) |
246 | { |
247 | FT_Byte* column = origin; |
248 | |
249 | |
250 | for ( ; width > 0; width--, column++ ) |
251 | { |
252 | FT_Byte* col = column - 2 * pitch; |
253 | |
254 | |
255 | for ( ; height > 0; height -= 3, col -= 3 * pitch ) |
256 | { |
257 | FT_UInt r, g, b; |
258 | FT_UInt p; |
259 | |
260 | |
261 | p = col[0]; |
262 | r = filters[0][0] * p; |
263 | g = filters[0][1] * p; |
264 | b = filters[0][2] * p; |
265 | |
266 | p = col[pitch]; |
267 | r += filters[1][0] * p; |
268 | g += filters[1][1] * p; |
269 | b += filters[1][2] * p; |
270 | |
271 | p = col[pitch * 2]; |
272 | r += filters[2][0] * p; |
273 | g += filters[2][1] * p; |
274 | b += filters[2][2] * p; |
275 | |
276 | col[0] = (FT_Byte)( r / 65536 ); |
277 | col[pitch] = (FT_Byte)( g / 65536 ); |
278 | col[pitch * 2] = (FT_Byte)( b / 65536 ); |
279 | } |
280 | } |
281 | } |
282 | } |
283 | |
284 | #endif /* USE_LEGACY */ |
285 | |
286 | |
287 | /* documentation in ftlcdfil.h */ |
288 | |
289 | FT_EXPORT_DEF( FT_Error ) |
290 | FT_Library_SetLcdFilterWeights( FT_Library library, |
291 | unsigned char *weights ) |
292 | { |
293 | if ( !library ) |
294 | return FT_THROW( Invalid_Library_Handle ); |
295 | |
296 | if ( !weights ) |
297 | return FT_THROW( Invalid_Argument ); |
298 | |
299 | ft_memcpy( library->lcd_weights, weights, FT_LCD_FILTER_FIVE_TAPS ); |
300 | library->lcd_filter_func = ft_lcd_filter_fir; |
301 | |
302 | return FT_Err_Ok; |
303 | } |
304 | |
305 | |
306 | /* documentation in ftlcdfil.h */ |
307 | |
308 | FT_EXPORT_DEF( FT_Error ) |
309 | FT_Library_SetLcdFilter( FT_Library library, |
310 | FT_LcdFilter filter ) |
311 | { |
312 | static const FT_LcdFiveTapFilter default_weights = |
313 | { 0x08, 0x4d, 0x56, 0x4d, 0x08 }; |
314 | static const FT_LcdFiveTapFilter light_weights = |
315 | { 0x00, 0x55, 0x56, 0x55, 0x00 }; |
316 | |
317 | |
318 | if ( !library ) |
319 | return FT_THROW( Invalid_Library_Handle ); |
320 | |
321 | switch ( filter ) |
322 | { |
323 | case FT_LCD_FILTER_NONE: |
324 | library->lcd_filter_func = NULL; |
325 | break; |
326 | |
327 | case FT_LCD_FILTER_DEFAULT: |
328 | ft_memcpy( library->lcd_weights, |
329 | default_weights, |
330 | FT_LCD_FILTER_FIVE_TAPS ); |
331 | library->lcd_filter_func = ft_lcd_filter_fir; |
332 | break; |
333 | |
334 | case FT_LCD_FILTER_LIGHT: |
335 | ft_memcpy( library->lcd_weights, |
336 | light_weights, |
337 | FT_LCD_FILTER_FIVE_TAPS ); |
338 | library->lcd_filter_func = ft_lcd_filter_fir; |
339 | break; |
340 | |
341 | #ifdef USE_LEGACY |
342 | |
343 | case FT_LCD_FILTER_LEGACY: |
344 | case FT_LCD_FILTER_LEGACY1: |
345 | library->lcd_filter_func = _ft_lcd_filter_legacy; |
346 | break; |
347 | |
348 | #endif |
349 | |
350 | default: |
351 | return FT_THROW( Invalid_Argument ); |
352 | } |
353 | |
354 | return FT_Err_Ok; |
355 | } |
356 | |
357 | |
358 | FT_EXPORT_DEF( FT_Error ) |
359 | FT_Library_SetLcdGeometry( FT_Library library, |
360 | FT_Vector sub[3] ) |
361 | { |
362 | FT_UNUSED( library ); |
363 | FT_UNUSED( sub ); |
364 | |
365 | return FT_THROW( Unimplemented_Feature ); |
366 | } |
367 | |
368 | #else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ |
369 | |
370 | /* add padding to accommodate outline shifts */ |
371 | FT_BASE_DEF( void ) |
372 | ft_lcd_padding( FT_BBox* cbox, |
373 | FT_GlyphSlot slot, |
374 | FT_Render_Mode mode ) |
375 | { |
376 | FT_Vector* sub = slot->library->lcd_geometry; |
377 | |
378 | if ( mode == FT_RENDER_MODE_LCD ) |
379 | { |
380 | cbox->xMin -= FT_MAX( FT_MAX( sub[0].x, sub[1].x ), sub[2].x ); |
381 | cbox->xMax -= FT_MIN( FT_MIN( sub[0].x, sub[1].x ), sub[2].x ); |
382 | cbox->yMin -= FT_MAX( FT_MAX( sub[0].y, sub[1].y ), sub[2].y ); |
383 | cbox->yMax -= FT_MIN( FT_MIN( sub[0].y, sub[1].y ), sub[2].y ); |
384 | } |
385 | else if ( mode == FT_RENDER_MODE_LCD_V ) |
386 | { |
387 | cbox->xMin -= FT_MAX( FT_MAX( sub[0].y, sub[1].y ), sub[2].y ); |
388 | cbox->xMax -= FT_MIN( FT_MIN( sub[0].y, sub[1].y ), sub[2].y ); |
389 | cbox->yMin += FT_MIN( FT_MIN( sub[0].x, sub[1].x ), sub[2].x ); |
390 | cbox->yMax += FT_MAX( FT_MAX( sub[0].x, sub[1].x ), sub[2].x ); |
391 | } |
392 | } |
393 | |
394 | |
395 | FT_EXPORT_DEF( FT_Error ) |
396 | FT_Library_SetLcdFilterWeights( FT_Library library, |
397 | unsigned char *weights ) |
398 | { |
399 | FT_UNUSED( library ); |
400 | FT_UNUSED( weights ); |
401 | |
402 | return FT_THROW( Unimplemented_Feature ); |
403 | } |
404 | |
405 | |
406 | FT_EXPORT_DEF( FT_Error ) |
407 | FT_Library_SetLcdFilter( FT_Library library, |
408 | FT_LcdFilter filter ) |
409 | { |
410 | FT_UNUSED( library ); |
411 | FT_UNUSED( filter ); |
412 | |
413 | return FT_THROW( Unimplemented_Feature ); |
414 | } |
415 | |
416 | |
417 | /* documentation in ftlcdfil.h */ |
418 | |
419 | FT_EXPORT_DEF( FT_Error ) |
420 | FT_Library_SetLcdGeometry( FT_Library library, |
421 | FT_Vector sub[3] ) |
422 | { |
423 | if ( !library ) |
424 | return FT_THROW( Invalid_Library_Handle ); |
425 | |
426 | if ( !sub ) |
427 | return FT_THROW( Invalid_Argument ); |
428 | |
429 | ft_memcpy( library->lcd_geometry, sub, 3 * sizeof( FT_Vector ) ); |
430 | |
431 | return FT_Err_Ok; |
432 | } |
433 | |
434 | #endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ |
435 | |
436 | |
437 | /* END */ |
438 | |