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