Rev 1891 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 1891 | Rev 3931 | ||
---|---|---|---|
Line 28... | Line 28... | ||
28 | #endif |
28 | #endif |
29 | #include "pixman-private.h" |
29 | #include "pixman-private.h" |
Line 30... | Line 30... | ||
30 | 30 | ||
Line 31... | Line -... | ||
31 | #include |
- | |
32 | - | ||
33 | static force_inline pixman_implementation_t * |
- | |
34 | get_implementation (void) |
31 | #include |
Line -... | Line 32... | ||
- | 32 | ||
35 | { |
33 | pixman_implementation_t *global_implementation; |
- | 34 | ||
- | 35 | #ifdef TOOLCHAIN_SUPPORTS_ATTRIBUTE_CONSTRUCTOR |
|
36 | static pixman_implementation_t *global_implementation; |
36 | static void __attribute__((constructor)) |
37 | - | ||
38 | if (!global_implementation) |
- | |
39 | global_implementation = _pixman_choose_implementation (); |
37 | pixman_constructor (void) |
- | 38 | { |
|
Line 40... | Line 39... | ||
40 | 39 | global_implementation = _pixman_choose_implementation (); |
|
Line 41... | Line 40... | ||
41 | return global_implementation; |
40 | } |
42 | } |
41 | #endif |
Line 151... | Line 150... | ||
151 | is_source_opaque >>= OPAQUE_SHIFT; |
150 | is_source_opaque >>= OPAQUE_SHIFT; |
Line 152... | Line 151... | ||
152 | 151 | ||
153 | return operator_table[op].opaque_info[is_dest_opaque | is_source_opaque]; |
152 | return operator_table[op].opaque_info[is_dest_opaque | is_source_opaque]; |
Line 154... | Line -... | ||
154 | } |
- | |
155 | - | ||
156 | static void |
- | |
157 | apply_workaround (pixman_image_t *image, |
- | |
158 | int32_t * x, |
- | |
159 | int32_t * y, |
- | |
160 | uint32_t ** save_bits, |
- | |
161 | int * save_dx, |
- | |
162 | int * save_dy) |
- | |
163 | { |
- | |
164 | if (image && (image->common.flags & FAST_PATH_NEEDS_WORKAROUND)) |
- | |
165 | { |
- | |
166 | /* Some X servers generate images that point to the |
- | |
167 | * wrong place in memory, but then set the clip region |
- | |
168 | * to point to the right place. Because of an old bug |
- | |
169 | * in pixman, this would actually work. |
- | |
170 | * |
- | |
171 | * Here we try and undo the damage |
- | |
172 | */ |
- | |
173 | int bpp = PIXMAN_FORMAT_BPP (image->bits.format) / 8; |
- | |
174 | pixman_box32_t *extents; |
- | |
175 | uint8_t *t; |
- | |
176 | int dx, dy; |
- | |
177 | - | ||
178 | extents = pixman_region32_extents (&(image->common.clip_region)); |
- | |
179 | dx = extents->x1; |
- | |
180 | dy = extents->y1; |
- | |
181 | - | ||
182 | *save_bits = image->bits.bits; |
- | |
183 | - | ||
184 | *x -= dx; |
- | |
185 | *y -= dy; |
- | |
186 | pixman_region32_translate (&(image->common.clip_region), -dx, -dy); |
- | |
187 | - | ||
188 | t = (uint8_t *)image->bits.bits; |
- | |
189 | t += dy * image->bits.rowstride * 4 + dx * bpp; |
- | |
190 | image->bits.bits = (uint32_t *)t; |
- | |
191 | - | ||
192 | *save_dx = dx; |
- | |
193 | *save_dy = dy; |
- | |
194 | } |
- | |
195 | } |
- | |
196 | - | ||
197 | static void |
- | |
198 | unapply_workaround (pixman_image_t *image, uint32_t *bits, int dx, int dy) |
- | |
199 | { |
- | |
200 | if (image && (image->common.flags & FAST_PATH_NEEDS_WORKAROUND)) |
- | |
201 | { |
- | |
202 | image->bits.bits = bits; |
- | |
203 | pixman_region32_translate (&image->common.clip_region, dx, dy); |
- | |
204 | } |
- | |
205 | } |
153 | } |
206 | 154 | ||
207 | /* |
155 | /* |
208 | * Computing composite region |
156 | * Computing composite region |
209 | */ |
157 | */ |
Line 274... | Line 222... | ||
274 | 222 | ||
275 | /* |
223 | /* |
276 | * returns FALSE if the final region is empty. Indistinguishable from |
224 | * returns FALSE if the final region is empty. Indistinguishable from |
277 | * an allocation failure, but rendering ignores those anyways. |
225 | * an allocation failure, but rendering ignores those anyways. |
278 | */ |
226 | */ |
279 | static pixman_bool_t |
227 | pixman_bool_t |
280 | pixman_compute_composite_region32 (pixman_region32_t * region, |
228 | _pixman_compute_composite_region32 (pixman_region32_t * region, |
281 | pixman_image_t * src_image, |
229 | pixman_image_t * src_image, |
282 | pixman_image_t * mask_image, |
230 | pixman_image_t * mask_image, |
283 | pixman_image_t * dst_image, |
231 | pixman_image_t * dest_image, |
284 | int32_t src_x, |
232 | int32_t src_x, |
285 | int32_t src_y, |
233 | int32_t src_y, |
286 | int32_t mask_x, |
234 | int32_t mask_x, |
287 | int32_t mask_y, |
235 | int32_t mask_y, |
Line 295... | Line 243... | ||
295 | region->extents.y1 = dest_y; |
243 | region->extents.y1 = dest_y; |
296 | region->extents.y2 = dest_y + height; |
244 | region->extents.y2 = dest_y + height; |
Line 297... | Line 245... | ||
297 | 245 | ||
298 | region->extents.x1 = MAX (region->extents.x1, 0); |
246 | region->extents.x1 = MAX (region->extents.x1, 0); |
299 | region->extents.y1 = MAX (region->extents.y1, 0); |
247 | region->extents.y1 = MAX (region->extents.y1, 0); |
300 | region->extents.x2 = MIN (region->extents.x2, dst_image->bits.width); |
248 | region->extents.x2 = MIN (region->extents.x2, dest_image->bits.width); |
Line 301... | Line 249... | ||
301 | region->extents.y2 = MIN (region->extents.y2, dst_image->bits.height); |
249 | region->extents.y2 = MIN (region->extents.y2, dest_image->bits.height); |
Line 302... | Line 250... | ||
302 | 250 | ||
303 | region->data = 0; |
251 | region->data = 0; |
Line 311... | Line 259... | ||
311 | region->extents.y1 = 0; |
259 | region->extents.y1 = 0; |
312 | region->extents.y2 = 0; |
260 | region->extents.y2 = 0; |
313 | return FALSE; |
261 | return FALSE; |
314 | } |
262 | } |
Line 315... | Line 263... | ||
315 | 263 | ||
316 | if (dst_image->common.have_clip_region) |
264 | if (dest_image->common.have_clip_region) |
317 | { |
265 | { |
318 | if (!clip_general_image (region, &dst_image->common.clip_region, 0, 0)) |
266 | if (!clip_general_image (region, &dest_image->common.clip_region, 0, 0)) |
319 | return FALSE; |
267 | return FALSE; |
Line 320... | Line 268... | ||
320 | } |
268 | } |
321 | 269 | ||
322 | if (dst_image->common.alpha_map) |
270 | if (dest_image->common.alpha_map) |
323 | { |
271 | { |
324 | if (!pixman_region32_intersect_rect (region, region, |
272 | if (!pixman_region32_intersect_rect (region, region, |
325 | dst_image->common.alpha_origin_x, |
273 | dest_image->common.alpha_origin_x, |
326 | dst_image->common.alpha_origin_y, |
274 | dest_image->common.alpha_origin_y, |
327 | dst_image->common.alpha_map->width, |
275 | dest_image->common.alpha_map->width, |
328 | dst_image->common.alpha_map->height)) |
276 | dest_image->common.alpha_map->height)) |
329 | { |
277 | { |
330 | return FALSE; |
278 | return FALSE; |
331 | } |
279 | } |
332 | if (!pixman_region32_not_empty (region)) |
280 | if (!pixman_region32_not_empty (region)) |
333 | return FALSE; |
281 | return FALSE; |
334 | if (dst_image->common.alpha_map->common.have_clip_region) |
282 | if (dest_image->common.alpha_map->common.have_clip_region) |
335 | { |
283 | { |
336 | if (!clip_general_image (region, &dst_image->common.alpha_map->common.clip_region, |
284 | if (!clip_general_image (region, &dest_image->common.alpha_map->common.clip_region, |
337 | -dst_image->common.alpha_origin_x, |
285 | -dest_image->common.alpha_origin_x, |
338 | -dst_image->common.alpha_origin_y)) |
286 | -dest_image->common.alpha_origin_y)) |
339 | { |
287 | { |
340 | return FALSE; |
288 | return FALSE; |
341 | } |
289 | } |
Line 375... | Line 323... | ||
375 | } |
323 | } |
Line 376... | Line 324... | ||
376 | 324 | ||
377 | return TRUE; |
325 | return TRUE; |
Line 378... | Line -... | ||
378 | } |
- | |
379 | - | ||
380 | #define N_CACHED_FAST_PATHS 8 |
326 | } |
381 | 327 | ||
382 | typedef struct |
- | |
383 | { |
- | |
384 | struct |
328 | typedef struct |
385 | { |
- | |
386 | pixman_implementation_t * imp; |
- | |
387 | pixman_fast_path_t fast_path; |
- | |
388 | } cache [N_CACHED_FAST_PATHS]; |
- | |
389 | } cache_t; |
- | |
390 | - | ||
391 | PIXMAN_DEFINE_THREAD_LOCAL (cache_t, fast_path_cache); |
- | |
392 | - | ||
393 | static force_inline pixman_bool_t |
329 | { |
394 | lookup_composite_function (pixman_op_t op, |
- | |
395 | pixman_format_code_t src_format, |
- | |
396 | uint32_t src_flags, |
- | |
397 | pixman_format_code_t mask_format, |
330 | pixman_fixed_48_16_t x1; |
398 | uint32_t mask_flags, |
- | |
399 | pixman_format_code_t dest_format, |
- | |
400 | uint32_t dest_flags, |
- | |
401 | pixman_implementation_t **out_imp, |
- | |
402 | pixman_composite_func_t *out_func) |
331 | pixman_fixed_48_16_t y1; |
403 | { |
- | |
404 | pixman_implementation_t *imp; |
- | |
405 | cache_t *cache; |
- | |
406 | int i; |
- | |
407 | - | ||
408 | /* Check cache for fast paths */ |
- | |
409 | cache = PIXMAN_GET_THREAD_LOCAL (fast_path_cache); |
- | |
410 | - | ||
411 | for (i = 0; i < N_CACHED_FAST_PATHS; ++i) |
- | |
412 | { |
- | |
413 | const pixman_fast_path_t *info = &(cache->cache[i].fast_path); |
- | |
414 | - | ||
415 | /* Note that we check for equality here, not whether |
- | |
416 | * the cached fast path matches. This is to prevent |
- | |
417 | * us from selecting an overly general fast path |
- | |
418 | * when a more specific one would work. |
- | |
419 | */ |
- | |
420 | if (info->op == op && |
- | |
421 | info->src_format == src_format && |
- | |
422 | info->mask_format == mask_format && |
- | |
423 | info->dest_format == dest_format && |
- | |
424 | info->src_flags == src_flags && |
- | |
425 | info->mask_flags == mask_flags && |
- | |
426 | info->dest_flags == dest_flags && |
- | |
427 | info->func) |
- | |
428 | { |
- | |
429 | *out_imp = cache->cache[i].imp; |
- | |
430 | *out_func = cache->cache[i].fast_path.func; |
- | |
431 | - | ||
432 | goto update_cache; |
- | |
433 | } |
- | |
434 | } |
- | |
435 | - | ||
436 | for (imp = get_implementation (); imp != NULL; imp = imp->delegate) |
- | |
437 | { |
- | |
438 | const pixman_fast_path_t *info = imp->fast_paths; |
- | |
439 | - | ||
440 | while (info->op != PIXMAN_OP_NONE) |
- | |
441 | { |
- | |
442 | if ((info->op == op || info->op == PIXMAN_OP_any) && |
- | |
443 | /* Formats */ |
- | |
444 | ((info->src_format == src_format) || |
- | |
445 | (info->src_format == PIXMAN_any)) && |
- | |
446 | ((info->mask_format == mask_format) || |
- | |
447 | (info->mask_format == PIXMAN_any)) && |
- | |
448 | ((info->dest_format == dest_format) || |
- | |
449 | (info->dest_format == PIXMAN_any)) && |
- | |
450 | /* Flags */ |
- | |
451 | (info->src_flags & src_flags) == info->src_flags && |
- | |
452 | (info->mask_flags & mask_flags) == info->mask_flags && |
- | |
453 | (info->dest_flags & dest_flags) == info->dest_flags) |
- | |
454 | { |
- | |
455 | *out_imp = imp; |
- | |
456 | *out_func = info->func; |
- | |
457 | - | ||
458 | /* Set i to the last spot in the cache so that the |
- | |
459 | * move-to-front code below will work |
- | |
460 | */ |
- | |
461 | i = N_CACHED_FAST_PATHS - 1; |
- | |
462 | - | ||
463 | goto update_cache; |
- | |
464 | } |
332 | pixman_fixed_48_16_t x2; |
465 | - | ||
466 | ++info; |
- | |
467 | } |
- | |
468 | } |
- | |
469 | return FALSE; |
- | |
470 | - | ||
471 | update_cache: |
- | |
472 | if (i) |
- | |
473 | { |
- | |
474 | while (i--) |
- | |
475 | cache->cache[i + 1] = cache->cache[i]; |
- | |
476 | - | ||
477 | cache->cache[0].imp = *out_imp; |
- | |
478 | cache->cache[0].fast_path.op = op; |
- | |
479 | cache->cache[0].fast_path.src_format = src_format; |
- | |
480 | cache->cache[0].fast_path.src_flags = src_flags; |
- | |
481 | cache->cache[0].fast_path.mask_format = mask_format; |
- | |
482 | cache->cache[0].fast_path.mask_flags = mask_flags; |
- | |
483 | cache->cache[0].fast_path.dest_format = dest_format; |
- | |
484 | cache->cache[0].fast_path.dest_flags = dest_flags; |
- | |
485 | cache->cache[0].fast_path.func = *out_func; |
- | |
486 | } |
- | |
487 | - | ||
Line 488... | Line 333... | ||
488 | return TRUE; |
333 | pixman_fixed_48_16_t y2; |
489 | } |
334 | } box_48_16_t; |
490 | 335 | ||
491 | static pixman_bool_t |
336 | static pixman_bool_t |
492 | compute_sample_extents (pixman_transform_t *transform, |
- | |
493 | pixman_box32_t *extents, int x, int y, |
337 | compute_transformed_extents (pixman_transform_t *transform, |
494 | pixman_fixed_t x_off, pixman_fixed_t y_off, |
- | |
495 | pixman_fixed_t width, pixman_fixed_t height) |
338 | const pixman_box32_t *extents, |
- | 339 | box_48_16_t *transformed) |
|
- | 340 | { |
|
Line 496... | Line -... | ||
496 | { |
- | |
497 | pixman_fixed_t x1, y1, x2, y2; |
341 | pixman_fixed_48_16_t tx1, ty1, tx2, ty2; |
498 | pixman_fixed_48_16_t tx1, ty1, tx2, ty2; |
342 | pixman_fixed_t x1, y1, x2, y2; |
499 | 343 | int i; |
|
500 | /* We have checked earlier that (extents->x1 - x) etc. fit in a pixman_fixed_t */ |
344 | |
Line 501... | Line 345... | ||
501 | x1 = (pixman_fixed_48_16_t)pixman_int_to_fixed (extents->x1 - x) + pixman_fixed_1 / 2; |
345 | x1 = pixman_int_to_fixed (extents->x1) + pixman_fixed_1 / 2; |
502 | y1 = (pixman_fixed_48_16_t)pixman_int_to_fixed (extents->y1 - y) + pixman_fixed_1 / 2; |
346 | y1 = pixman_int_to_fixed (extents->y1) + pixman_fixed_1 / 2; |
503 | x2 = (pixman_fixed_48_16_t)pixman_int_to_fixed (extents->x2 - x) - pixman_fixed_1 / 2; |
347 | x2 = pixman_int_to_fixed (extents->x2) - pixman_fixed_1 / 2; |
504 | y2 = (pixman_fixed_48_16_t)pixman_int_to_fixed (extents->y2 - y) - pixman_fixed_1 / 2; |
348 | y2 = pixman_int_to_fixed (extents->y2) - pixman_fixed_1 / 2; |
505 | 349 | ||
506 | if (!transform) |
350 | if (!transform) |
- | 351 | { |
|
- | 352 | transformed->x1 = x1; |
|
507 | { |
353 | transformed->y1 = y1; |
508 | tx1 = (pixman_fixed_48_16_t)x1; |
- | |
509 | ty1 = (pixman_fixed_48_16_t)y1; |
- | |
510 | tx2 = (pixman_fixed_48_16_t)x2; |
- | |
Line 511... | Line 354... | ||
511 | ty2 = (pixman_fixed_48_16_t)y2; |
354 | transformed->x2 = x2; |
512 | } |
355 | transformed->y2 = y2; |
Line 513... | Line 356... | ||
513 | else |
356 | |
514 | { |
357 | return TRUE; |
515 | int i; |
358 | } |
516 | 359 | ||
Line 530... | Line 373... | ||
530 | return FALSE; |
373 | return FALSE; |
Line 531... | Line 374... | ||
531 | 374 | ||
532 | tx = (pixman_fixed_48_16_t)v.vector[0]; |
375 | tx = (pixman_fixed_48_16_t)v.vector[0]; |
Line 533... | Line -... | ||
533 | ty = (pixman_fixed_48_16_t)v.vector[1]; |
- | |
534 | - | ||
535 | if (i == 0) |
- | |
536 | { |
- | |
537 | tx1 = tx; |
- | |
538 | ty1 = ty; |
- | |
539 | tx2 = tx; |
- | |
540 | ty2 = ty; |
- | |
541 | } |
- | |
542 | else |
376 | ty = (pixman_fixed_48_16_t)v.vector[1]; |
543 | { |
377 | |
544 | if (tx < tx1) |
378 | if (tx < tx1) |
545 | tx1 = tx; |
379 | tx1 = tx; |
546 | if (ty < ty1) |
380 | if (ty < ty1) |
547 | ty1 = ty; |
381 | ty1 = ty; |
548 | if (tx > tx2) |
382 | if (tx > tx2) |
549 | tx2 = tx; |
383 | tx2 = tx; |
550 | if (ty > ty2) |
384 | if (ty > ty2) |
551 | ty2 = ty; |
- | |
552 | } |
- | |
Line 553... | Line -... | ||
553 | } |
- | |
554 | } |
- | |
555 | - | ||
556 | /* Expand the source area by a tiny bit so account of different rounding that |
- | |
557 | * may happen during sampling. Note that (8 * pixman_fixed_e) is very far from |
385 | ty2 = ty; |
558 | * 0.5 so this won't cause the area computed to be overly pessimistic. |
386 | } |
559 | */ |
- | |
560 | tx1 += x_off - 8 * pixman_fixed_e; |
- | |
561 | ty1 += y_off - 8 * pixman_fixed_e; |
- | |
562 | tx2 += x_off + width + 8 * pixman_fixed_e; |
- | |
563 | ty2 += y_off + height + 8 * pixman_fixed_e; |
- | |
564 | - | ||
565 | if (tx1 < pixman_min_fixed_48_16 || tx1 > pixman_max_fixed_48_16 || |
- | |
566 | ty1 < pixman_min_fixed_48_16 || ty1 > pixman_max_fixed_48_16 || |
- | |
567 | tx2 < pixman_min_fixed_48_16 || tx2 > pixman_max_fixed_48_16 || |
- | |
568 | ty2 < pixman_min_fixed_48_16 || ty2 > pixman_max_fixed_48_16) |
- | |
569 | { |
- | |
570 | return FALSE; |
- | |
571 | } |
387 | |
572 | else |
388 | transformed->x1 = tx1; |
573 | { |
- | |
574 | extents->x1 = pixman_fixed_to_int (tx1); |
- | |
Line 575... | Line 389... | ||
575 | extents->y1 = pixman_fixed_to_int (ty1); |
389 | transformed->y1 = ty1; |
576 | extents->x2 = pixman_fixed_to_int (tx2) + 1; |
390 | transformed->x2 = tx2; |
577 | extents->y2 = pixman_fixed_to_int (ty2) + 1; |
- | |
Line 578... | Line 391... | ||
578 | 391 | transformed->y2 = ty2; |
|
- | 392 | ||
- | 393 | return TRUE; |
|
Line 579... | Line 394... | ||
579 | return TRUE; |
394 | } |
580 | } |
395 | |
581 | } |
396 | #define IS_16BIT(x) (((x) >= INT16_MIN) && ((x) <= INT16_MAX)) |
- | 397 | #define ABS(f) (((f) < 0)? (-(f)) : (f)) |
|
582 | 398 | #define IS_16_16(f) (((f) >= pixman_min_fixed_48_16 && ((f) <= pixman_max_fixed_48_16))) |
|
583 | #define IS_16BIT(x) (((x) >= INT16_MIN) && ((x) <= INT16_MAX)) |
399 | |
584 | - | ||
585 | static pixman_bool_t |
400 | static pixman_bool_t |
586 | analyze_extent (pixman_image_t *image, int x, int y, |
401 | analyze_extent (pixman_image_t *image, |
- | 402 | const pixman_box32_t *extents, |
|
- | 403 | uint32_t *flags) |
|
587 | const pixman_box32_t *extents, uint32_t *flags) |
404 | { |
Line 588... | Line 405... | ||
588 | { |
405 | pixman_transform_t *transform; |
589 | pixman_transform_t *transform; |
406 | pixman_fixed_t x_off, y_off; |
Line 590... | Line 407... | ||
590 | pixman_fixed_t *params; |
407 | pixman_fixed_t width, height; |
591 | pixman_fixed_t x_off, y_off; |
408 | pixman_fixed_t *params; |
592 | pixman_fixed_t width, height; |
409 | box_48_16_t transformed; |
593 | pixman_box32_t ex; |
410 | pixman_box32_t exp_extents; |
594 | 411 | ||
595 | if (!image) |
412 | if (!image) |
596 | return TRUE; |
413 | return TRUE; |
597 | 414 | ||
598 | /* Some compositing functions walk one step |
415 | /* Some compositing functions walk one step |
599 | * outside the destination rectangle, so we |
416 | * outside the destination rectangle, so we |
600 | * check here that the expanded-by-one source |
417 | * check here that the expanded-by-one source |
601 | * extents in destination space fits in 16 bits |
418 | * extents in destination space fits in 16 bits |
Line 602... | Line 419... | ||
602 | */ |
419 | */ |
Line 616... | Line 433... | ||
616 | * them to be smaller than 16 bits. |
433 | * them to be smaller than 16 bits. |
617 | */ |
434 | */ |
618 | if (image->bits.width >= 0x7fff || image->bits.height >= 0x7fff) |
435 | if (image->bits.width >= 0x7fff || image->bits.height >= 0x7fff) |
619 | return FALSE; |
436 | return FALSE; |
Line 620... | Line -... | ||
620 | - | ||
621 | #define ID_AND_NEAREST (FAST_PATH_ID_TRANSFORM | FAST_PATH_NEAREST_FILTER) |
- | |
622 | 437 | ||
623 | if ((image->common.flags & ID_AND_NEAREST) == ID_AND_NEAREST && |
438 | if ((image->common.flags & FAST_PATH_ID_TRANSFORM) == FAST_PATH_ID_TRANSFORM && |
624 | extents->x1 - x >= 0 && |
439 | extents->x1 >= 0 && |
625 | extents->y1 - y >= 0 && |
440 | extents->y1 >= 0 && |
626 | extents->x2 - x <= image->bits.width && |
441 | extents->x2 <= image->bits.width && |
627 | extents->y2 - y <= image->bits.height) |
442 | extents->y2 <= image->bits.height) |
628 | { |
443 | { |
629 | *flags |= FAST_PATH_SAMPLES_COVER_CLIP; |
444 | *flags |= FAST_PATH_SAMPLES_COVER_CLIP_NEAREST; |
630 | return TRUE; |
445 | return TRUE; |
Line 631... | Line 446... | ||
631 | } |
446 | } |
632 | 447 | ||
Line 638... | Line 453... | ||
638 | y_off = - pixman_fixed_e - ((params[1] - pixman_fixed_1) >> 1); |
453 | y_off = - pixman_fixed_e - ((params[1] - pixman_fixed_1) >> 1); |
639 | width = params[0]; |
454 | width = params[0]; |
640 | height = params[1]; |
455 | height = params[1]; |
641 | break; |
456 | break; |
Line -... | Line 457... | ||
- | 457 | ||
- | 458 | case PIXMAN_FILTER_SEPARABLE_CONVOLUTION: |
|
- | 459 | params = image->common.filter_params; |
|
- | 460 | x_off = - pixman_fixed_e - ((params[0] - pixman_fixed_1) >> 1); |
|
- | 461 | y_off = - pixman_fixed_e - ((params[1] - pixman_fixed_1) >> 1); |
|
- | 462 | width = params[0]; |
|
- | 463 | height = params[1]; |
|
- | 464 | break; |
|
642 | 465 | ||
643 | case PIXMAN_FILTER_GOOD: |
466 | case PIXMAN_FILTER_GOOD: |
644 | case PIXMAN_FILTER_BEST: |
467 | case PIXMAN_FILTER_BEST: |
645 | case PIXMAN_FILTER_BILINEAR: |
468 | case PIXMAN_FILTER_BILINEAR: |
646 | x_off = - pixman_fixed_1 / 2; |
469 | x_off = - pixman_fixed_1 / 2; |
Line 658... | Line 481... | ||
658 | break; |
481 | break; |
Line 659... | Line 482... | ||
659 | 482 | ||
660 | default: |
483 | default: |
661 | return FALSE; |
484 | return FALSE; |
662 | } |
- | |
663 | - | ||
664 | /* Check whether the non-expanded, transformed extent is entirely within |
- | |
665 | * the source image, and set the FAST_PATH_SAMPLES_COVER_CLIP if it is. |
- | |
666 | */ |
- | |
667 | ex = *extents; |
- | |
668 | if (compute_sample_extents (transform, &ex, x, y, x_off, y_off, width, height) && |
- | |
669 | ex.x1 >= 0 && ex.y1 >= 0 && |
- | |
670 | ex.x2 <= image->bits.width && ex.y2 <= image->bits.height) |
- | |
671 | { |
- | |
672 | *flags |= FAST_PATH_SAMPLES_COVER_CLIP; |
- | |
673 | } |
485 | } |
674 | } |
486 | } |
675 | else |
487 | else |
676 | { |
488 | { |
677 | x_off = 0; |
489 | x_off = 0; |
678 | y_off = 0; |
490 | y_off = 0; |
679 | width = 0; |
491 | width = 0; |
680 | height = 0; |
492 | height = 0; |
Line -... | Line 493... | ||
- | 493 | } |
|
- | 494 | ||
- | 495 | if (!compute_transformed_extents (transform, extents, &transformed)) |
|
681 | } |
496 | return FALSE; |
682 | 497 | ||
683 | /* Check that the extents expanded by one don't overflow. This ensures that |
498 | /* Expand the source area by a tiny bit so account of different rounding that |
684 | * compositing functions can simply walk the source space using 16.16 |
499 | * may happen during sampling. Note that (8 * pixman_fixed_e) is very far from |
685 | * variables without worrying about overflow. |
500 | * 0.5 so this won't cause the area computed to be overly pessimistic. |
686 | */ |
501 | */ |
687 | ex.x1 = extents->x1 - 1; |
502 | transformed.x1 -= 8 * pixman_fixed_e; |
688 | ex.y1 = extents->y1 - 1; |
503 | transformed.y1 -= 8 * pixman_fixed_e; |
Line -... | Line 504... | ||
- | 504 | transformed.x2 += 8 * pixman_fixed_e; |
|
- | 505 | transformed.y2 += 8 * pixman_fixed_e; |
|
- | 506 | ||
- | 507 | if (image->common.type == BITS) |
|
- | 508 | { |
|
- | 509 | if (pixman_fixed_to_int (transformed.x1) >= 0 && |
|
- | 510 | pixman_fixed_to_int (transformed.y1) >= 0 && |
|
- | 511 | pixman_fixed_to_int (transformed.x2) < image->bits.width && |
|
- | 512 | pixman_fixed_to_int (transformed.y2) < image->bits.height) |
|
- | 513 | { |
|
- | 514 | *flags |= FAST_PATH_SAMPLES_COVER_CLIP_NEAREST; |
|
- | 515 | } |
|
- | 516 | ||
- | 517 | if (pixman_fixed_to_int (transformed.x1 - pixman_fixed_1 / 2) >= 0 && |
|
- | 518 | pixman_fixed_to_int (transformed.y1 - pixman_fixed_1 / 2) >= 0 && |
|
- | 519 | pixman_fixed_to_int (transformed.x2 + pixman_fixed_1 / 2) < image->bits.width && |
|
- | 520 | pixman_fixed_to_int (transformed.y2 + pixman_fixed_1 / 2) < image->bits.height) |
|
- | 521 | { |
|
- | 522 | *flags |= FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR; |
|
- | 523 | } |
|
- | 524 | } |
|
- | 525 | ||
- | 526 | /* Check we don't overflow when the destination extents are expanded by one. |
|
- | 527 | * This ensures that compositing functions can simply walk the source space |
|
- | 528 | * using 16.16 variables without worrying about overflow. |
|
- | 529 | */ |
|
- | 530 | exp_extents = *extents; |
|
- | 531 | exp_extents.x1 -= 1; |
|
- | 532 | exp_extents.y1 -= 1; |
|
689 | ex.x2 = extents->x2 + 1; |
533 | exp_extents.x2 += 1; |
690 | ex.y2 = extents->y2 + 1; |
534 | exp_extents.y2 += 1; |
Line -... | Line 535... | ||
- | 535 | ||
- | 536 | if (!compute_transformed_extents (transform, &exp_extents, &transformed)) |
|
- | 537 | return FALSE; |
|
- | 538 | ||
- | 539 | if (!IS_16_16 (transformed.x1 + x_off - 8 * pixman_fixed_e) || |
|
- | 540 | !IS_16_16 (transformed.y1 + y_off - 8 * pixman_fixed_e) || |
|
- | 541 | !IS_16_16 (transformed.x2 + x_off + 8 * pixman_fixed_e + width) || |
|
- | 542 | !IS_16_16 (transformed.y2 + y_off + 8 * pixman_fixed_e + height)) |
|
691 | 543 | { |
|
692 | if (!compute_sample_extents (transform, &ex, x, y, x_off, y_off, width, height)) |
544 | return FALSE; |
Line 693... | Line 545... | ||
693 | return FALSE; |
545 | } |
694 | 546 | ||
Line 727... | Line 579... | ||
727 | int32_t dest_y, |
579 | int32_t dest_y, |
728 | int32_t width, |
580 | int32_t width, |
729 | int32_t height) |
581 | int32_t height) |
730 | { |
582 | { |
731 | pixman_format_code_t src_format, mask_format, dest_format; |
583 | pixman_format_code_t src_format, mask_format, dest_format; |
732 | uint32_t src_flags, mask_flags, dest_flags; |
- | |
733 | pixman_region32_t region; |
584 | pixman_region32_t region; |
734 | pixman_box32_t *extents; |
585 | pixman_box32_t extents; |
735 | uint32_t *src_bits; |
- | |
736 | int src_dx, src_dy; |
- | |
737 | uint32_t *mask_bits; |
- | |
738 | int mask_dx, mask_dy; |
- | |
739 | uint32_t *dest_bits; |
- | |
740 | int dest_dx, dest_dy; |
- | |
741 | pixman_bool_t need_workaround; |
- | |
742 | pixman_implementation_t *imp; |
586 | pixman_implementation_t *imp; |
743 | pixman_composite_func_t func; |
587 | pixman_composite_func_t func; |
- | 588 | pixman_composite_info_t info; |
|
- | 589 | const pixman_box32_t *pbox; |
|
- | 590 | int n; |
|
Line 744... | Line 591... | ||
744 | 591 | ||
745 | _pixman_image_validate (src); |
592 | _pixman_image_validate (src); |
746 | if (mask) |
593 | if (mask) |
747 | _pixman_image_validate (mask); |
594 | _pixman_image_validate (mask); |
Line 748... | Line 595... | ||
748 | _pixman_image_validate (dest); |
595 | _pixman_image_validate (dest); |
749 | 596 | ||
Line 750... | Line 597... | ||
750 | src_format = src->common.extended_format_code; |
597 | src_format = src->common.extended_format_code; |
751 | src_flags = src->common.flags; |
598 | info.src_flags = src->common.flags; |
752 | 599 | ||
753 | if (mask) |
600 | if (mask && !(mask->common.flags & FAST_PATH_IS_OPAQUE)) |
754 | { |
601 | { |
755 | mask_format = mask->common.extended_format_code; |
602 | mask_format = mask->common.extended_format_code; |
756 | mask_flags = mask->common.flags; |
603 | info.mask_flags = mask->common.flags; |
757 | } |
604 | } |
758 | else |
605 | else |
759 | { |
606 | { |
Line 760... | Line 607... | ||
760 | mask_format = PIXMAN_null; |
607 | mask_format = PIXMAN_null; |
761 | mask_flags = FAST_PATH_IS_OPAQUE; |
608 | info.mask_flags = FAST_PATH_IS_OPAQUE; |
Line 762... | Line 609... | ||
762 | } |
609 | } |
763 | 610 | ||
764 | dest_format = dest->common.extended_format_code; |
611 | dest_format = dest->common.extended_format_code; |
765 | dest_flags = dest->common.flags; |
612 | info.dest_flags = dest->common.flags; |
- | 613 | ||
766 | 614 | /* Check for pixbufs */ |
|
767 | /* Check for pixbufs */ |
615 | if ((mask_format == PIXMAN_a8r8g8b8 || mask_format == PIXMAN_a8b8g8r8) && |
768 | if ((mask_format == PIXMAN_a8r8g8b8 || mask_format == PIXMAN_a8b8g8r8) && |
616 | (src->type == BITS && src->bits.bits == mask->bits.bits) && |
769 | (src->type == BITS && src->bits.bits == mask->bits.bits) && |
617 | (src->common.repeat == mask->common.repeat) && |
770 | (src->common.repeat == mask->common.repeat) && |
618 | (info.src_flags & info.mask_flags & FAST_PATH_ID_TRANSFORM) && |
771 | (src_x == mask_x && src_y == mask_y)) |
619 | (src_x == mask_x && src_y == mask_y)) |
772 | { |
620 | { |
Line 773... | Line -... | ||
773 | if (src_format == PIXMAN_x8b8g8r8) |
- | |
774 | src_format = mask_format = PIXMAN_pixbuf; |
- | |
775 | else if (src_format == PIXMAN_x8r8g8b8) |
- | |
776 | src_format = mask_format = PIXMAN_rpixbuf; |
- | |
777 | } |
- | |
778 | - | ||
779 | /* Check for workaround */ |
- | |
780 | need_workaround = (src_flags | mask_flags | dest_flags) & FAST_PATH_NEEDS_WORKAROUND; |
- | |
781 | - | ||
782 | if (need_workaround) |
- | |
783 | { |
621 | if (src_format == PIXMAN_x8b8g8r8) |
Line 784... | Line 622... | ||
784 | apply_workaround (src, &src_x, &src_y, &src_bits, &src_dx, &src_dy); |
622 | src_format = mask_format = PIXMAN_pixbuf; |
785 | apply_workaround (mask, &mask_x, &mask_y, &mask_bits, &mask_dx, &mask_dy); |
623 | else if (src_format == PIXMAN_x8r8g8b8) |
786 | apply_workaround (dest, &dest_x, &dest_y, &dest_bits, &dest_dx, &dest_dy); |
624 | src_format = mask_format = PIXMAN_rpixbuf; |
787 | } |
625 | } |
788 | 626 | ||
789 | pixman_region32_init (®ion); |
627 | pixman_region32_init (®ion); |
Line 790... | Line 628... | ||
790 | 628 | ||
- | 629 | if (!_pixman_compute_composite_region32 ( |
|
- | 630 | ®ion, src, mask, dest, |
|
- | 631 | src_x, src_y, mask_x, mask_y, dest_x, dest_y, width, height)) |
|
- | 632 | { |
|
- | 633 | goto out; |
|
Line 791... | Line 634... | ||
791 | if (!pixman_compute_composite_region32 ( |
634 | } |
792 | ®ion, src, mask, dest, |
635 | |
Line -... | Line 636... | ||
- | 636 | extents = *pixman_region32_extents (®ion); |
|
- | 637 | ||
- | 638 | extents.x1 -= dest_x - src_x; |
|
- | 639 | extents.y1 -= dest_y - src_y; |
|
- | 640 | extents.x2 -= dest_x - src_x; |
|
793 | src_x, src_y, mask_x, mask_y, dest_x, dest_y, width, height)) |
641 | extents.y2 -= dest_y - src_y; |
794 | { |
642 | |
Line 795... | Line 643... | ||
795 | goto out; |
643 | if (!analyze_extent (src, &extents, &info.src_flags)) |
796 | } |
644 | goto out; |
797 | 645 | ||
- | 646 | extents.x1 -= src_x - mask_x; |
|
- | 647 | extents.y1 -= src_y - mask_y; |
|
- | 648 | extents.x2 -= src_x - mask_x; |
|
798 | extents = pixman_region32_extents (®ion); |
649 | extents.y2 -= src_y - mask_y; |
- | 650 | ||
- | 651 | if (!analyze_extent (mask, &extents, &info.mask_flags)) |
|
Line 799... | Line 652... | ||
799 | 652 | goto out; |
|
- | 653 | ||
- | 654 | /* If the clip is within the source samples, and the samples are |
|
800 | if (!analyze_extent (src, dest_x - src_x, dest_y - src_y, extents, &src_flags)) |
655 | * opaque, then the source is effectively opaque. |
- | 656 | */ |
|
Line 801... | Line 657... | ||
801 | goto out; |
657 | #define NEAREST_OPAQUE (FAST_PATH_SAMPLES_OPAQUE | \ |
- | 658 | FAST_PATH_NEAREST_FILTER | \ |
|
- | 659 | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST) |
|
802 | 660 | #define BILINEAR_OPAQUE (FAST_PATH_SAMPLES_OPAQUE | \ |
|
- | 661 | FAST_PATH_BILINEAR_FILTER | \ |
|
Line 803... | Line 662... | ||
803 | if (!analyze_extent (mask, dest_x - mask_x, dest_y - mask_y, extents, &mask_flags)) |
662 | FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR) |
804 | goto out; |
663 | |
805 | 664 | if ((info.src_flags & NEAREST_OPAQUE) == NEAREST_OPAQUE || |
|
806 | /* If the clip is within the source samples, and the samples are opaque, |
665 | (info.src_flags & BILINEAR_OPAQUE) == BILINEAR_OPAQUE) |
807 | * then the source is effectively opaque. |
666 | { |
808 | */ |
667 | info.src_flags |= FAST_PATH_IS_OPAQUE; |
809 | #define BOTH (FAST_PATH_SAMPLES_OPAQUE | FAST_PATH_SAMPLES_COVER_CLIP) |
- | |
810 | - | ||
Line 811... | Line 668... | ||
811 | if ((src_flags & BOTH) == BOTH) |
668 | } |
- | 669 | ||
812 | src_flags |= FAST_PATH_IS_OPAQUE; |
670 | if ((info.mask_flags & NEAREST_OPAQUE) == NEAREST_OPAQUE || |
813 | 671 | (info.mask_flags & BILINEAR_OPAQUE) == BILINEAR_OPAQUE) |
|
814 | if ((mask_flags & BOTH) == BOTH) |
672 | { |
815 | mask_flags |= FAST_PATH_IS_OPAQUE; |
673 | info.mask_flags |= FAST_PATH_IS_OPAQUE; |
816 | 674 | } |
|
- | 675 | ||
817 | /* |
676 | /* |
818 | * Check if we can replace our operator by a simpler one |
677 | * Check if we can replace our operator by a simpler one |
Line 819... | Line 678... | ||
819 | * if the src or dest are opaque. The output operator should be |
678 | * if the src or dest are opaque. The output operator should be |
Line 820... | Line 679... | ||
820 | * mathematically equivalent to the source. |
679 | * mathematically equivalent to the source. |
821 | */ |
680 | */ |
822 | op = optimize_operator (op, src_flags, mask_flags, dest_flags); |
- | |
823 | if (op == PIXMAN_OP_DST) |
- | |
824 | goto out; |
681 | info.op = optimize_operator (op, info.src_flags, info.mask_flags, info.dest_flags); |
825 | 682 | ||
826 | if (lookup_composite_function (op, |
683 | _pixman_implementation_lookup_composite ( |
827 | src_format, src_flags, |
684 | get_implementation (), info.op, |
828 | mask_format, mask_flags, |
685 | src_format, info.src_flags, |
829 | dest_format, dest_flags, |
686 | mask_format, info.mask_flags, |
830 | &imp, &func)) |
687 | dest_format, info.dest_flags, |
831 | { |
688 | &imp, &func); |
- | 689 | ||
- | 690 | info.src_image = src; |
|
Line 832... | Line 691... | ||
832 | const pixman_box32_t *pbox; |
691 | info.mask_image = mask; |
833 | int n; |
692 | info.dest_image = dest; |
834 | - | ||
Line 835... | Line 693... | ||
835 | pbox = pixman_region32_rectangles (®ion, &n); |
693 | |
836 | - | ||
837 | while (n--) |
- | |
838 | { |
- | |
839 | func (imp, op, |
- | |
840 | src, mask, dest, |
- | |
841 | pbox->x1 + src_x - dest_x, |
- | |
842 | pbox->y1 + src_y - dest_y, |
- | |
843 | pbox->x1 + mask_x - dest_x, |
694 | pbox = pixman_region32_rectangles (®ion, &n); |
844 | pbox->y1 + mask_y - dest_y, |
695 | |
Line 845... | Line 696... | ||
845 | pbox->x1, |
696 | while (n--) |
846 | pbox->y1, |
697 | { |
Line 887... | Line 738... | ||
887 | int dst_stride, |
738 | int dst_stride, |
888 | int src_bpp, |
739 | int src_bpp, |
889 | int dst_bpp, |
740 | int dst_bpp, |
890 | int src_x, |
741 | int src_x, |
891 | int src_y, |
742 | int src_y, |
892 | int dst_x, |
743 | int dest_x, |
893 | int dst_y, |
744 | int dest_y, |
894 | int width, |
745 | int width, |
895 | int height) |
746 | int height) |
896 | { |
747 | { |
897 | return _pixman_implementation_blt (get_implementation(), |
748 | return _pixman_implementation_blt (get_implementation(), |
898 | src_bits, dst_bits, src_stride, dst_stride, |
749 | src_bits, dst_bits, src_stride, dst_stride, |
899 | src_bpp, dst_bpp, |
750 | src_bpp, dst_bpp, |
900 | src_x, src_y, |
751 | src_x, src_y, |
901 | dst_x, dst_y, |
752 | dest_x, dest_y, |
902 | width, height); |
753 | width, height); |
903 | } |
754 | } |
Line 904... | Line 755... | ||
904 | 755 | ||
905 | PIXMAN_EXPORT pixman_bool_t |
756 | PIXMAN_EXPORT pixman_bool_t |
Line 908... | Line 759... | ||
908 | int bpp, |
759 | int bpp, |
909 | int x, |
760 | int x, |
910 | int y, |
761 | int y, |
911 | int width, |
762 | int width, |
912 | int height, |
763 | int height, |
913 | uint32_t xor) |
764 | uint32_t filler) |
914 | { |
765 | { |
915 | return _pixman_implementation_fill ( |
766 | return _pixman_implementation_fill ( |
916 | get_implementation(), bits, stride, bpp, x, y, width, height, xor); |
767 | get_implementation(), bits, stride, bpp, x, y, width, height, filler); |
917 | } |
768 | } |
Line 918... | Line 769... | ||
918 | 769 | ||
919 | static uint32_t |
770 | static uint32_t |
920 | color_to_uint32 (const pixman_color_t *color) |
771 | color_to_uint32 (const pixman_color_t *color) |
Line 925... | Line 776... | ||
925 | (color->green & 0xff00) | |
776 | (color->green & 0xff00) | |
926 | (color->blue >> 8); |
777 | (color->blue >> 8); |
927 | } |
778 | } |
Line 928... | Line 779... | ||
928 | 779 | ||
929 | static pixman_bool_t |
780 | static pixman_bool_t |
930 | color_to_pixel (pixman_color_t * color, |
781 | color_to_pixel (const pixman_color_t *color, |
931 | uint32_t * pixel, |
782 | uint32_t * pixel, |
932 | pixman_format_code_t format) |
783 | pixman_format_code_t format) |
933 | { |
784 | { |
Line 937... | Line 788... | ||
937 | format == PIXMAN_x8r8g8b8 || |
788 | format == PIXMAN_x8r8g8b8 || |
938 | format == PIXMAN_a8b8g8r8 || |
789 | format == PIXMAN_a8b8g8r8 || |
939 | format == PIXMAN_x8b8g8r8 || |
790 | format == PIXMAN_x8b8g8r8 || |
940 | format == PIXMAN_b8g8r8a8 || |
791 | format == PIXMAN_b8g8r8a8 || |
941 | format == PIXMAN_b8g8r8x8 || |
792 | format == PIXMAN_b8g8r8x8 || |
- | 793 | format == PIXMAN_r8g8b8a8 || |
|
- | 794 | format == PIXMAN_r8g8b8x8 || |
|
942 | format == PIXMAN_r5g6b5 || |
795 | format == PIXMAN_r5g6b5 || |
943 | format == PIXMAN_b5g6r5 || |
796 | format == PIXMAN_b5g6r5 || |
- | 797 | format == PIXMAN_a8 || |
|
944 | format == PIXMAN_a8)) |
798 | format == PIXMAN_a1)) |
945 | { |
799 | { |
946 | return FALSE; |
800 | return FALSE; |
947 | } |
801 | } |
Line 948... | Line 802... | ||
948 | 802 | ||
Line 958... | Line 812... | ||
958 | c = ((c & 0xff000000) >> 24) | |
812 | c = ((c & 0xff000000) >> 24) | |
959 | ((c & 0x00ff0000) >> 8) | |
813 | ((c & 0x00ff0000) >> 8) | |
960 | ((c & 0x0000ff00) << 8) | |
814 | ((c & 0x0000ff00) << 8) | |
961 | ((c & 0x000000ff) << 24); |
815 | ((c & 0x000000ff) << 24); |
962 | } |
816 | } |
- | 817 | if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_RGBA) |
|
- | 818 | c = ((c & 0xff000000) >> 24) | (c << 8); |
|
Line 963... | Line 819... | ||
963 | 819 | ||
- | 820 | if (format == PIXMAN_a1) |
|
- | 821 | c = c >> 31; |
|
964 | if (format == PIXMAN_a8) |
822 | else if (format == PIXMAN_a8) |
965 | c = c >> 24; |
823 | c = c >> 24; |
966 | else if (format == PIXMAN_r5g6b5 || |
824 | else if (format == PIXMAN_r5g6b5 || |
967 | format == PIXMAN_b5g6r5) |
825 | format == PIXMAN_b5g6r5) |
Line 968... | Line 826... | ||
968 | c = CONVERT_8888_TO_0565 (c); |
826 | c = convert_8888_to_0565 (c); |
969 | 827 | ||
970 | #if 0 |
828 | #if 0 |
971 | printf ("color: %x %x %x %x\n", color->alpha, color->red, color->green, color->blue); |
829 | printf ("color: %x %x %x %x\n", color->alpha, color->red, color->green, color->blue); |
Line 977... | Line 835... | ||
977 | } |
835 | } |
Line 978... | Line 836... | ||
978 | 836 | ||
979 | PIXMAN_EXPORT pixman_bool_t |
837 | PIXMAN_EXPORT pixman_bool_t |
980 | pixman_image_fill_rectangles (pixman_op_t op, |
838 | pixman_image_fill_rectangles (pixman_op_t op, |
981 | pixman_image_t * dest, |
839 | pixman_image_t * dest, |
982 | pixman_color_t * color, |
840 | const pixman_color_t * color, |
983 | int n_rects, |
841 | int n_rects, |
984 | const pixman_rectangle16_t *rects) |
842 | const pixman_rectangle16_t *rects) |
985 | { |
843 | { |
986 | pixman_box32_t stack_boxes[6]; |
844 | pixman_box32_t stack_boxes[6]; |
Line 1016... | Line 874... | ||
1016 | } |
874 | } |
Line 1017... | Line 875... | ||
1017 | 875 | ||
1018 | PIXMAN_EXPORT pixman_bool_t |
876 | PIXMAN_EXPORT pixman_bool_t |
1019 | pixman_image_fill_boxes (pixman_op_t op, |
877 | pixman_image_fill_boxes (pixman_op_t op, |
1020 | pixman_image_t * dest, |
878 | pixman_image_t * dest, |
1021 | pixman_color_t * color, |
879 | const pixman_color_t *color, |
1022 | int n_boxes, |
880 | int n_boxes, |
1023 | const pixman_box32_t *boxes) |
881 | const pixman_box32_t *boxes) |
1024 | { |
882 | { |
1025 | pixman_image_t *solid; |
883 | pixman_image_t *solid; |
Line 1161... | Line 1019... | ||
1161 | case PIXMAN_a2b10g10r10: |
1019 | case PIXMAN_a2b10g10r10: |
1162 | case PIXMAN_x2b10g10r10: |
1020 | case PIXMAN_x2b10g10r10: |
1163 | case PIXMAN_a2r10g10b10: |
1021 | case PIXMAN_a2r10g10b10: |
1164 | case PIXMAN_x2r10g10b10: |
1022 | case PIXMAN_x2r10g10b10: |
1165 | case PIXMAN_a8r8g8b8: |
1023 | case PIXMAN_a8r8g8b8: |
- | 1024 | case PIXMAN_a8r8g8b8_sRGB: |
|
1166 | case PIXMAN_x8r8g8b8: |
1025 | case PIXMAN_x8r8g8b8: |
1167 | case PIXMAN_a8b8g8r8: |
1026 | case PIXMAN_a8b8g8r8: |
1168 | case PIXMAN_x8b8g8r8: |
1027 | case PIXMAN_x8b8g8r8: |
1169 | case PIXMAN_b8g8r8a8: |
1028 | case PIXMAN_b8g8r8a8: |
1170 | case PIXMAN_b8g8r8x8: |
1029 | case PIXMAN_b8g8r8x8: |
- | 1030 | case PIXMAN_r8g8b8a8: |
|
- | 1031 | case PIXMAN_r8g8b8x8: |
|
1171 | case PIXMAN_r8g8b8: |
1032 | case PIXMAN_r8g8b8: |
1172 | case PIXMAN_b8g8r8: |
1033 | case PIXMAN_b8g8r8: |
1173 | case PIXMAN_r5g6b5: |
1034 | case PIXMAN_r5g6b5: |
1174 | case PIXMAN_b5g6r5: |
1035 | case PIXMAN_b5g6r5: |
1175 | case PIXMAN_x14r6g6b6: |
1036 | case PIXMAN_x14r6g6b6: |
Line 1241... | Line 1102... | ||
1241 | 1102 | ||
1242 | PIXMAN_EXPORT pixman_bool_t |
1103 | PIXMAN_EXPORT pixman_bool_t |
1243 | pixman_compute_composite_region (pixman_region16_t * region, |
1104 | pixman_compute_composite_region (pixman_region16_t * region, |
1244 | pixman_image_t * src_image, |
1105 | pixman_image_t * src_image, |
1245 | pixman_image_t * mask_image, |
1106 | pixman_image_t * mask_image, |
1246 | pixman_image_t * dst_image, |
1107 | pixman_image_t * dest_image, |
1247 | int16_t src_x, |
1108 | int16_t src_x, |
1248 | int16_t src_y, |
1109 | int16_t src_y, |
1249 | int16_t mask_x, |
1110 | int16_t mask_x, |
1250 | int16_t mask_y, |
1111 | int16_t mask_y, |
Line 1256... | Line 1117... | ||
1256 | pixman_region32_t r32; |
1117 | pixman_region32_t r32; |
1257 | pixman_bool_t retval; |
1118 | pixman_bool_t retval; |
Line 1258... | Line 1119... | ||
1258 | 1119 | ||
Line 1259... | Line 1120... | ||
1259 | pixman_region32_init (&r32); |
1120 | pixman_region32_init (&r32); |
1260 | 1121 | ||
1261 | retval = pixman_compute_composite_region32 ( |
1122 | retval = _pixman_compute_composite_region32 ( |
1262 | &r32, src_image, mask_image, dst_image, |
1123 | &r32, src_image, mask_image, dest_image, |
Line 1263... | Line 1124... | ||
1263 | src_x, src_y, mask_x, mask_y, dest_x, dest_y, |
1124 | src_x, src_y, mask_x, mask_y, dest_x, dest_y, |
1264 | width, height); |
1125 | width, height); |