| File: | pixman/pixman-glyph.c |
| Location: | line 489, column 3 |
| Description: | Called function pointer is null (null dereference) |
| 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 | ||||
| 34 | typedef struct glyph_metrics_t glyph_metrics_t; | |||
| 35 | typedef 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 | ||||
| 46 | struct 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 | ||||
| 56 | struct 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 | ||||
| 65 | static void | |||
| 66 | free_glyph (glyph_t *glyph) | |||
| 67 | { | |||
| 68 | pixman_list_unlink (&glyph->mru_link); | |||
| 69 | pixman_image_unref (glyph->image); | |||
| 70 | free (glyph); | |||
| 71 | } | |||
| 72 | ||||
| 73 | static unsigned int | |||
| 74 | hash (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 | ||||
| 94 | static glyph_t * | |||
| 95 | lookup_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 | ||||
| 116 | static void | |||
| 117 | insert_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 | ||||
| 140 | static void | |||
| 141 | remove_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 | ||||
| 166 | static void | |||
| 167 | clear_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 | ||||
| 185 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) pixman_glyph_cache_t * | |||
| 186 | pixman_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))__builtin___memset_chk (cache->glyphs, 0, sizeof (cache-> glyphs), __builtin_object_size (cache->glyphs, 0)); | |||
| 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 | ||||
| 203 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 204 | pixman_glyph_cache_destroy (pixman_glyph_cache_t *cache) | |||
| 205 | { | |||
| 206 | return_if_fail (cache->freeze_count == 0)do { if (__builtin_expect ((!(cache->freeze_count == 0)), 0 )) { _pixman_log_error (((const char*) (__PRETTY_FUNCTION__)) , "The expression " "cache->freeze_count == 0" " was false" ); return; } } while (0); | |||
| 207 | ||||
| 208 | clear_table (cache); | |||
| 209 | ||||
| 210 | free (cache); | |||
| 211 | } | |||
| 212 | ||||
| 213 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 214 | pixman_glyph_cache_freeze (pixman_glyph_cache_t *cache) | |||
| 215 | { | |||
| 216 | cache->freeze_count++; | |||
| 217 | } | |||
| 218 | ||||
| 219 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 220 | pixman_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 | ||||
| 243 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) const void * | |||
| 244 | pixman_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 | ||||
| 251 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) const void * | |||
| 252 | pixman_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 (__builtin_expect ((!(cache->freeze_count > 0)) , 0)) { _pixman_log_error (((const char*) (__PRETTY_FUNCTION__ )), "The expression " "cache->freeze_count > 0" " was false" ); return (((void*)0)); } } while (0); | |||
| 263 | return_val_if_fail (image->type == BITS, NULL)do { if (__builtin_expect ((!(image->type == BITS)), 0)) { _pixman_log_error (((const char*) (__PRETTY_FUNCTION__)), "The expression " "image->type == BITS" " was false"); 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 | ||||
| 304 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 305 | pixman_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 | ||||
| 319 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 320 | pixman_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_MAX2147483647; | |||
| 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 | */ | |||
| 354 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) pixman_format_code_t | |||
| 355 | pixman_glyph_get_mask_format (pixman_glyph_cache_t *cache, | |||
| 356 | int n_glyphs, | |||
| 357 | const 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 | ||||
| 381 | static pixman_bool_t | |||
| 382 | box32_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 | ||||
| 394 | #if defined(__GNUC__4) && !defined(__x86_64__1) && !defined(__amd64__1) | |||
| 395 | __attribute__((__force_align_arg_pointer__)) | |||
| 396 | #endif | |||
| 397 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 398 | pixman_composite_glyphs_no_mask (pixman_op_t op, | |||
| 399 | pixman_image_t *src, | |||
| 400 | pixman_image_t *dest, | |||
| 401 | int32_t src_x, | |||
| 402 | int32_t src_y, | |||
| 403 | int32_t dest_x, | |||
| 404 | int32_t dest_y, | |||
| 405 | pixman_glyph_cache_t *cache, | |||
| 406 | int n_glyphs, | |||
| 407 | const pixman_glyph_t *glyphs) | |||
| 408 | { | |||
| 409 | pixman_region32_t region; | |||
| 410 | pixman_format_code_t glyph_format = PIXMAN_null(((0) << 24) | ((0) << 16) | ((0) << 12) | ( (0) << 8) | ((0) << 4) | ((0))); | |||
| 411 | uint32_t glyph_flags = 0; | |||
| 412 | pixman_format_code_t dest_format; | |||
| 413 | uint32_t dest_flags; | |||
| 414 | pixman_composite_func_t func = NULL((void*)0); | |||
| ||||
| 415 | pixman_implementation_t *implementation = NULL((void*)0); | |||
| 416 | pixman_composite_info_t info; | |||
| 417 | int i; | |||
| 418 | ||||
| 419 | _pixman_image_validate (src); | |||
| 420 | _pixman_image_validate (dest); | |||
| 421 | ||||
| 422 | dest_format = dest->common.extended_format_code; | |||
| 423 | dest_flags = dest->common.flags; | |||
| 424 | ||||
| 425 | pixman_region32_init (®ion); | |||
| 426 | if (!_pixman_compute_composite_region32 ( | |||
| 427 | ®ion, | |||
| 428 | src, NULL((void*)0), dest, | |||
| 429 | src_x - dest_x, src_y - dest_y, 0, 0, 0, 0, | |||
| 430 | dest->bits.width, dest->bits.height)) | |||
| 431 | { | |||
| 432 | goto out; | |||
| 433 | } | |||
| 434 | ||||
| 435 | info.op = op; | |||
| 436 | info.src_image = src; | |||
| 437 | info.dest_image = dest; | |||
| 438 | info.src_flags = src->common.flags; | |||
| 439 | info.dest_flags = dest->common.flags; | |||
| 440 | ||||
| 441 | for (i = 0; i < n_glyphs; ++i) | |||
| 442 | { | |||
| 443 | glyph_t *glyph = (glyph_t *)glyphs[i].glyph; | |||
| 444 | pixman_image_t *glyph_img = glyph->image; | |||
| 445 | pixman_box32_t glyph_box; | |||
| 446 | pixman_box32_t *pbox; | |||
| 447 | uint32_t extra = FAST_PATH_SAMPLES_COVER_CLIP_NEAREST(1 << 23); | |||
| 448 | pixman_box32_t composite_box; | |||
| 449 | int n; | |||
| 450 | ||||
| 451 | glyph_box.x1 = dest_x + glyphs[i].x - glyph->origin_x; | |||
| 452 | glyph_box.y1 = dest_y + glyphs[i].y - glyph->origin_y; | |||
| 453 | glyph_box.x2 = glyph_box.x1 + glyph->image->bits.width; | |||
| 454 | glyph_box.y2 = glyph_box.y1 + glyph->image->bits.height; | |||
| 455 | ||||
| 456 | pbox = pixman_region32_rectangles (®ion, &n); | |||
| 457 | ||||
| 458 | info.mask_image = glyph_img; | |||
| 459 | ||||
| 460 | while (n--) | |||
| 461 | { | |||
| 462 | if (box32_intersect (&composite_box, pbox, &glyph_box)) | |||
| 463 | { | |||
| 464 | if (glyph_img->common.extended_format_code != glyph_format || | |||
| 465 | glyph_img->common.flags != glyph_flags) | |||
| 466 | { | |||
| 467 | glyph_format = glyph_img->common.extended_format_code; | |||
| 468 | glyph_flags = glyph_img->common.flags; | |||
| 469 | ||||
| 470 | _pixman_implementation_lookup_composite ( | |||
| 471 | get_implementation(), op, | |||
| 472 | src->common.extended_format_code, src->common.flags, | |||
| 473 | glyph_format, glyph_flags | extra, | |||
| 474 | dest_format, dest_flags, | |||
| 475 | &implementation, &func); | |||
| 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); | |||
| ||||
| 490 | } | |||
| 491 | ||||
| 492 | pbox++; | |||
| 493 | } | |||
| 494 | pixman_list_move_to_front (&cache->mru, &glyph->mru_link); | |||
| 495 | } | |||
| 496 | ||||
| 497 | out: | |||
| 498 | pixman_region32_fini (®ion); | |||
| 499 | } | |||
| 500 | ||||
| 501 | static void | |||
| 502 | add_glyphs (pixman_glyph_cache_t *cache, | |||
| 503 | pixman_image_t *dest, | |||
| 504 | int off_x, int off_y, | |||
| 505 | int n_glyphs, const 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 | pixman_format_code_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 | static const 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_implementation_lookup_composite ( | |||
| 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 | ||||
| 587 | glyph_box.x1 = glyphs[i].x - glyph->origin_x + off_x; | |||
| 588 | glyph_box.y1 = glyphs[i].y - glyph->origin_y + off_y; | |||
| 589 | glyph_box.x2 = glyph_box.x1 + glyph->image->bits.width; | |||
| 590 | glyph_box.y2 = glyph_box.y1 + glyph->image->bits.height; | |||
| 591 | ||||
| 592 | if (box32_intersect (&composite_box, &glyph_box, &dest_box)) | |||
| 593 | { | |||
| 594 | int src_x = composite_box.x1 - glyph_box.x1; | |||
| 595 | int src_y = composite_box.y1 - glyph_box.y1; | |||
| 596 | ||||
| 597 | if (white_src) | |||
| 598 | info.mask_image = glyph_img; | |||
| 599 | else | |||
| 600 | info.src_image = glyph_img; | |||
| 601 | ||||
| 602 | info.mask_x = info.src_x = src_x; | |||
| 603 | info.mask_y = info.src_y = src_y; | |||
| 604 | info.dest_x = composite_box.x1; | |||
| 605 | info.dest_y = composite_box.y1; | |||
| 606 | info.width = composite_box.x2 - composite_box.x1; | |||
| 607 | info.height = composite_box.y2 - composite_box.y1; | |||
| 608 | ||||
| 609 | func (implementation, &info); | |||
| 610 | ||||
| 611 | pixman_list_move_to_front (&cache->mru, &glyph->mru_link); | |||
| 612 | } | |||
| 613 | } | |||
| 614 | ||||
| 615 | out: | |||
| 616 | if (white_img) | |||
| 617 | pixman_image_unref (white_img); | |||
| 618 | } | |||
| 619 | ||||
| 620 | /* Conceptually, for each glyph, (white IN glyph) is PIXMAN_OP_ADDed to an | |||
| 621 | * infinitely big mask image at the position such that the glyph origin point | |||
| 622 | * is positioned at the (glyphs[i].x, glyphs[i].y) point. | |||
| 623 | * | |||
| 624 | * Then (mask_x, mask_y) in the infinite mask and (src_x, src_y) in the source | |||
| 625 | * image are both aligned with (dest_x, dest_y) in the destination image. Then | |||
| 626 | * these three images are composited within the | |||
| 627 | * | |||
| 628 | * (dest_x, dest_y, dst_x + width, dst_y + height) | |||
| 629 | * | |||
| 630 | * rectangle. | |||
| 631 | * | |||
| 632 | * TODO: | |||
| 633 | * - Trim the mask to the destination clip/image? | |||
| 634 | * - Trim composite region based on sources, when the op ignores 0s. | |||
| 635 | */ | |||
| 636 | #if defined(__GNUC__4) && !defined(__x86_64__1) && !defined(__amd64__1) | |||
| 637 | __attribute__((__force_align_arg_pointer__)) | |||
| 638 | #endif | |||
| 639 | PIXMAN_EXPORT__attribute__ ((visibility("default"))) void | |||
| 640 | pixman_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 | const 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 | } |