Bug Summary

File:pixman/pixman-glyph.c
Location:line 489, column 3
Description:Called function pointer is null (null dereference)

Annotated Source Code

1/*
2 * Copyright 2010, 2012, Soren Sandmann <sandmann@cs.au.dk>
3 * Copyright 2010, 2011, 2012, Red Hat, Inc
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Author: Soren Sandmann <sandmann@cs.au.dk>
25 */
26
27#ifdef HAVE_CONFIG_H1
28#include <config.h>
29#endif
30#include "pixman-private.h"
31
32#include <stdlib.h>
33
34typedef struct glyph_metrics_t glyph_metrics_t;
35typedef struct glyph_t glyph_t;
36
37#define TOMBSTONE((glyph_t *)0x1) ((glyph_t *)0x1)
38
39/* XXX: These numbers are arbitrary---we've never done any measurements.
40 */
41#define N_GLYPHS_HIGH_WATER(16384) (16384)
42#define N_GLYPHS_LOW_WATER(8192) (8192)
43#define HASH_SIZE(2 * (16384)) (2 * N_GLYPHS_HIGH_WATER(16384))
44#define HASH_MASK((2 * (16384)) - 1) (HASH_SIZE(2 * (16384)) - 1)
45
46struct glyph_t
47{
48 void * font_key;
49 void * glyph_key;
50 int origin_x;
51 int origin_y;
52 pixman_image_t * image;
53 pixman_link_t mru_link;
54};
55
56struct pixman_glyph_cache_t
57{
58 int n_glyphs;
59 int n_tombstones;
60 int freeze_count;
61 pixman_list_t mru;
62 glyph_t * glyphs[HASH_SIZE(2 * (16384))];
63};
64
65static void
66free_glyph (glyph_t *glyph)
67{
68 pixman_list_unlink (&glyph->mru_link);
69 pixman_image_unref (glyph->image);
70 free (glyph);
71}
72
73static unsigned int
74hash (const void *font_key, const void *glyph_key)
75{
76 size_t key = (size_t)font_key + (size_t)glyph_key;
77
78 /* This hash function is based on one found on Thomas Wang's
79 * web page at
80 *
81 * http://www.concentric.net/~Ttwang/tech/inthash.htm
82 *
83 */
84 key = (key << 15) - key - 1;
85 key = key ^ (key >> 12);
86 key = key + (key << 2);
87 key = key ^ (key >> 4);
88 key = key + (key << 3) + (key << 11);
89 key = key ^ (key >> 16);
90
91 return key;
92}
93
94static glyph_t *
95lookup_glyph (pixman_glyph_cache_t *cache,
96 void *font_key,
97 void *glyph_key)
98{
99 unsigned idx;
100 glyph_t *g;
101
102 idx = hash (font_key, glyph_key);
103 while ((g = cache->glyphs[idx++ & HASH_MASK((2 * (16384)) - 1)]))
104 {
105 if (g != TOMBSTONE((glyph_t *)0x1) &&
106 g->font_key == font_key &&
107 g->glyph_key == glyph_key)
108 {
109 return g;
110 }
111 }
112
113 return NULL((void*)0);
114}
115
116static void
117insert_glyph (pixman_glyph_cache_t *cache,
118 glyph_t *glyph)
119{
120 unsigned idx;
121 glyph_t **loc;
122
123 idx = hash (glyph->font_key, glyph->glyph_key);
124
125 /* Note: we assume that there is room in the table. If there isn't,
126 * this will be an infinite loop.
127 */
128 do
129 {
130 loc = &cache->glyphs[idx++ & HASH_MASK((2 * (16384)) - 1)];
131 } while (*loc && *loc != TOMBSTONE((glyph_t *)0x1));
132
133 if (*loc == TOMBSTONE((glyph_t *)0x1))
134 cache->n_tombstones--;
135 cache->n_glyphs++;
136
137 *loc = glyph;
138}
139
140static void
141remove_glyph (pixman_glyph_cache_t *cache,
142 glyph_t *glyph)
143{
144 unsigned idx;
145
146 idx = hash (glyph->font_key, glyph->glyph_key);
147 while (cache->glyphs[idx & HASH_MASK((2 * (16384)) - 1)] != glyph)
148 idx++;
149
150 cache->glyphs[idx & HASH_MASK((2 * (16384)) - 1)] = TOMBSTONE((glyph_t *)0x1);
151 cache->n_tombstones++;
152 cache->n_glyphs--;
153
154 /* Eliminate tombstones if possible */
155 if (cache->glyphs[(idx + 1) & HASH_MASK((2 * (16384)) - 1)] == NULL((void*)0))
156 {
157 while (cache->glyphs[idx & HASH_MASK((2 * (16384)) - 1)] == TOMBSTONE((glyph_t *)0x1))
158 {
159 cache->glyphs[idx & HASH_MASK((2 * (16384)) - 1)] = NULL((void*)0);
160 cache->n_tombstones--;
161 idx--;
162 }
163 }
164}
165
166static void
167clear_table (pixman_glyph_cache_t *cache)
168{
169 int i;
170
171 for (i = 0; i < HASH_SIZE(2 * (16384)); ++i)
172 {
173 glyph_t *glyph = cache->glyphs[i];
174
175 if (glyph && glyph != TOMBSTONE((glyph_t *)0x1))
176 free_glyph (glyph);
177
178 cache->glyphs[i] = NULL((void*)0);
179 }
180
181 cache->n_glyphs = 0;
182 cache->n_tombstones = 0;
183}
184
185PIXMAN_EXPORT__attribute__ ((visibility("default"))) pixman_glyph_cache_t *
186pixman_glyph_cache_create (void)
187{
188 pixman_glyph_cache_t *cache;
189
190 if (!(cache = malloc (sizeof *cache)))
191 return NULL((void*)0);
192
193 memset (cache->glyphs, 0, sizeof (cache->glyphs));
194 cache->n_glyphs = 0;
195 cache->n_tombstones = 0;
196 cache->freeze_count = 0;
197
198 pixman_list_init (&cache->mru);
199
200 return cache;
201}
202
203PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
204pixman_glyph_cache_destroy (pixman_glyph_cache_t *cache)
205{
206 return_if_fail (cache->freeze_count == 0)do { if (!(cache->freeze_count == 0)) return; } while (0);
207
208 clear_table (cache);
209
210 free (cache);
211}
212
213PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
214pixman_glyph_cache_freeze (pixman_glyph_cache_t *cache)
215{
216 cache->freeze_count++;
217}
218
219PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
220pixman_glyph_cache_thaw (pixman_glyph_cache_t *cache)
221{
222 if (--cache->freeze_count == 0 &&
223 cache->n_glyphs + cache->n_tombstones > N_GLYPHS_HIGH_WATER(16384))
224 {
225 if (cache->n_tombstones > N_GLYPHS_HIGH_WATER(16384))
226 {
227 /* More than half the entries are
228 * tombstones. Just dump the whole table.
229 */
230 clear_table (cache);
231 }
232
233 while (cache->n_glyphs > N_GLYPHS_LOW_WATER(8192))
234 {
235 glyph_t *glyph = CONTAINER_OF (glyph_t, mru_link, cache->mru.tail)((glyph_t *)(((uint8_t *)cache->mru.tail) - __builtin_offsetof
(glyph_t, mru_link)));
236
237 remove_glyph (cache, glyph);
238 free_glyph (glyph);
239 }
240 }
241}
242
243PIXMAN_EXPORT__attribute__ ((visibility("default"))) const void *
244pixman_glyph_cache_lookup (pixman_glyph_cache_t *cache,
245 void *font_key,
246 void *glyph_key)
247{
248 return lookup_glyph (cache, font_key, glyph_key);
249}
250
251PIXMAN_EXPORT__attribute__ ((visibility("default"))) const void *
252pixman_glyph_cache_insert (pixman_glyph_cache_t *cache,
253 void *font_key,
254 void *glyph_key,
255 int origin_x,
256 int origin_y,
257 pixman_image_t *image)
258{
259 glyph_t *glyph;
260 int32_t width, height;
261
262 return_val_if_fail (cache->freeze_count > 0, NULL)do { if (!(cache->freeze_count > 0)) return (((void*)0)
); } while (0);
263 return_val_if_fail (image->type == BITS, NULL)do { if (!(image->type == BITS)) return (((void*)0)); } while
(0);
264
265 width = image->bits.width;
266 height = image->bits.height;
267
268 if (cache->n_glyphs >= HASH_SIZE(2 * (16384)))
269 return NULL((void*)0);
270
271 if (!(glyph = malloc (sizeof *glyph)))
272 return NULL((void*)0);
273
274 glyph->font_key = font_key;
275 glyph->glyph_key = glyph_key;
276 glyph->origin_x = origin_x;
277 glyph->origin_y = origin_y;
278
279 if (!(glyph->image = pixman_image_create_bits (
280 image->bits.format, width, height, NULL((void*)0), -1)))
281 {
282 free (glyph);
283 return NULL((void*)0);
284 }
285
286 pixman_image_composite32 (PIXMAN_OP_SRC,
287 image, NULL((void*)0), glyph->image, 0, 0, 0, 0, 0, 0,
288 width, height);
289
290 if (PIXMAN_FORMAT_A (glyph->image->bits.format)(((glyph->image->bits.format) >> 12) & 0x0f) != 0 &&
291 PIXMAN_FORMAT_RGB (glyph->image->bits.format)(((glyph->image->bits.format) ) & 0xfff) != 0)
292 {
293 pixman_image_set_component_alpha (glyph->image, TRUE1);
294 }
295
296 pixman_list_prepend (&cache->mru, &glyph->mru_link);
297
298 _pixman_image_validate (glyph->image);
299 insert_glyph (cache, glyph);
300
301 return glyph;
302}
303
304PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
305pixman_glyph_cache_remove (pixman_glyph_cache_t *cache,
306 void *font_key,
307 void *glyph_key)
308{
309 glyph_t *glyph;
310
311 if ((glyph = lookup_glyph (cache, font_key, glyph_key)))
312 {
313 remove_glyph (cache, glyph);
314
315 free_glyph (glyph);
316 }
317}
318
319PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
320pixman_glyph_get_extents (pixman_glyph_cache_t *cache,
321 int n_glyphs,
322 pixman_glyph_t *glyphs,
323 pixman_box32_t *extents)
324{
325 int i;
326
327 extents->x1 = extents->y1 = INT32_MAX(2147483647);
328 extents->x2 = extents->y2 = INT32_MIN(-2147483647 -1);
329
330 for (i = 0; i < n_glyphs; ++i)
331 {
332 glyph_t *glyph = (glyph_t *)glyphs[i].glyph;
333 int x1, y1, x2, y2;
334
335 x1 = glyphs[i].x - glyph->origin_x;
336 y1 = glyphs[i].y - glyph->origin_y;
337 x2 = glyphs[i].x - glyph->origin_x + glyph->image->bits.width;
338 y2 = glyphs[i].y - glyph->origin_y + glyph->image->bits.height;
339
340 if (x1 < extents->x1)
341 extents->x1 = x1;
342 if (y1 < extents->y1)
343 extents->y1 = y1;
344 if (x2 > extents->x2)
345 extents->x2 = x2;
346 if (y2 > extents->y2)
347 extents->y2 = y2;
348 }
349}
350
351/* This function returns a format that is suitable for use as a mask for the
352 * set of glyphs in question.
353 */
354PIXMAN_EXPORT__attribute__ ((visibility("default"))) pixman_format_code_t
355pixman_glyph_get_mask_format (pixman_glyph_cache_t *cache,
356 int n_glyphs,
357 pixman_glyph_t * glyphs)
358{
359 pixman_format_code_t format = PIXMAN_a1;
360 int i;
361
362 for (i = 0; i < n_glyphs; ++i)
363 {
364 const glyph_t *glyph = glyphs[i].glyph;
365 pixman_format_code_t glyph_format = glyph->image->bits.format;
366
367 if (PIXMAN_FORMAT_TYPE (glyph_format)(((glyph_format) >> 16) & 0xff) == PIXMAN_TYPE_A1)
368 {
369 if (PIXMAN_FORMAT_A (glyph_format)(((glyph_format) >> 12) & 0x0f) > PIXMAN_FORMAT_A (format)(((format) >> 12) & 0x0f))
370 format = glyph_format;
371 }
372 else
373 {
374 return PIXMAN_a8r8g8b8;
375 }
376 }
377
378 return format;
379}
380
381static pixman_bool_t
382box32_intersect (pixman_box32_t *dest,
383 const pixman_box32_t *box1,
384 const pixman_box32_t *box2)
385{
386 dest->x1 = MAX (box1->x1, box2->x1)((box1->x1 > box2->x1) ? box1->x1 : box2->x1);
387 dest->y1 = MAX (box1->y1, box2->y1)((box1->y1 > box2->y1) ? box1->y1 : box2->y1);
388 dest->x2 = MIN (box1->x2, box2->x2)((box1->x2 < box2->x2) ? box1->x2 : box2->x2);
389 dest->y2 = MIN (box1->y2, box2->y2)((box1->y2 < box2->y2) ? box1->y2 : box2->y2);
390
391 return dest->x2 > dest->x1 && dest->y2 > dest->y1;
392}
393
394PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
395pixman_composite_glyphs_no_mask (pixman_op_t op,
396 pixman_image_t *src,
397 pixman_image_t *dest,
398 int32_t src_x,
399 int32_t src_y,
400 int32_t dest_x,
401 int32_t dest_y,
402 pixman_glyph_cache_t *cache,
403 int n_glyphs,
404 pixman_glyph_t *glyphs)
405{
406 pixman_region32_t region;
407 pixman_format_code_t glyph_format = PIXMAN_null(((0) << 24) | ((0) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)));
408 uint32_t glyph_flags = 0;
409 pixman_format_code_t dest_format;
410 uint32_t dest_flags;
411 pixman_composite_func_t func = NULL((void*)0);
412 pixman_implementation_t *implementation = NULL((void*)0);
413 pixman_composite_info_t info;
414 int i;
415
416 _pixman_image_validate (src);
417 _pixman_image_validate (dest);
418
419 dest_format = dest->common.extended_format_code;
420 dest_flags = dest->common.flags;
421
422 pixman_region32_init (&region);
423 if (!_pixman_compute_composite_region32 (
1
Taking false branch
424 &region,
425 src, NULL((void*)0), dest,
426 src_x - dest_x, src_y - dest_y, 0, 0, 0, 0,
427 dest->bits.width, dest->bits.height))
428 {
429 goto out;
430 }
431
432 info.op = op;
433 info.src_image = src;
434 info.dest_image = dest;
435 info.src_flags = src->common.flags;
436 info.dest_flags = dest->common.flags;
437
438 for (i = 0; i < n_glyphs; ++i)
2
Assuming 'i' is < 'n_glyphs'
3
Loop condition is true. Entering loop body
439 {
440 glyph_t *glyph = (glyph_t *)glyphs[i].glyph;
441 pixman_image_t *glyph_img = glyph->image;
442 pixman_box32_t glyph_box;
443 pixman_box32_t *pbox;
444 uint32_t extra = FAST_PATH_SAMPLES_COVER_CLIP_NEAREST(1 << 23);
445 pixman_box32_t composite_box;
446 int n;
447
448 glyph_box.x1 = dest_x + glyphs[i].x - glyph->origin_x;
449 glyph_box.y1 = dest_y + glyphs[i].y - glyph->origin_y;
450 glyph_box.x2 = glyph_box.x1 + glyph->image->bits.width;
451 glyph_box.y2 = glyph_box.y1 + glyph->image->bits.height;
452
453 pbox = pixman_region32_rectangles (&region, &n);
454
455 info.mask_image = glyph_img;
456
457 while (n--)
4
Loop condition is true. Entering loop body
458 {
459 if (box32_intersect (&composite_box, pbox, &glyph_box))
5
Taking true branch
460 {
461 if (glyph_img->common.extended_format_code != glyph_format ||
6
Taking false branch
462 glyph_img->common.flags != glyph_flags)
463 {
464 glyph_format = glyph_img->common.extended_format_code;
465 glyph_flags = glyph_img->common.flags;
466
467 _pixman_lookup_composite_function (
468 get_implementation(), op,
469 src->common.extended_format_code, src->common.flags,
470 glyph_format, glyph_flags | extra,
471 dest_format, dest_flags,
472 &implementation, &func);
473
474 if (!func)
475 goto out;
476 }
477
478 info.src_x = src_x + composite_box.x1 - dest_x;
479 info.src_y = src_y + composite_box.y1 - dest_y;
480 info.mask_x = composite_box.x1 - (dest_x + glyphs[i].x - glyph->origin_x);
481 info.mask_y = composite_box.y1 - (dest_y + glyphs[i].y - glyph->origin_y);
482 info.dest_x = composite_box.x1;
483 info.dest_y = composite_box.y1;
484 info.width = composite_box.x2 - composite_box.x1;
485 info.height = composite_box.y2 - composite_box.y1;
486
487 info.mask_flags = glyph_flags;
488
489 func (implementation, &info);
7
Called function pointer is null (null dereference)
490 }
491
492 pbox++;
493 }
494 pixman_list_move_to_front (&cache->mru, &glyph->mru_link);
495 }
496
497out:
498 pixman_region32_fini (&region);
499}
500
501static void
502add_glyphs (pixman_glyph_cache_t *cache,
503 pixman_image_t *dest,
504 int off_x, int off_y,
505 int n_glyphs, pixman_glyph_t *glyphs)
506{
507 pixman_format_code_t glyph_format = PIXMAN_null(((0) << 24) | ((0) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)));
508 uint32_t glyph_flags = 0;
509 pixman_composite_func_t func = NULL((void*)0);
510 pixman_implementation_t *implementation = NULL((void*)0);
511 uint32_t dest_format;
512 uint32_t dest_flags;
513 pixman_box32_t dest_box;
514 pixman_composite_info_t info;
515 pixman_image_t *white_img = NULL((void*)0);
516 pixman_bool_t white_src = FALSE0;
517 int i;
518
519 _pixman_image_validate (dest);
520
521 dest_format = dest->common.extended_format_code;
522 dest_flags = dest->common.flags;
523
524 info.op = PIXMAN_OP_ADD;
525 info.dest_image = dest;
526 info.src_x = 0;
527 info.src_y = 0;
528 info.dest_flags = dest_flags;
529
530 dest_box.x1 = 0;
531 dest_box.y1 = 0;
532 dest_box.x2 = dest->bits.width;
533 dest_box.y2 = dest->bits.height;
534
535 for (i = 0; i < n_glyphs; ++i)
536 {
537 glyph_t *glyph = (glyph_t *)glyphs[i].glyph;
538 pixman_image_t *glyph_img = glyph->image;
539 pixman_box32_t glyph_box;
540 pixman_box32_t composite_box;
541
542 if (glyph_img->common.extended_format_code != glyph_format ||
543 glyph_img->common.flags != glyph_flags)
544 {
545 pixman_format_code_t src_format, mask_format;
546
547 glyph_format = glyph_img->common.extended_format_code;
548 glyph_flags = glyph_img->common.flags;
549
550 if (glyph_format == dest->bits.format)
551 {
552 src_format = glyph_format;
553 mask_format = PIXMAN_null(((0) << 24) | ((0) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)));
554 info.src_flags = glyph_flags | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST(1 << 23);
555 info.mask_flags = FAST_PATH_IS_OPAQUE(1 << 13);
556 info.mask_image = NULL((void*)0);
557 white_src = FALSE0;
558 }
559 else
560 {
561 if (!white_img)
562 {
563 pixman_color_t white = { 0xffff, 0xffff, 0xffff, 0xffff };
564
565 if (!(white_img = pixman_image_create_solid_fill (&white)))
566 goto out;
567
568 _pixman_image_validate (white_img);
569 }
570
571 src_format = PIXMAN_solid(((0) << 24) | ((1) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)));
572 mask_format = glyph_format;
573 info.src_flags = white_img->common.flags;
574 info.mask_flags = glyph_flags | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST(1 << 23);
575 info.src_image = white_img;
576 white_src = TRUE1;
577 }
578
579 _pixman_lookup_composite_function (
580 get_implementation(), PIXMAN_OP_ADD,
581 src_format, info.src_flags,
582 mask_format, info.mask_flags,
583 dest_format, dest_flags,
584 &implementation, &func);
585
586 if (!func)
587 goto out;
588 }
589
590 glyph_box.x1 = glyphs[i].x - glyph->origin_x + off_x;
591 glyph_box.y1 = glyphs[i].y - glyph->origin_y + off_y;
592 glyph_box.x2 = glyph_box.x1 + glyph->image->bits.width;
593 glyph_box.y2 = glyph_box.y1 + glyph->image->bits.height;
594
595 if (box32_intersect (&composite_box, &glyph_box, &dest_box))
596 {
597 int src_x = composite_box.x1 - glyph_box.x1;
598 int src_y = composite_box.y1 - glyph_box.y1;
599
600 if (white_src)
601 info.mask_image = glyph_img;
602 else
603 info.src_image = glyph_img;
604
605 info.mask_x = info.src_x = src_x;
606 info.mask_y = info.src_y = src_y;
607 info.dest_x = composite_box.x1;
608 info.dest_y = composite_box.y1;
609 info.width = composite_box.x2 - composite_box.x1;
610 info.height = composite_box.y2 - composite_box.y1;
611
612 func (implementation, &info);
613
614 pixman_list_move_to_front (&cache->mru, &glyph->mru_link);
615 }
616 }
617
618out:
619 if (white_img)
620 pixman_image_unref (white_img);
621}
622
623/* Conceptually, for each glyph, (white IN glyph) is PIXMAN_OP_ADDed to an
624 * infinitely big mask image at the position such that the glyph origin point
625 * is positioned at the (glyphs[i].x, glyphs[i].y) point.
626 *
627 * Then (mask_x, mask_y) in the infinite mask and (src_x, src_y) in the source
628 * image are both aligned with (dest_x, dest_y) in the destination image. Then
629 * these three images are composited within the
630 *
631 * (dest_x, dest_y, dst_x + width, dst_y + height)
632 *
633 * rectangle.
634 *
635 * TODO:
636 * - Trim the mask to the destination clip/image?
637 * - Trim composite region based on sources, when the op ignores 0s.
638 */
639PIXMAN_EXPORT__attribute__ ((visibility("default"))) void
640pixman_composite_glyphs (pixman_op_t op,
641 pixman_image_t *src,
642 pixman_image_t *dest,
643 pixman_format_code_t mask_format,
644 int32_t src_x,
645 int32_t src_y,
646 int32_t mask_x,
647 int32_t mask_y,
648 int32_t dest_x,
649 int32_t dest_y,
650 int32_t width,
651 int32_t height,
652 pixman_glyph_cache_t *cache,
653 int n_glyphs,
654 pixman_glyph_t *glyphs)
655{
656 pixman_image_t *mask;
657
658 if (!(mask = pixman_image_create_bits (mask_format, width, height, NULL((void*)0), -1)))
659 return;
660
661 if (PIXMAN_FORMAT_A (mask_format)(((mask_format) >> 12) & 0x0f) != 0 &&
662 PIXMAN_FORMAT_RGB (mask_format)(((mask_format) ) & 0xfff) != 0)
663 {
664 pixman_image_set_component_alpha (mask, TRUE1);
665 }
666
667 add_glyphs (cache, mask, - mask_x, - mask_y, n_glyphs, glyphs);
668
669 pixman_image_composite32 (op, src, mask, dest,
670 src_x, src_y,
671 0, 0,
672 dest_x, dest_y,
673 width, height);
674
675 pixman_image_unref (mask);
676}