2 * Copyright 1987, 1988, 1989, 1998 The Open Group
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
17 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 * Except as contained in this notice, the name of The Open Group shall not be
21 * used in advertising or otherwise to promote the sale, use or other dealings
22 * in this Software without prior written authorization from The Open Group.
24 * Copyright 1987, 1988, 1989 by
25 * Digital Equipment Corporation, Maynard, Massachusetts.
29 * Permission to use, copy, modify, and distribute this software and its
30 * documentation for any purpose and without fee is hereby granted,
31 * provided that the above copyright notice appear in all copies and that
32 * both that copyright notice and this permission notice appear in
33 * supporting documentation, and that the name of Digital not be
34 * used in advertising or publicity pertaining to distribution of the
35 * software without specific, written prior permission.
37 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
40 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
41 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
42 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
45 * Copyright © 1998 Keith Packard
47 * Permission to use, copy, modify, distribute, and sell this software and its
48 * documentation for any purpose is hereby granted without fee, provided that
49 * the above copyright notice appear in all copies and that both that
50 * copyright notice and this permission notice appear in supporting
51 * documentation, and that the name of Keith Packard not be used in
52 * advertising or publicity pertaining to distribution of the software without
53 * specific, written prior permission. Keith Packard makes no
54 * representations about the suitability of this software for any purpose. It
55 * is provided "as is" without express or implied warranty.
57 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
58 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
59 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
60 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
61 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
62 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
63 * PERFORMANCE OF THIS SOFTWARE.
70 #include "pixman-private.h"
72 #define PIXREGION_NIL(reg) ((reg)->data && !(reg)->data->numRects)
74 #define PIXREGION_NAR(reg) ((reg)->data == pixman_broken_data)
75 #define PIXREGION_NUMRECTS(reg) ((reg)->data ? (reg)->data->numRects : 1)
76 #define PIXREGION_SIZE(reg) ((reg)->data ? (reg)->data->size : 0)
77 #define PIXREGION_RECTS(reg) \
78 ((reg)->data ? (box_type_t *)((reg)->data + 1) \
80 #define PIXREGION_BOXPTR(reg) ((box_type_t *)((reg)->data + 1))
81 #define PIXREGION_BOX(reg, i) (&PIXREGION_BOXPTR (reg)[i])
82 #define PIXREGION_TOP(reg) PIXREGION_BOX (reg, (reg)->data->numRects)
83 #define PIXREGION_END(reg) PIXREGION_BOX (reg, (reg)->data->numRects - 1)
85 #define GOOD_RECT(rect) ((rect)->x1 < (rect)->x2 && (rect)->y1 < (rect)->y2)
86 #define BAD_RECT(rect) ((rect)->x1 > (rect)->x2 || (rect)->y1 > (rect)->y2)
93 if (!PREFIX (_selfcheck (reg))) \
94 _pixman_log_error (FUNC, "Malformed region " # reg); \
103 static const box_type_t PREFIX (_empty_box_) = { 0, 0, 0, 0 };
104 static const region_data_type_t PREFIX (_empty_data_) = { 0, 0 };
105 #if defined (__llvm__) && !defined (__clang__)
106 static const volatile region_data_type_t PREFIX (_broken_data_) = { 0, 0 };
108 static const region_data_type_t PREFIX (_broken_data_) = { 0, 0 };
111 static box_type_t *pixman_region_empty_box =
112 (box_type_t *)&PREFIX (_empty_box_);
113 static region_data_type_t *pixman_region_empty_data =
114 (region_data_type_t *)&PREFIX (_empty_data_);
115 static region_data_type_t *pixman_broken_data =
116 (region_data_type_t *)&PREFIX (_broken_data_);
119 pixman_break (region_type_t *region);
122 * The functions in this file implement the Region abstraction used extensively
123 * throughout the X11 sample server. A Region is simply a set of disjoint
124 * (non-overlapping) rectangles, plus an "extent" rectangle which is the
125 * smallest single rectangle that contains all the non-overlapping rectangles.
127 * A Region is implemented as a "y-x-banded" array of rectangles. This array
128 * imposes two degrees of order. First, all rectangles are sorted by top side
129 * y coordinate first (y1), and then by left side x coordinate (x1).
131 * Furthermore, the rectangles are grouped into "bands". Each rectangle in a
132 * band has the same top y coordinate (y1), and each has the same bottom y
133 * coordinate (y2). Thus all rectangles in a band differ only in their left
134 * and right side (x1 and x2). Bands are implicit in the array of rectangles:
135 * there is no separate list of band start pointers.
137 * The y-x band representation does not minimize rectangles. In particular,
138 * if a rectangle vertically crosses a band (the rectangle has scanlines in
139 * the y1 to y2 area spanned by the band), then the rectangle may be broken
140 * down into two or more smaller rectangles stacked one atop the other.
142 * ----------- -----------
144 * | | -------- ----------- --------
145 * | | | | in y-x banded | | | | band 1
146 * | | | | form is | | | |
147 * ----------- | | ----------- --------
151 * An added constraint on the rectangles is that they must cover as much
152 * horizontal area as possible: no two rectangles within a band are allowed
155 * Whenever possible, bands will be merged together to cover a greater vertical
156 * distance (and thus reduce the number of rectangles). Two bands can be merged
157 * only if the bottom of one touches the top of the other and they have
158 * rectangles in the same places (of the same width, of course).
160 * Adam de Boor wrote most of the original region code. Joel McCormack
161 * substantially modified or rewrote most of the core arithmetic routines, and
162 * added pixman_region_validate in order to support several speed improvements
163 * to pixman_region_validate_tree. Bob Scheifler changed the representation
164 * to be more compact when empty or a single rectangle, and did a bunch of
165 * gratuitous reformatting. Carl Worth did further gratuitous reformatting
166 * while re-merging the server and client region code into libpixregion.
167 * Soren Sandmann did even more gratuitous reformatting.
170 /* true iff two Boxes overlap */
171 #define EXTENTCHECK(r1, r2) \
172 (!( ((r1)->x2 <= (r2)->x1) || \
173 ((r1)->x1 >= (r2)->x2) || \
174 ((r1)->y2 <= (r2)->y1) || \
175 ((r1)->y1 >= (r2)->y2) ) )
177 /* true iff (x,y) is in Box */
178 #define INBOX(r, x, y) \
184 /* true iff Box r1 contains Box r2 */
185 #define SUBSUMES(r1, r2) \
186 ( ((r1)->x1 <= (r2)->x1) && \
187 ((r1)->x2 >= (r2)->x2) && \
188 ((r1)->y1 <= (r2)->y1) && \
189 ((r1)->y2 >= (r2)->y2) )
192 PIXREGION_SZOF (size_t n)
194 size_t size = n * sizeof(box_type_t);
196 if (n > UINT32_MAX / sizeof(box_type_t))
199 if (sizeof(region_data_type_t) > UINT32_MAX - size)
202 return size + sizeof(region_data_type_t);
206 alloc_data (size_t n)
208 size_t sz = PIXREGION_SZOF (n);
216 #define FREE_DATA(reg) if ((reg)->data && (reg)->data->size) free ((reg)->data)
218 #define RECTALLOC_BAIL(region, n, bail) \
221 if (!(region)->data || \
222 (((region)->data->numRects + (n)) > (region)->data->size)) \
224 if (!pixman_rect_alloc (region, n)) \
229 #define RECTALLOC(region, n) \
232 if (!(region)->data || \
233 (((region)->data->numRects + (n)) > (region)->data->size)) \
235 if (!pixman_rect_alloc (region, n)) { \
241 #define ADDRECT(next_rect, nx1, ny1, nx2, ny2) \
244 next_rect->x1 = nx1; \
245 next_rect->y1 = ny1; \
246 next_rect->x2 = nx2; \
247 next_rect->y2 = ny2; \
252 #define NEWRECT(region, next_rect, nx1, ny1, nx2, ny2) \
255 if (!(region)->data || \
256 ((region)->data->numRects == (region)->data->size)) \
258 if (!pixman_rect_alloc (region, 1)) \
260 next_rect = PIXREGION_TOP (region); \
262 ADDRECT (next_rect, nx1, ny1, nx2, ny2); \
263 region->data->numRects++; \
264 critical_if_fail (region->data->numRects <= region->data->size); \
267 #define DOWNSIZE(reg, numRects) \
270 if (((numRects) < ((reg)->data->size >> 1)) && \
271 ((reg)->data->size > 50)) \
273 region_data_type_t * new_data; \
274 size_t data_size = PIXREGION_SZOF (numRects); \
282 new_data = (region_data_type_t *) \
283 realloc ((reg)->data, data_size); \
288 new_data->size = (numRects); \
289 (reg)->data = new_data; \
294 PIXMAN_EXPORT pixman_bool_t
295 PREFIX (_equal) (region_type_t *reg1, region_type_t *reg2)
301 if (reg1->extents.x1 != reg2->extents.x1)
304 if (reg1->extents.x2 != reg2->extents.x2)
307 if (reg1->extents.y1 != reg2->extents.y1)
310 if (reg1->extents.y2 != reg2->extents.y2)
313 if (PIXREGION_NUMRECTS (reg1) != PIXREGION_NUMRECTS (reg2))
316 rects1 = PIXREGION_RECTS (reg1);
317 rects2 = PIXREGION_RECTS (reg2);
319 for (i = 0; i != PIXREGION_NUMRECTS (reg1); i++)
321 if (rects1[i].x1 != rects2[i].x1)
324 if (rects1[i].x2 != rects2[i].x2)
327 if (rects1[i].y1 != rects2[i].y1)
330 if (rects1[i].y2 != rects2[i].y2)
338 PREFIX (_print) (region_type_t *rgn)
344 num = PIXREGION_NUMRECTS (rgn);
345 size = PIXREGION_SIZE (rgn);
346 rects = PIXREGION_RECTS (rgn);
348 fprintf (stderr, "num: %d size: %d\n", num, size);
349 fprintf (stderr, "extents: %d %d %d %d\n",
355 for (i = 0; i < num; i++)
357 fprintf (stderr, "%d %d %d %d \n",
358 rects[i].x1, rects[i].y1, rects[i].x2, rects[i].y2);
361 fprintf (stderr, "\n");
368 PREFIX (_init) (region_type_t *region)
370 region->extents = *pixman_region_empty_box;
371 region->data = pixman_region_empty_data;
375 PREFIX (_init_rect) (region_type_t * region,
381 region->extents.x1 = x;
382 region->extents.y1 = y;
383 region->extents.x2 = x + width;
384 region->extents.y2 = y + height;
386 if (!GOOD_RECT (®ion->extents))
388 if (BAD_RECT (®ion->extents))
389 _pixman_log_error (FUNC, "Invalid rectangle passed");
390 PREFIX (_init) (region);
398 PREFIX (_init_with_extents) (region_type_t *region, box_type_t *extents)
400 if (!GOOD_RECT (extents))
402 if (BAD_RECT (extents))
403 _pixman_log_error (FUNC, "Invalid rectangle passed");
404 PREFIX (_init) (region);
407 region->extents = *extents;
413 PREFIX (_fini) (region_type_t *region)
420 PREFIX (_n_rects) (region_type_t *region)
422 return PIXREGION_NUMRECTS (region);
425 PIXMAN_EXPORT box_type_t *
426 PREFIX (_rectangles) (region_type_t *region,
430 *n_rects = PIXREGION_NUMRECTS (region);
432 return PIXREGION_RECTS (region);
436 pixman_break (region_type_t *region)
440 region->extents = *pixman_region_empty_box;
441 region->data = pixman_broken_data;
447 pixman_rect_alloc (region_type_t * region,
450 region_data_type_t *data;
455 region->data = alloc_data (n);
458 return pixman_break (region);
460 region->data->numRects = 1;
461 *PIXREGION_BOXPTR (region) = region->extents;
463 else if (!region->data->size)
465 region->data = alloc_data (n);
468 return pixman_break (region);
470 region->data->numRects = 0;
478 n = region->data->numRects;
479 if (n > 500) /* XXX pick numbers out of a hat */
483 n += region->data->numRects;
484 data_size = PIXREGION_SZOF (n);
492 data = (region_data_type_t *)
493 realloc (region->data, PIXREGION_SZOF (n));
497 return pixman_break (region);
502 region->data->size = n;
507 PIXMAN_EXPORT pixman_bool_t
508 PREFIX (_copy) (region_type_t *dst, region_type_t *src)
516 dst->extents = src->extents;
518 if (!src->data || !src->data->size)
521 dst->data = src->data;
525 if (!dst->data || (dst->data->size < src->data->numRects))
529 dst->data = alloc_data (src->data->numRects);
532 return pixman_break (dst);
534 dst->data->size = src->data->numRects;
537 dst->data->numRects = src->data->numRects;
539 memmove ((char *)PIXREGION_BOXPTR (dst), (char *)PIXREGION_BOXPTR (src),
540 dst->data->numRects * sizeof(box_type_t));
545 /*======================================================================
546 * Generic Region Operator
547 *====================================================================*/
550 *-----------------------------------------------------------------------
552 * Attempt to merge the boxes in the current band with those in the
553 * previous one. We are guaranteed that the current band extends to
554 * the end of the rects array. Used only by pixman_op.
557 * The new index for the previous band.
560 * If coalescing takes place:
561 * - rectangles in the previous band will have their y2 fields
563 * - region->data->numRects will be decreased.
565 *-----------------------------------------------------------------------
568 pixman_coalesce (region_type_t * region, /* Region to coalesce */
569 int prev_start, /* Index of start of previous band */
570 int cur_start) /* Index of start of current band */
572 box_type_t *prev_box; /* Current box in previous band */
573 box_type_t *cur_box; /* Current box in current band */
574 int numRects; /* Number rectangles in both bands */
575 int y2; /* Bottom of current band */
578 * Figure out how many rectangles are in the band.
580 numRects = cur_start - prev_start;
581 critical_if_fail (numRects == region->data->numRects - cur_start);
583 if (!numRects) return cur_start;
586 * The bands may only be coalesced if the bottom of the previous
587 * matches the top scanline of the current.
589 prev_box = PIXREGION_BOX (region, prev_start);
590 cur_box = PIXREGION_BOX (region, cur_start);
591 if (prev_box->y2 != cur_box->y1) return cur_start;
594 * Make sure the bands have boxes in the same places. This
595 * assumes that boxes have been added in such a way that they
596 * cover the most area possible. I.e. two boxes in a band must
597 * have some horizontal space between them.
603 if ((prev_box->x1 != cur_box->x1) || (prev_box->x2 != cur_box->x2))
613 * The bands may be merged, so set the bottom y of each box
614 * in the previous band to the bottom y of the current band.
616 numRects = cur_start - prev_start;
617 region->data->numRects -= numRects;
630 /* Quicky macro to avoid trivial reject procedure calls to pixman_coalesce */
632 #define COALESCE(new_reg, prev_band, cur_band) \
635 if (cur_band - prev_band == new_reg->data->numRects - cur_band) \
636 prev_band = pixman_coalesce (new_reg, prev_band, cur_band); \
638 prev_band = cur_band; \
642 *-----------------------------------------------------------------------
643 * pixman_region_append_non_o --
644 * Handle a non-overlapping band for the union and subtract operations.
645 * Just adds the (top/bottom-clipped) rectangles into the region.
646 * Doesn't have to check for subsumption or anything.
652 * region->data->numRects is incremented and the rectangles overwritten
653 * with the rectangles we're passed.
655 *-----------------------------------------------------------------------
657 static inline pixman_bool_t
658 pixman_region_append_non_o (region_type_t * region,
664 box_type_t *next_rect;
667 new_rects = r_end - r;
669 critical_if_fail (y1 < y2);
670 critical_if_fail (new_rects != 0);
672 /* Make sure we have enough space for all rectangles to be added */
673 RECTALLOC (region, new_rects);
674 next_rect = PIXREGION_TOP (region);
675 region->data->numRects += new_rects;
679 critical_if_fail (r->x1 < r->x2);
680 ADDRECT (next_rect, r->x1, y1, r->x2, y2);
688 #define FIND_BAND(r, r_band_end, r_end, ry1) \
692 r_band_end = r + 1; \
693 while ((r_band_end != r_end) && (r_band_end->y1 == ry1)) { \
698 #define APPEND_REGIONS(new_reg, r, r_end) \
702 if ((new_rects = r_end - r)) { \
703 RECTALLOC_BAIL (new_reg, new_rects, bail); \
704 memmove ((char *)PIXREGION_TOP (new_reg), (char *)r, \
705 new_rects * sizeof(box_type_t)); \
706 new_reg->data->numRects += new_rects; \
711 *-----------------------------------------------------------------------
713 * Apply an operation to two regions. Called by pixman_region_union, pixman_region_inverse,
714 * pixman_region_subtract, pixman_region_intersect.... Both regions MUST have at least one
715 * rectangle, and cannot be the same object.
718 * TRUE if successful.
721 * The new region is overwritten.
722 * overlap set to TRUE if overlap_func ever returns TRUE.
725 * The idea behind this function is to view the two regions as sets.
726 * Together they cover a rectangle of area that this function divides
727 * into horizontal bands where points are covered only by one region
728 * or by both. For the first case, the non_overlap_func is called with
729 * each the band and the band's upper and lower extents. For the
730 * second, the overlap_func is called to process the entire band. It
731 * is responsible for clipping the rectangles in the band, though
732 * this function provides the boundaries.
733 * At the end of each band, the new region is coalesced, if possible,
734 * to reduce the number of rectangles in the region.
736 *-----------------------------------------------------------------------
739 typedef pixman_bool_t (*overlap_proc_ptr) (region_type_t *region,
749 pixman_op (region_type_t * new_reg, /* Place to store result */
750 region_type_t * reg1, /* First region in operation */
751 region_type_t * reg2, /* 2d region in operation */
752 overlap_proc_ptr overlap_func, /* Function to call for over-
754 int append_non1, /* Append non-overlapping bands
757 int append_non2, /* Append non-overlapping bands
762 box_type_t *r1; /* Pointer into first region */
763 box_type_t *r2; /* Pointer into 2d region */
764 box_type_t *r1_end; /* End of 1st region */
765 box_type_t *r2_end; /* End of 2d region */
766 int ybot; /* Bottom of intersection */
767 int ytop; /* Top of intersection */
768 region_data_type_t *old_data; /* Old data for new_reg */
769 int prev_band; /* Index of start of
770 * previous band in new_reg */
771 int cur_band; /* Index of start of current
773 box_type_t * r1_band_end; /* End of current band in r1 */
774 box_type_t * r2_band_end; /* End of current band in r2 */
775 int top; /* Top of non-overlapping band */
776 int bot; /* Bottom of non-overlapping band*/
777 int r1y1; /* Temps for r1->y1 and r2->y1 */
783 * Break any region computed from a broken region
785 if (PIXREGION_NAR (reg1) || PIXREGION_NAR (reg2))
786 return pixman_break (new_reg);
790 * set r1, r2, r1_end and r2_end appropriately, save the rectangles
791 * of the destination region until the end in case it's one of
792 * the two source regions, then mark the "new" region empty, allocating
793 * another array of rectangles for it to use.
796 r1 = PIXREGION_RECTS (reg1);
797 new_size = PIXREGION_NUMRECTS (reg1);
798 r1_end = r1 + new_size;
800 numRects = PIXREGION_NUMRECTS (reg2);
801 r2 = PIXREGION_RECTS (reg2);
802 r2_end = r2 + numRects;
804 critical_if_fail (r1 != r1_end);
805 critical_if_fail (r2 != r2_end);
807 old_data = (region_data_type_t *)NULL;
809 if (((new_reg == reg1) && (new_size > 1)) ||
810 ((new_reg == reg2) && (numRects > 1)))
812 old_data = new_reg->data;
813 new_reg->data = pixman_region_empty_data;
816 /* guess at new size */
817 if (numRects > new_size)
823 new_reg->data = pixman_region_empty_data;
824 else if (new_reg->data->size)
825 new_reg->data->numRects = 0;
827 if (new_size > new_reg->data->size)
829 if (!pixman_rect_alloc (new_reg, new_size))
838 * In the upcoming loop, ybot and ytop serve different functions depending
839 * on whether the band being handled is an overlapping or non-overlapping
841 * In the case of a non-overlapping band (only one of the regions
842 * has points in the band), ybot is the bottom of the most recent
843 * intersection and thus clips the top of the rectangles in that band.
844 * ytop is the top of the next intersection between the two regions and
845 * serves to clip the bottom of the rectangles in the current band.
846 * For an overlapping band (where the two regions intersect), ytop clips
847 * the top of the rectangles of both regions and ybot clips the bottoms.
850 ybot = MIN (r1->y1, r2->y1);
853 * prev_band serves to mark the start of the previous band so rectangles
854 * can be coalesced into larger rectangles. qv. pixman_coalesce, above.
855 * In the beginning, there is no previous band, so prev_band == cur_band
856 * (cur_band is set later on, of course, but the first band will always
857 * start at index 0). prev_band and cur_band must be indices because of
858 * the possible expansion, and resultant moving, of the new region's
859 * array of rectangles.
866 * This algorithm proceeds one source-band (as opposed to a
867 * destination band, which is determined by where the two regions
868 * intersect) at a time. r1_band_end and r2_band_end serve to mark the
869 * rectangle after the last one in the current band for their
870 * respective regions.
872 critical_if_fail (r1 != r1_end);
873 critical_if_fail (r2 != r2_end);
875 FIND_BAND (r1, r1_band_end, r1_end, r1y1);
876 FIND_BAND (r2, r2_band_end, r2_end, r2y1);
879 * First handle the band that doesn't intersect, if any.
881 * Note that attention is restricted to one band in the
882 * non-intersecting region at once, so if a region has n
883 * bands between the current position and the next place it overlaps
884 * the other, this entire loop will be passed through n times.
890 top = MAX (r1y1, ybot);
891 bot = MIN (r1->y2, r2y1);
894 cur_band = new_reg->data->numRects;
895 if (!pixman_region_append_non_o (new_reg, r1, r1_band_end, top, bot))
897 COALESCE (new_reg, prev_band, cur_band);
902 else if (r2y1 < r1y1)
906 top = MAX (r2y1, ybot);
907 bot = MIN (r2->y2, r1y1);
911 cur_band = new_reg->data->numRects;
913 if (!pixman_region_append_non_o (new_reg, r2, r2_band_end, top, bot))
916 COALESCE (new_reg, prev_band, cur_band);
927 * Now see if we've hit an intersecting band. The two bands only
928 * intersect if ybot > ytop
930 ybot = MIN (r1->y2, r2->y2);
933 cur_band = new_reg->data->numRects;
935 if (!(*overlap_func)(new_reg,
944 COALESCE (new_reg, prev_band, cur_band);
948 * If we've finished with a band (y2 == ybot) we skip forward
949 * in the region to the next band.
958 while (r1 != r1_end && r2 != r2_end);
961 * Deal with whichever region (if any) still has rectangles left.
963 * We only need to worry about banding and coalescing for the very first
964 * band left. After that, we can just group all remaining boxes,
965 * regardless of how many bands, into one final append to the list.
968 if ((r1 != r1_end) && append_non1)
970 /* Do first non_overlap1Func call, which may be able to coalesce */
971 FIND_BAND (r1, r1_band_end, r1_end, r1y1);
973 cur_band = new_reg->data->numRects;
975 if (!pixman_region_append_non_o (new_reg,
977 MAX (r1y1, ybot), r1->y2))
982 COALESCE (new_reg, prev_band, cur_band);
984 /* Just append the rest of the boxes */
985 APPEND_REGIONS (new_reg, r1_band_end, r1_end);
987 else if ((r2 != r2_end) && append_non2)
989 /* Do first non_overlap2Func call, which may be able to coalesce */
990 FIND_BAND (r2, r2_band_end, r2_end, r2y1);
992 cur_band = new_reg->data->numRects;
994 if (!pixman_region_append_non_o (new_reg,
996 MAX (r2y1, ybot), r2->y2))
1001 COALESCE (new_reg, prev_band, cur_band);
1003 /* Append rest of boxes */
1004 APPEND_REGIONS (new_reg, r2_band_end, r2_end);
1009 if (!(numRects = new_reg->data->numRects))
1011 FREE_DATA (new_reg);
1012 new_reg->data = pixman_region_empty_data;
1014 else if (numRects == 1)
1016 new_reg->extents = *PIXREGION_BOXPTR (new_reg);
1017 FREE_DATA (new_reg);
1018 new_reg->data = (region_data_type_t *)NULL;
1022 DOWNSIZE (new_reg, numRects);
1030 return pixman_break (new_reg);
1034 *-----------------------------------------------------------------------
1035 * pixman_set_extents --
1036 * Reset the extents of a region to what they should be. Called by
1037 * pixman_region_subtract and pixman_region_intersect as they can't
1038 * figure it out along the way or do so easily, as pixman_region_union can.
1044 * The region's 'extents' structure is overwritten.
1046 *-----------------------------------------------------------------------
1049 pixman_set_extents (region_type_t *region)
1051 box_type_t *box, *box_end;
1056 if (!region->data->size)
1058 region->extents.x2 = region->extents.x1;
1059 region->extents.y2 = region->extents.y1;
1063 box = PIXREGION_BOXPTR (region);
1064 box_end = PIXREGION_END (region);
1067 * Since box is the first rectangle in the region, it must have the
1068 * smallest y1 and since box_end is the last rectangle in the region,
1069 * it must have the largest y2, because of banding. Initialize x1 and
1070 * x2 from box and box_end, resp., as good things to initialize them
1073 region->extents.x1 = box->x1;
1074 region->extents.y1 = box->y1;
1075 region->extents.x2 = box_end->x2;
1076 region->extents.y2 = box_end->y2;
1078 critical_if_fail (region->extents.y1 < region->extents.y2);
1080 while (box <= box_end)
1082 if (box->x1 < region->extents.x1)
1083 region->extents.x1 = box->x1;
1084 if (box->x2 > region->extents.x2)
1085 region->extents.x2 = box->x2;
1089 critical_if_fail (region->extents.x1 < region->extents.x2);
1092 /*======================================================================
1093 * Region Intersection
1094 *====================================================================*/
1096 *-----------------------------------------------------------------------
1097 * pixman_region_intersect_o --
1098 * Handle an overlapping band for pixman_region_intersect.
1101 * TRUE if successful.
1104 * Rectangles may be added to the region.
1106 *-----------------------------------------------------------------------
1109 static pixman_bool_t
1110 pixman_region_intersect_o (region_type_t *region,
1112 box_type_t * r1_end,
1114 box_type_t * r2_end,
1121 box_type_t * next_rect;
1123 next_rect = PIXREGION_TOP (region);
1125 critical_if_fail (y1 < y2);
1126 critical_if_fail (r1 != r1_end && r2 != r2_end);
1130 x1 = MAX (r1->x1, r2->x1);
1131 x2 = MIN (r1->x2, r2->x2);
1134 * If there's any overlap between the two rectangles, add that
1135 * overlap to the new region.
1138 NEWRECT (region, next_rect, x1, y1, x2, y2);
1141 * Advance the pointer(s) with the leftmost right side, since the next
1142 * rectangle on that list may still overlap the other region's
1143 * current rectangle.
1154 while ((r1 != r1_end) && (r2 != r2_end));
1159 PIXMAN_EXPORT pixman_bool_t
1160 PREFIX (_intersect) (region_type_t * new_reg,
1161 region_type_t * reg1,
1162 region_type_t * reg2)
1168 /* check for trivial reject */
1169 if (PIXREGION_NIL (reg1) || PIXREGION_NIL (reg2) ||
1170 !EXTENTCHECK (®1->extents, ®2->extents))
1172 /* Covers about 20% of all cases */
1173 FREE_DATA (new_reg);
1174 new_reg->extents.x2 = new_reg->extents.x1;
1175 new_reg->extents.y2 = new_reg->extents.y1;
1176 if (PIXREGION_NAR (reg1) || PIXREGION_NAR (reg2))
1178 new_reg->data = pixman_broken_data;
1183 new_reg->data = pixman_region_empty_data;
1186 else if (!reg1->data && !reg2->data)
1188 /* Covers about 80% of cases that aren't trivially rejected */
1189 new_reg->extents.x1 = MAX (reg1->extents.x1, reg2->extents.x1);
1190 new_reg->extents.y1 = MAX (reg1->extents.y1, reg2->extents.y1);
1191 new_reg->extents.x2 = MIN (reg1->extents.x2, reg2->extents.x2);
1192 new_reg->extents.y2 = MIN (reg1->extents.y2, reg2->extents.y2);
1194 FREE_DATA (new_reg);
1196 new_reg->data = (region_data_type_t *)NULL;
1198 else if (!reg2->data && SUBSUMES (®2->extents, ®1->extents))
1200 return PREFIX (_copy) (new_reg, reg1);
1202 else if (!reg1->data && SUBSUMES (®1->extents, ®2->extents))
1204 return PREFIX (_copy) (new_reg, reg2);
1206 else if (reg1 == reg2)
1208 return PREFIX (_copy) (new_reg, reg1);
1212 /* General purpose intersection */
1213 int overlap; /* result ignored */
1215 if (!pixman_op (new_reg, reg1, reg2, pixman_region_intersect_o, FALSE, FALSE,
1221 pixman_set_extents (new_reg);
1228 #define MERGERECT(r) \
1233 /* Merge with current rectangle */ \
1242 /* Add current rectangle, start new one */ \
1243 NEWRECT (region, next_rect, x1, y1, x2, y2); \
1250 /*======================================================================
1252 *====================================================================*/
1255 *-----------------------------------------------------------------------
1256 * pixman_region_union_o --
1257 * Handle an overlapping band for the union operation. Picks the
1258 * left-most rectangle each time and merges it into the region.
1261 * TRUE if successful.
1264 * region is overwritten.
1265 * overlap is set to TRUE if any boxes overlap.
1267 *-----------------------------------------------------------------------
1269 static pixman_bool_t
1270 pixman_region_union_o (region_type_t *region,
1272 box_type_t * r1_end,
1274 box_type_t * r2_end,
1279 box_type_t *next_rect;
1280 int x1; /* left and right side of current union */
1283 critical_if_fail (y1 < y2);
1284 critical_if_fail (r1 != r1_end && r2 != r2_end);
1286 next_rect = PIXREGION_TOP (region);
1288 /* Start off current rectangle */
1289 if (r1->x1 < r2->x1)
1301 while (r1 != r1_end && r2 != r2_end)
1303 if (r1->x1 < r2->x1)
1309 /* Finish off whoever (if any) is left */
1316 while (r1 != r1_end);
1318 else if (r2 != r2_end)
1324 while (r2 != r2_end);
1327 /* Add current rectangle */
1328 NEWRECT (region, next_rect, x1, y1, x2, y2);
1333 PIXMAN_EXPORT pixman_bool_t
1334 PREFIX(_intersect_rect) (region_type_t *dest,
1335 region_type_t *source,
1338 unsigned int height)
1340 region_type_t region;
1343 region.extents.x1 = x;
1344 region.extents.y1 = y;
1345 region.extents.x2 = x + width;
1346 region.extents.y2 = y + height;
1348 return PREFIX(_intersect) (dest, source, ®ion);
1351 /* Convenience function for performing union of region with a
1354 PIXMAN_EXPORT pixman_bool_t
1355 PREFIX (_union_rect) (region_type_t *dest,
1356 region_type_t *source,
1360 unsigned int height)
1362 region_type_t region;
1364 region.extents.x1 = x;
1365 region.extents.y1 = y;
1366 region.extents.x2 = x + width;
1367 region.extents.y2 = y + height;
1369 if (!GOOD_RECT (®ion.extents))
1371 if (BAD_RECT (®ion.extents))
1372 _pixman_log_error (FUNC, "Invalid rectangle passed");
1373 return PREFIX (_copy) (dest, source);
1378 return PREFIX (_union) (dest, source, ®ion);
1381 PIXMAN_EXPORT pixman_bool_t
1382 PREFIX (_union) (region_type_t *new_reg,
1383 region_type_t *reg1,
1384 region_type_t *reg2)
1386 int overlap; /* result ignored */
1388 /* Return TRUE if some overlap
1389 * between reg1, reg2
1395 /* checks all the simple cases */
1398 * Region 1 and 2 are the same
1401 return PREFIX (_copy) (new_reg, reg1);
1406 if (PIXREGION_NIL (reg1))
1408 if (PIXREGION_NAR (reg1))
1409 return pixman_break (new_reg);
1411 if (new_reg != reg2)
1412 return PREFIX (_copy) (new_reg, reg2);
1420 if (PIXREGION_NIL (reg2))
1422 if (PIXREGION_NAR (reg2))
1423 return pixman_break (new_reg);
1425 if (new_reg != reg1)
1426 return PREFIX (_copy) (new_reg, reg1);
1432 * Region 1 completely subsumes region 2
1434 if (!reg1->data && SUBSUMES (®1->extents, ®2->extents))
1436 if (new_reg != reg1)
1437 return PREFIX (_copy) (new_reg, reg1);
1443 * Region 2 completely subsumes region 1
1445 if (!reg2->data && SUBSUMES (®2->extents, ®1->extents))
1447 if (new_reg != reg2)
1448 return PREFIX (_copy) (new_reg, reg2);
1453 if (!pixman_op (new_reg, reg1, reg2, pixman_region_union_o, TRUE, TRUE, &overlap))
1456 new_reg->extents.x1 = MIN (reg1->extents.x1, reg2->extents.x1);
1457 new_reg->extents.y1 = MIN (reg1->extents.y1, reg2->extents.y1);
1458 new_reg->extents.x2 = MAX (reg1->extents.x2, reg2->extents.x2);
1459 new_reg->extents.y2 = MAX (reg1->extents.y2, reg2->extents.y2);
1466 /*======================================================================
1467 * Batch Rectangle Union
1468 *====================================================================*/
1470 #define EXCHANGE_RECTS(a, b) \
1474 rects[a] = rects[b]; \
1488 /* Always called with numRects > 1 */
1494 if (rects[0].y1 > rects[1].y1 ||
1495 (rects[0].y1 == rects[1].y1 && rects[0].x1 > rects[1].x1))
1497 EXCHANGE_RECTS (0, 1);
1503 /* Choose partition element, stick in location 0 */
1504 EXCHANGE_RECTS (0, numRects >> 1);
1508 /* Partition array */
1521 while (i != numRects && (r->y1 < y1 || (r->y1 == y1 && r->x1 < x1)))
1530 while (y1 < r->y1 || (y1 == r->y1 && x1 < r->x1));
1533 EXCHANGE_RECTS (i, j);
1537 /* Move partition element back to middle */
1538 EXCHANGE_RECTS (0, j);
1541 if (numRects - j - 1 > 1)
1542 quick_sort_rects (&rects[j + 1], numRects - j - 1);
1546 while (numRects > 1);
1550 *-----------------------------------------------------------------------
1551 * pixman_region_validate --
1553 * Take a ``region'' which is a non-y-x-banded random collection of
1554 * rectangles, and compute a nice region which is the union of all the
1558 * TRUE if successful.
1561 * The passed-in ``region'' may be modified.
1562 * overlap set to TRUE if any retangles overlapped,
1566 * Step 1. Sort the rectangles into ascending order with primary key y1
1567 * and secondary key x1.
1569 * Step 2. Split the rectangles into the minimum number of proper y-x
1570 * banded regions. This may require horizontally merging
1571 * rectangles, and vertically coalescing bands. With any luck,
1572 * this step in an identity transformation (ala the Box widget),
1573 * or a coalescing into 1 box (ala Menus).
1575 * Step 3. Merge the separate regions down to a single region by calling
1576 * pixman_region_union. Maximize the work each pixman_region_union call does by using
1579 *-----------------------------------------------------------------------
1582 static pixman_bool_t
1583 validate (region_type_t * badreg,
1586 /* Descriptor for regions under construction in Step 2. */
1594 region_info_t stack_regions[64];
1596 int numRects; /* Original numRects for badreg */
1597 region_info_t *ri; /* Array of current regions */
1598 int num_ri; /* Number of entries used in ri */
1599 int size_ri; /* Number of entries available in ri */
1600 int i; /* Index into rects */
1601 int j; /* Index into ri */
1602 region_info_t *rit; /* &ri[j] */
1603 region_type_t *reg; /* ri[j].reg */
1604 box_type_t *box; /* Current box in rects */
1605 box_type_t *ri_box; /* Last box in ri[j].reg */
1606 region_type_t *hreg; /* ri[j_half].reg */
1607 pixman_bool_t ret = TRUE;
1616 numRects = badreg->data->numRects;
1619 if (PIXREGION_NAR (badreg))
1625 if (badreg->extents.x1 < badreg->extents.x2)
1627 if ((numRects) == 1)
1630 badreg->data = (region_data_type_t *) NULL;
1634 DOWNSIZE (badreg, numRects);
1642 /* Step 1: Sort the rects array into ascending (y1, x1) order */
1643 quick_sort_rects (PIXREGION_BOXPTR (badreg), numRects);
1645 /* Step 2: Scatter the sorted array into the minimum number of regions */
1647 /* Set up the first region to be the first rectangle in badreg */
1648 /* Note that step 2 code will never overflow the ri[0].reg rects array */
1650 size_ri = sizeof (stack_regions) / sizeof (stack_regions[0]);
1652 ri[0].prev_band = 0;
1654 ri[0].reg = *badreg;
1655 box = PIXREGION_BOXPTR (&ri[0].reg);
1656 ri[0].reg.extents = *box;
1657 ri[0].reg.data->numRects = 1;
1658 badreg->extents = *pixman_region_empty_box;
1659 badreg->data = pixman_region_empty_data;
1661 /* Now scatter rectangles into the minimum set of valid regions. If the
1662 * next rectangle to be added to a region would force an existing rectangle
1663 * in the region to be split up in order to maintain y-x banding, just
1664 * forget it. Try the next region. If it doesn't fit cleanly into any
1665 * region, make a new one.
1668 for (i = numRects; --i > 0;)
1671 /* Look for a region to append box to */
1672 for (j = num_ri, rit = ri; --j >= 0; rit++)
1675 ri_box = PIXREGION_END (reg);
1677 if (box->y1 == ri_box->y1 && box->y2 == ri_box->y2)
1679 /* box is in same band as ri_box. Merge or append it */
1680 if (box->x1 <= ri_box->x2)
1682 /* Merge it with ri_box */
1683 if (box->x1 < ri_box->x2)
1686 if (box->x2 > ri_box->x2)
1687 ri_box->x2 = box->x2;
1691 RECTALLOC_BAIL (reg, 1, bail);
1692 *PIXREGION_TOP (reg) = *box;
1693 reg->data->numRects++;
1696 goto next_rect; /* So sue me */
1698 else if (box->y1 >= ri_box->y2)
1700 /* Put box into new band */
1701 if (reg->extents.x2 < ri_box->x2)
1702 reg->extents.x2 = ri_box->x2;
1704 if (reg->extents.x1 > box->x1)
1705 reg->extents.x1 = box->x1;
1707 COALESCE (reg, rit->prev_band, rit->cur_band);
1708 rit->cur_band = reg->data->numRects;
1709 RECTALLOC_BAIL (reg, 1, bail);
1710 *PIXREGION_TOP (reg) = *box;
1711 reg->data->numRects++;
1715 /* Well, this region was inappropriate. Try the next one. */
1718 /* Uh-oh. No regions were appropriate. Create a new one. */
1719 if (size_ri == num_ri)
1723 /* Oops, allocate space for new region information */
1726 data_size = size_ri * sizeof(region_info_t);
1727 if (data_size / size_ri != sizeof(region_info_t))
1730 if (ri == stack_regions)
1732 rit = malloc (data_size);
1735 memcpy (rit, ri, num_ri * sizeof (region_info_t));
1739 rit = (region_info_t *) realloc (ri, data_size);
1749 rit->reg.extents = *box;
1750 rit->reg.data = (region_data_type_t *)NULL;
1752 /* MUST force allocation */
1753 if (!pixman_rect_alloc (&rit->reg, (i + num_ri) / num_ri))
1759 /* Make a final pass over each region in order to COALESCE and set
1760 * extents.x2 and extents.y2
1762 for (j = num_ri, rit = ri; --j >= 0; rit++)
1765 ri_box = PIXREGION_END (reg);
1766 reg->extents.y2 = ri_box->y2;
1768 if (reg->extents.x2 < ri_box->x2)
1769 reg->extents.x2 = ri_box->x2;
1771 COALESCE (reg, rit->prev_band, rit->cur_band);
1773 if (reg->data->numRects == 1) /* keep unions happy below */
1776 reg->data = (region_data_type_t *)NULL;
1780 /* Step 3: Union all regions into a single region */
1783 int half = num_ri / 2;
1784 for (j = num_ri & 1; j < (half + (num_ri & 1)); j++)
1787 hreg = &ri[j + half].reg;
1789 if (!pixman_op (reg, reg, hreg, pixman_region_union_o, TRUE, TRUE, overlap))
1792 if (hreg->extents.x1 < reg->extents.x1)
1793 reg->extents.x1 = hreg->extents.x1;
1795 if (hreg->extents.y1 < reg->extents.y1)
1796 reg->extents.y1 = hreg->extents.y1;
1798 if (hreg->extents.x2 > reg->extents.x2)
1799 reg->extents.x2 = hreg->extents.x2;
1801 if (hreg->extents.y2 > reg->extents.y2)
1802 reg->extents.y2 = hreg->extents.y2;
1813 *badreg = ri[0].reg;
1815 if (ri != stack_regions)
1822 for (i = 0; i < num_ri; i++)
1823 FREE_DATA (&ri[i].reg);
1825 if (ri != stack_regions)
1828 return pixman_break (badreg);
1831 /*======================================================================
1832 * Region Subtraction
1833 *====================================================================*/
1836 *-----------------------------------------------------------------------
1837 * pixman_region_subtract_o --
1838 * Overlapping band subtraction. x1 is the left-most point not yet
1842 * TRUE if successful.
1845 * region may have rectangles added to it.
1847 *-----------------------------------------------------------------------
1850 static pixman_bool_t
1851 pixman_region_subtract_o (region_type_t * region,
1853 box_type_t * r1_end,
1855 box_type_t * r2_end,
1860 box_type_t * next_rect;
1865 critical_if_fail (y1 < y2);
1866 critical_if_fail (r1 != r1_end && r2 != r2_end);
1868 next_rect = PIXREGION_TOP (region);
1875 * Subtrahend entirely to left of minuend: go to next subtrahend.
1879 else if (r2->x1 <= x1)
1882 * Subtrahend preceeds minuend: nuke left edge of minuend.
1888 * Minuend completely covered: advance to next minuend and
1889 * reset left fence to edge of new minuend.
1898 * Subtrahend now used up since it doesn't extend beyond
1904 else if (r2->x1 < r1->x2)
1907 * Left part of subtrahend covers part of minuend: add uncovered
1908 * part of minuend to region and skip to next subtrahend.
1910 critical_if_fail (x1 < r2->x1);
1911 NEWRECT (region, next_rect, x1, y1, r2->x1, y2);
1917 * Minuend used up: advance to new...
1926 * Subtrahend used up
1934 * Minuend used up: add any remaining piece before advancing.
1937 NEWRECT (region, next_rect, x1, y1, r1->x2, y2);
1945 while ((r1 != r1_end) && (r2 != r2_end));
1948 * Add remaining minuend rectangles to region.
1950 while (r1 != r1_end)
1952 critical_if_fail (x1 < r1->x2);
1954 NEWRECT (region, next_rect, x1, y1, r1->x2, y2);
1964 *-----------------------------------------------------------------------
1965 * pixman_region_subtract --
1966 * Subtract reg_s from reg_m and leave the result in reg_d.
1967 * S stands for subtrahend, M for minuend and D for difference.
1970 * TRUE if successful.
1973 * reg_d is overwritten.
1975 *-----------------------------------------------------------------------
1977 PIXMAN_EXPORT pixman_bool_t
1978 PREFIX (_subtract) (region_type_t *reg_d,
1979 region_type_t *reg_m,
1980 region_type_t *reg_s)
1982 int overlap; /* result ignored */
1988 /* check for trivial rejects */
1989 if (PIXREGION_NIL (reg_m) || PIXREGION_NIL (reg_s) ||
1990 !EXTENTCHECK (®_m->extents, ®_s->extents))
1992 if (PIXREGION_NAR (reg_s))
1993 return pixman_break (reg_d);
1995 return PREFIX (_copy) (reg_d, reg_m);
1997 else if (reg_m == reg_s)
2000 reg_d->extents.x2 = reg_d->extents.x1;
2001 reg_d->extents.y2 = reg_d->extents.y1;
2002 reg_d->data = pixman_region_empty_data;
2007 /* Add those rectangles in region 1 that aren't in region 2,
2008 do yucky substraction for overlaps, and
2009 just throw away rectangles in region 2 that aren't in region 1 */
2010 if (!pixman_op (reg_d, reg_m, reg_s, pixman_region_subtract_o, TRUE, FALSE, &overlap))
2014 * Can't alter reg_d's extents before we call pixman_op because
2015 * it might be one of the source regions and pixman_op depends
2016 * on the extents of those regions being unaltered. Besides, this
2017 * way there's no checking against rectangles that will be nuked
2018 * due to coalescing, so we have to examine fewer rectangles.
2020 pixman_set_extents (reg_d);
2025 /*======================================================================
2027 *====================================================================*/
2030 *-----------------------------------------------------------------------
2031 * pixman_region_inverse --
2032 * Take a region and a box and return a region that is everything
2033 * in the box but not in the region. The careful reader will note
2034 * that this is the same as subtracting the region from the box...
2040 * new_reg is overwritten.
2042 *-----------------------------------------------------------------------
2045 PIXMAN_EXPORT PREFIX (_inverse) (region_type_t *new_reg, /* Destination region */
2046 region_type_t *reg1, /* Region to invert */
2047 box_type_t * inv_rect) /* Bounding box for inversion */
2049 region_type_t inv_reg; /* Quick and dirty region made from the
2051 int overlap; /* result ignored */
2056 /* check for trivial rejects */
2057 if (PIXREGION_NIL (reg1) || !EXTENTCHECK (inv_rect, ®1->extents))
2059 if (PIXREGION_NAR (reg1))
2060 return pixman_break (new_reg);
2062 new_reg->extents = *inv_rect;
2063 FREE_DATA (new_reg);
2064 new_reg->data = (region_data_type_t *)NULL;
2069 /* Add those rectangles in region 1 that aren't in region 2,
2070 * do yucky substraction for overlaps, and
2071 * just throw away rectangles in region 2 that aren't in region 1
2073 inv_reg.extents = *inv_rect;
2074 inv_reg.data = (region_data_type_t *)NULL;
2075 if (!pixman_op (new_reg, &inv_reg, reg1, pixman_region_subtract_o, TRUE, FALSE, &overlap))
2079 * Can't alter new_reg's extents before we call pixman_op because
2080 * it might be one of the source regions and pixman_op depends
2081 * on the extents of those regions being unaltered. Besides, this
2082 * way there's no checking against rectangles that will be nuked
2083 * due to coalescing, so we have to examine fewer rectangles.
2085 pixman_set_extents (new_reg);
2090 /* In time O(log n), locate the first box whose y2 is greater than y.
2091 * Return @end if no such box exists.
2094 find_box_for_y (box_type_t *begin, box_type_t *end, int y)
2101 if (end - begin == 1)
2109 mid = begin + (end - begin) / 2;
2112 /* If no box is found in [begin, mid], the function
2113 * will return @mid, which is then known to be the
2116 return find_box_for_y (begin, mid, y);
2120 return find_box_for_y (mid, end, y);
2125 * rect_in(region, rect)
2126 * This routine takes a pointer to a region and a pointer to a box
2127 * and determines if the box is outside/inside/partly inside the region.
2129 * The idea is to travel through the list of rectangles trying to cover the
2130 * passed box with them. Anytime a piece of the rectangle isn't covered
2131 * by a band of rectangles, part_out is set TRUE. Any time a rectangle in
2132 * the region covers part of the box, part_in is set TRUE. The process ends
2133 * when either the box has been completely covered (we reached a band that
2134 * doesn't overlap the box, part_in is TRUE and part_out is false), the
2135 * box has been partially covered (part_in == part_out == TRUE -- because of
2136 * the banding, the first time this is true we know the box is only
2137 * partially in the region) or is outside the region (we reached a band
2138 * that doesn't overlap the box at all and part_in is false)
2140 pixman_region_overlap_t
2141 PIXMAN_EXPORT PREFIX (_contains_rectangle) (region_type_t * region,
2145 box_type_t * pbox_end;
2146 int part_in, part_out;
2152 numRects = PIXREGION_NUMRECTS (region);
2154 /* useful optimization */
2155 if (!numRects || !EXTENTCHECK (®ion->extents, prect))
2156 return(PIXMAN_REGION_OUT);
2160 /* We know that it must be PIXMAN_REGION_IN or PIXMAN_REGION_PART */
2161 if (SUBSUMES (®ion->extents, prect))
2162 return(PIXMAN_REGION_IN);
2164 return(PIXMAN_REGION_PART);
2170 /* (x,y) starts at upper left of rect, moving to the right and down */
2174 /* can stop when both part_out and part_in are TRUE, or we reach prect->y2 */
2175 for (pbox = PIXREGION_BOXPTR (region), pbox_end = pbox + numRects;
2179 /* getting up to speed or skipping remainder of band */
2182 if ((pbox = find_box_for_y (pbox, pbox_end, y)) == pbox_end)
2188 part_out = TRUE; /* missed part of rectangle above */
2189 if (part_in || (pbox->y1 >= prect->y2))
2191 y = pbox->y1; /* x guaranteed to be == prect->x1 */
2195 continue; /* not far enough over yet */
2199 part_out = TRUE; /* missed part of rectangle to left */
2204 if (pbox->x1 < prect->x2)
2206 part_in = TRUE; /* definitely overlap */
2211 if (pbox->x2 >= prect->x2)
2213 y = pbox->y2; /* finished with this band */
2216 x = prect->x1; /* reset x out to left again */
2221 * Because boxes in a band are maximal width, if the first box
2222 * to overlap the rectangle doesn't completely cover it in that
2223 * band, the rectangle must be partially out, since some of it
2224 * will be uncovered in that band. part_in will have been set true
2235 return PIXMAN_REGION_PART;
2237 return PIXMAN_REGION_IN;
2241 return PIXMAN_REGION_OUT;
2245 /* PREFIX(_translate) (region, x, y)
2246 * translates in place
2250 PREFIX (_translate) (region_type_t *region, int x, int y)
2252 overflow_int_t x1, x2, y1, y2;
2257 region->extents.x1 = x1 = region->extents.x1 + x;
2258 region->extents.y1 = y1 = region->extents.y1 + y;
2259 region->extents.x2 = x2 = region->extents.x2 + x;
2260 region->extents.y2 = y2 = region->extents.y2 + y;
2262 if (((x1 - PIXMAN_REGION_MIN) | (y1 - PIXMAN_REGION_MIN) | (PIXMAN_REGION_MAX - x2) | (PIXMAN_REGION_MAX - y2)) >= 0)
2264 if (region->data && (nbox = region->data->numRects))
2266 for (pbox = PIXREGION_BOXPTR (region); nbox--; pbox++)
2277 if (((x2 - PIXMAN_REGION_MIN) | (y2 - PIXMAN_REGION_MIN) | (PIXMAN_REGION_MAX - x1) | (PIXMAN_REGION_MAX - y1)) <= 0)
2279 region->extents.x2 = region->extents.x1;
2280 region->extents.y2 = region->extents.y1;
2282 region->data = pixman_region_empty_data;
2286 if (x1 < PIXMAN_REGION_MIN)
2287 region->extents.x1 = PIXMAN_REGION_MIN;
2288 else if (x2 > PIXMAN_REGION_MAX)
2289 region->extents.x2 = PIXMAN_REGION_MAX;
2291 if (y1 < PIXMAN_REGION_MIN)
2292 region->extents.y1 = PIXMAN_REGION_MIN;
2293 else if (y2 > PIXMAN_REGION_MAX)
2294 region->extents.y2 = PIXMAN_REGION_MAX;
2296 if (region->data && (nbox = region->data->numRects))
2298 box_type_t * pbox_out;
2300 for (pbox_out = pbox = PIXREGION_BOXPTR (region); nbox--; pbox++)
2302 pbox_out->x1 = x1 = pbox->x1 + x;
2303 pbox_out->y1 = y1 = pbox->y1 + y;
2304 pbox_out->x2 = x2 = pbox->x2 + x;
2305 pbox_out->y2 = y2 = pbox->y2 + y;
2307 if (((x2 - PIXMAN_REGION_MIN) | (y2 - PIXMAN_REGION_MIN) |
2308 (PIXMAN_REGION_MAX - x1) | (PIXMAN_REGION_MAX - y1)) <= 0)
2310 region->data->numRects--;
2314 if (x1 < PIXMAN_REGION_MIN)
2315 pbox_out->x1 = PIXMAN_REGION_MIN;
2316 else if (x2 > PIXMAN_REGION_MAX)
2317 pbox_out->x2 = PIXMAN_REGION_MAX;
2319 if (y1 < PIXMAN_REGION_MIN)
2320 pbox_out->y1 = PIXMAN_REGION_MIN;
2321 else if (y2 > PIXMAN_REGION_MAX)
2322 pbox_out->y2 = PIXMAN_REGION_MAX;
2327 if (pbox_out != pbox)
2329 if (region->data->numRects == 1)
2331 region->extents = *PIXREGION_BOXPTR (region);
2333 region->data = (region_data_type_t *)NULL;
2337 pixman_set_extents (region);
2346 PREFIX (_reset) (region_type_t *region, box_type_t *box)
2350 critical_if_fail (GOOD_RECT (box));
2352 region->extents = *box;
2356 region->data = NULL;
2359 /* box is "return" value */
2361 PREFIX (_contains_point) (region_type_t * region,
2365 box_type_t *pbox, *pbox_end;
2369 numRects = PIXREGION_NUMRECTS (region);
2371 if (!numRects || !INBOX (®ion->extents, x, y))
2377 *box = region->extents;
2382 pbox = PIXREGION_BOXPTR (region);
2383 pbox_end = pbox + numRects;
2385 pbox = find_box_for_y (pbox, pbox_end, y);
2387 for (;pbox != pbox_end; pbox++)
2389 if ((y < pbox->y1) || (x < pbox->x1))
2390 break; /* missed it */
2393 continue; /* not there yet */
2405 PREFIX (_not_empty) (region_type_t * region)
2409 return(!PIXREGION_NIL (region));
2412 PIXMAN_EXPORT box_type_t *
2413 PREFIX (_extents) (region_type_t * region)
2417 return(®ion->extents);
2421 * Clip a list of scanlines to a region. The caller has allocated the
2422 * space. FSorted is non-zero if the scanline origins are in ascending order.
2424 * returns the number of new, clipped scanlines.
2427 PIXMAN_EXPORT pixman_bool_t
2428 PREFIX (_selfcheck) (region_type_t *reg)
2432 if ((reg->extents.x1 > reg->extents.x2) ||
2433 (reg->extents.y1 > reg->extents.y2))
2438 numRects = PIXREGION_NUMRECTS (reg);
2441 return ((reg->extents.x1 == reg->extents.x2) &&
2442 (reg->extents.y1 == reg->extents.y2) &&
2443 (reg->data->size || (reg->data == pixman_region_empty_data)));
2445 else if (numRects == 1)
2447 return (!reg->data);
2451 box_type_t * pbox_p, * pbox_n;
2454 pbox_p = PIXREGION_RECTS (reg);
2456 box.y2 = pbox_p[numRects - 1].y2;
2457 pbox_n = pbox_p + 1;
2459 for (i = numRects; --i > 0; pbox_p++, pbox_n++)
2461 if ((pbox_n->x1 >= pbox_n->x2) ||
2462 (pbox_n->y1 >= pbox_n->y2))
2467 if (pbox_n->x1 < box.x1)
2468 box.x1 = pbox_n->x1;
2470 if (pbox_n->x2 > box.x2)
2471 box.x2 = pbox_n->x2;
2473 if ((pbox_n->y1 < pbox_p->y1) ||
2474 ((pbox_n->y1 == pbox_p->y1) &&
2475 ((pbox_n->x1 < pbox_p->x2) || (pbox_n->y2 != pbox_p->y2))))
2481 return ((box.x1 == reg->extents.x1) &&
2482 (box.x2 == reg->extents.x2) &&
2483 (box.y1 == reg->extents.y1) &&
2484 (box.y2 == reg->extents.y2));
2488 PIXMAN_EXPORT pixman_bool_t
2489 PREFIX (_init_rects) (region_type_t *region,
2490 const box_type_t *boxes, int count)
2496 /* if it's 1, then we just want to set the extents, so call
2497 * the existing method. */
2500 PREFIX (_init_rect) (region,
2503 boxes[0].x2 - boxes[0].x1,
2504 boxes[0].y2 - boxes[0].y1);
2508 PREFIX (_init) (region);
2510 /* if it's 0, don't call pixman_rect_alloc -- 0 rectangles is
2511 * a special case, and causing pixman_rect_alloc would cause
2512 * us to leak memory (because the 0-rect case should be the
2513 * static pixman_region_empty_data data).
2518 if (!pixman_rect_alloc (region, count))
2521 rects = PIXREGION_RECTS (region);
2523 /* Copy in the rects */
2524 memcpy (rects, boxes, sizeof(box_type_t) * count);
2525 region->data->numRects = count;
2527 /* Eliminate empty and malformed rectangles */
2530 for (i = 0; i < count; ++i)
2532 box_type_t *box = &rects[i];
2534 if (box->x1 >= box->x2 || box->y1 >= box->y2)
2536 else if (displacement)
2537 rects[i - displacement] = rects[i];
2540 region->data->numRects -= displacement;
2542 /* If eliminating empty rectangles caused there
2543 * to be only 0 or 1 rectangles, deal with that.
2545 if (region->data->numRects == 0)
2548 PREFIX (_init) (region);
2553 if (region->data->numRects == 1)
2555 region->extents = rects[0];
2558 region->data = NULL;
2566 region->extents.x1 = region->extents.x2 = 0;
2568 return validate (region, &i);
2571 #define READ(_ptr) (*(_ptr))
2573 static inline box_type_t *
2574 bitmap_addrect (region_type_t *reg,
2576 box_type_t **first_rect,
2580 if ((rx1 < rx2) && (ry1 < ry2) &&
2581 (!(reg->data->numRects &&
2582 ((r-1)->y1 == ry1) && ((r-1)->y2 == ry2) &&
2583 ((r-1)->x1 <= rx1) && ((r-1)->x2 >= rx2))))
2585 if (reg->data->numRects == reg->data->size)
2587 if (!pixman_rect_alloc (reg, 1))
2589 *first_rect = PIXREGION_BOXPTR(reg);
2590 r = *first_rect + reg->data->numRects;
2596 reg->data->numRects++;
2597 if (r->x1 < reg->extents.x1)
2598 reg->extents.x1 = r->x1;
2599 if (r->x2 > reg->extents.x2)
2600 reg->extents.x2 = r->x2;
2606 /* Convert bitmap clip mask into clipping region.
2607 * First, goes through each line and makes boxes by noting the transitions
2608 * from 0 to 1 and 1 to 0.
2609 * Then it coalesces the current line with the previous if they have boxes
2610 * at the same X coordinates.
2611 * Stride is in number of uint32_t per line.
2614 PREFIX (_init_from_image) (region_type_t *region,
2615 pixman_image_t *image)
2617 uint32_t mask0 = 0xffffffff & ~SCREEN_SHIFT_RIGHT(0xffffffff, 1);
2618 box_type_t *first_rect, *rects, *prect_line_start;
2619 box_type_t *old_rect, *new_rect;
2620 uint32_t *pw, w, *pw_line, *pw_line_end;
2621 int irect_prev_start, irect_line_start;
2622 int h, base, rx1 = 0, crects;
2624 pixman_bool_t in_box, same;
2625 int width, height, stride;
2627 PREFIX(_init) (region);
2629 critical_if_fail (region->data);
2631 return_if_fail (image->type == BITS);
2632 return_if_fail (image->bits.format == PIXMAN_a1);
2634 pw_line = pixman_image_get_data (image);
2635 width = pixman_image_get_width (image);
2636 height = pixman_image_get_height (image);
2637 stride = pixman_image_get_stride (image) / 4;
2639 first_rect = PIXREGION_BOXPTR(region);
2642 region->extents.x1 = width - 1;
2643 region->extents.x2 = 0;
2644 irect_prev_start = -1;
2645 for (h = 0; h < height; h++)
2649 irect_line_start = rects - first_rect;
2651 /* If the Screen left most bit of the word is set, we're starting in
2653 if (READ(pw) & mask0)
2663 /* Process all words which are fully in the pixmap */
2664 pw_line_end = pw + (width >> 5);
2665 for (base = 0; pw < pw_line_end; base += 32)
2678 for (ib = 0; ib < 32; ib++)
2680 /* If the Screen left most bit of the word is set, we're
2696 rects = bitmap_addrect (region, rects, &first_rect,
2697 rx1, h, base + ib, h + 1);
2703 /* Shift the word VISUALLY left one. */
2704 w = SCREEN_SHIFT_LEFT(w, 1);
2710 /* Process final partial word on line */
2712 for (ib = 0; ib < (width & 31); ib++)
2714 /* If the Screen left most bit of the word is set, we're
2730 rects = bitmap_addrect(region, rects, &first_rect,
2731 rx1, h, base + ib, h + 1);
2737 /* Shift the word VISUALLY left one. */
2738 w = SCREEN_SHIFT_LEFT(w, 1);
2741 /* If scanline ended with last bit set, end the box */
2744 rects = bitmap_addrect(region, rects, &first_rect,
2745 rx1, h, base + (width & 31), h + 1);
2749 /* if all rectangles on this line have the same x-coords as
2750 * those on the previous line, then add 1 to all the previous y2s and
2751 * throw away all the rectangles from this line
2754 if (irect_prev_start != -1)
2756 crects = irect_line_start - irect_prev_start;
2758 crects == ((rects - first_rect) - irect_line_start))
2760 old_rect = first_rect + irect_prev_start;
2761 new_rect = prect_line_start = first_rect + irect_line_start;
2763 while (old_rect < prect_line_start)
2765 if ((old_rect->x1 != new_rect->x1) ||
2766 (old_rect->x2 != new_rect->x2))
2776 old_rect = first_rect + irect_prev_start;
2777 while (old_rect < prect_line_start)
2783 region->data->numRects -= crects;
2788 irect_prev_start = irect_line_start;
2790 if (!region->data->numRects)
2792 region->extents.x1 = region->extents.x2 = 0;
2796 region->extents.y1 = PIXREGION_BOXPTR(region)->y1;
2797 region->extents.y2 = PIXREGION_END(region)->y2;
2798 if (region->data->numRects == 1)
2800 free (region->data);
2801 region->data = NULL;