WebSVN – Kolibri OS – Diff – /programs/develop/libraries/pixman/pixman-region.c

 #endif
+static const box_type_t PREFIX (_empty_box_) = { 0, 0, 0, 0 };
+static const region_data_type_t PREFIX (_empty_data_) = { 0, 0 };
+#if defined (__llvm__) && !defined (__clang__)
-static const box_type_t PREFIX (_empty_box_) = { 0, 0, 0, 0 };
+static const volatile region_data_type_t PREFIX (_broken_data_) = { 0, 0 };
+#else
-static const region_data_type_t PREFIX (_empty_data_) = { 0, 0 };
+static const region_data_type_t PREFIX (_broken_data_) = { 0, 0 };
-static const region_data_type_t PREFIX (_broken_data_) = { 0, 0 };
+#endif
 static box_type_t *pixman_region_empty_box =
 	return 0;
     return size + sizeof(region_data_type_t);
 }
-static void *
+static region_data_type_t *
 alloc_data (size_t n)
+{
 					   box_type_t *   r1,
 					   box_type_t *   r1_end,
 					   box_type_t *   r2,
 					   box_type_t *   r2_end,
 					   int            y1,
-					   int            y2,
+					   int            y2);
-					   int *          overlap);
 static pixman_bool_t
 pixman_op (region_type_t *  new_reg,               /* Place to store result	    */
 	   region_type_t *  reg1,                  /* First region in operation     */
 	   region_type_t *  reg2,                  /* 2d region in operation        */
 	   overlap_proc_ptr overlap_func,          /* Function to call for over-
 						    * lapping bands		    */
 	   int              append_non1,           /* Append non-overlapping bands
 						    * in region 1 ?
 						    */
-	   int              append_non2,           /* Append non-overlapping bands
+	   int              append_non2            /* Append non-overlapping bands
 						    * in region 2 ?
 						    */
 	   int *            overlap)
+{
     box_type_t *r1;                 /* Pointer into first region     */
     box_type_t *r2;                 /* Pointer into 2d region	     */
     box_type_t *r1_end;             /* End of 1st region	     */
     if (new_size > new_reg->data->size)
+    {
         if (!pixman_rect_alloc (new_reg, new_size))
-        {
             if (old_data)
-		free (old_data);
+            free (old_data);
             return FALSE;
+	}
             cur_band = new_reg->data->numRects;
             if (!(*overlap_func)(new_reg,
                                  r1, r1_band_end,
                                  r2, r2_band_end,
-                                 ytop, ybot,
-                                 overlap))
+                                 ytop, ybot))
+	    {
 		goto bail;
+	    }
         /* Append rest of boxes */
         APPEND_REGIONS (new_reg, r2_band_end, r2_end);
-    }
+    }
     if (old_data)
-	free (old_data);
+    free (old_data);
+    }
     return TRUE;
 bail:
-    if (old_data)
+bail:
-	free (old_data);
+    free (old_data);
                            box_type_t *   r1,
                            box_type_t *   r1_end,
                            box_type_t *   r2,
                            box_type_t *   r2_end,
                            int            y1,
-                           int            y2,
+                           int            y2)
-                           int *          overlap)
+{
     int x1;
     int x2;
     box_type_t *        next_rect;
         return PREFIX (_copy) (new_reg, reg1);
+    }
     else
+    {
         /* General purpose intersection */
-        int overlap; /* result ignored */
-        if (!pixman_op (new_reg, reg1, reg2, pixman_region_intersect_o, FALSE, FALSE,
-                        &overlap))
         if (!pixman_op (new_reg, reg1, reg2, pixman_region_intersect_o, FALSE, FALSE))
-	    return FALSE;
 	    return FALSE;
         pixman_set_extents (new_reg);
     do									\
     {									\
         if (r->x1 <= x2)						\
 	{								\
             /* Merge with current rectangle */				\
-            if (r->x1 < x2)						\
-		*overlap = TRUE;					\
-									\
             if (x2 < r->x2)						\
 		x2 = r->x2;						\
 	}								\
 	else								\
 	{								\
 		       box_type_t *   r1,
 		       box_type_t *   r1_end,
 		       box_type_t *   r2,
 		       box_type_t *   r2_end,
 		       int            y1,
-		       int            y2,
+		       int            y2)
-		       int *          overlap)
+{
     box_type_t *next_rect;
     int x1;            /* left and right side of current union */
     int x2;
 PIXMAN_EXPORT pixman_bool_t
 PREFIX (_union) (region_type_t *new_reg,
                  region_type_t *reg1,
                  region_type_t *reg2)
+{
-    int overlap; /* result ignored */
     /* Return TRUE if some overlap
      * between reg1, reg2
      */
     GOOD (reg1);
     GOOD (reg2);
 	    return PREFIX (_copy) (new_reg, reg2);
 	return TRUE;
     }
-    if (!pixman_op (new_reg, reg1, reg2, pixman_region_union_o, TRUE, TRUE, &overlap))
+    if (!pixman_op (new_reg, reg1, reg2, pixman_region_union_o, TRUE, TRUE))
 	return FALSE;
             do
+            {
                 r++;
                 i++;
+	    }
-            while (i != numRects && (r->y1 < y1 || (r->y1 == y1 && r->x1 < x1)))
+	    while (i != numRects && (r->y1 < y1 || (r->y1 == y1 && r->x1 < x1)));
-		;
 	    r = &(rects[j]);
             do
+            {
+ *
  *-----------------------------------------------------------------------
  */
 static pixman_bool_t
-validate (region_type_t * badreg,
-          int *           overlap)
+validate (region_type_t * badreg)
+{
     /* Descriptor for regions under construction  in Step 2. */
     typedef struct
+    {
     box_type_t *box;                /* Current box in rects		    */
     box_type_t *ri_box;             /* Last box in ri[j].reg		    */
     region_type_t *hreg;            /* ri[j_half].reg			    */
     pixman_bool_t ret = TRUE;
     *overlap = FALSE;
     if (!badreg->data)
+    {
         GOOD (badreg);
         return TRUE;
+            {
                 /* box is in same band as ri_box.  Merge or append it */
                 if (box->x1 <= ri_box->x2)
+                {
                     /* Merge it with ri_box */
-                    if (box->x1 < ri_box->x2)
-			*overlap = TRUE;
                     if (box->x2 > ri_box->x2)
 			ri_box->x2 = box->x2;
+		}
                 else
+                {
         for (j = num_ri & 1; j < (half + (num_ri & 1)); j++)
+        {
             reg = &ri[j].reg;
             hreg = &ri[j + half].reg;
-            if (!pixman_op (reg, reg, hreg, pixman_region_union_o, TRUE, TRUE, overlap))
+            if (!pixman_op (reg, reg, hreg, pixman_region_union_o, TRUE, TRUE))
 		ret = FALSE;
 			  box_type_t *    r1,
 			  box_type_t *    r1_end,
 			  box_type_t *    r2,
 			  box_type_t *    r2_end,
 			  int             y1,
-			  int             y2,
+			  int             y2)
-			  int *           overlap)
+{
     box_type_t *        next_rect;
     int x1;
             r2++;
+	}
         else if (r2->x1 <= x1)
+        {
             /*
-	     * Subtrahend preceeds minuend: nuke left edge of minuend.
+	     * Subtrahend precedes minuend: nuke left edge of minuend.
 	     */
             x1 = r2->x2;
             if (x1 >= r1->x2)
+            {
                 /*
 PIXMAN_EXPORT pixman_bool_t
 PREFIX (_subtract) (region_type_t *reg_d,
                     region_type_t *reg_m,
                     region_type_t *reg_s)
+{
-    int overlap; /* result ignored */
     GOOD (reg_m);
     GOOD (reg_s);
     GOOD (reg_d);
         return TRUE;
+    }
     /* Add those rectangles in region 1 that aren't in region 2,
-       do yucky substraction for overlaps, and
+       do yucky subtraction for overlaps, and
        just throw away rectangles in region 2 that aren't in region 1 */
-    if (!pixman_op (reg_d, reg_m, reg_s, pixman_region_subtract_o, TRUE, FALSE, &overlap))
+    if (!pixman_op (reg_d, reg_m, reg_s, pixman_region_subtract_o, TRUE, FALSE))
 	return FALSE;
  * Side Effects:
  *	new_reg is overwritten.
+ *
  *-----------------------------------------------------------------------
  */
-pixman_bool_t
+PIXMAN_EXPORT pixman_bool_t
-PIXMAN_EXPORT PREFIX (_inverse) (region_type_t *new_reg,  /* Destination region */
+PREFIX (_inverse) (region_type_t *new_reg,  /* Destination region */
-                                 region_type_t *reg1,     /* Region to invert */
+		   region_type_t *reg1,     /* Region to invert */
-                                 box_type_t *   inv_rect) /* Bounding box for inversion */
+		   box_type_t *   inv_rect) /* Bounding box for inversion */
+{
     region_type_t inv_reg; /* Quick and dirty region made from the
 			    * bounding box */
-    int overlap;           /* result ignored */
     GOOD (reg1);
     GOOD (new_reg);
     /* check for trivial rejects */
         return TRUE;
+    }
     /* Add those rectangles in region 1 that aren't in region 2,
-     * do yucky substraction for overlaps, and
+     * do yucky subtraction for overlaps, and
      * just throw away rectangles in region 2 that aren't in region 1
      */
     inv_reg.extents = *inv_rect;
     inv_reg.data = (region_data_type_t *)NULL;
-    if (!pixman_op (new_reg, &inv_reg, reg1, pixman_region_subtract_o, TRUE, FALSE, &overlap))
+    if (!pixman_op (new_reg, &inv_reg, reg1, pixman_region_subtract_o, TRUE, FALSE))
 	return FALSE;
     pixman_set_extents (new_reg);
     GOOD (new_reg);
     return TRUE;
+}
+/* In time O(log n), locate the first box whose y2 is greater than y.
+ * Return @end if no such box exists.
+ */
+static box_type_t *
+find_box_for_y (box_type_t *begin, box_type_t *end, int y)
+{
+    box_type_t *mid;
+    if (end == begin)
+	return end;
+    if (end - begin == 1)
+    {
+	if (begin->y2 > y)
+	    return begin;
+	else
+	    return end;
+    }
+    mid = begin + (end - begin) / 2;
+    if (mid->y2 > y)
+    {
+	/* If no box is found in [begin, mid], the function
+	 * will return @mid, which is then known to be the
+	 * correct answer.
+	 */
+	return find_box_for_y (begin, mid, y);
+    }
+    else
+    {
+	return find_box_for_y (mid, end, y);
+    }
+}
 /*
  *   rect_in(region, rect)
  *   This routine takes a pointer to a region and a pointer to a box
  *   and determines if the box is outside/inside/partly inside the region.
  *   box has been partially covered (part_in == part_out == TRUE -- because of
  *   the banding, the first time this is true we know the box is only
  *   partially in the region) or is outside the region (we reached a band
  *   that doesn't overlap the box at all and part_in is false)
  */
-pixman_region_overlap_t
+PIXMAN_EXPORT pixman_region_overlap_t
-PIXMAN_EXPORT PREFIX (_contains_rectangle) (region_type_t *  region,
+PREFIX (_contains_rectangle) (region_type_t *  region,
-                                            box_type_t *     prect)
+			      box_type_t *     prect)
+{
     box_type_t *     pbox;
     box_type_t *     pbox_end;
     int part_in, part_out;
     /* can stop when both part_out and part_in are TRUE, or we reach prect->y2 */
     for (pbox = PIXREGION_BOXPTR (region), pbox_end = pbox + numRects;
-         pbox != pbox_end;
+	 pbox != pbox_end;
-         pbox++)
+	 pbox++)
+    {
+	/* getting up to speed or skipping remainder of band */
-        if (pbox->y2 <= y)
+	if (pbox->y2 <= y)
+	{
-	    continue;   /* getting up to speed or skipping remainder of band */
+	    if ((pbox = find_box_for_y (pbox, pbox_end, y)) == pbox_end)
+		break;
+	}
         if (pbox->y1 > y)
+        {
             part_out = TRUE;     /* missed part of rectangle above */
     FREE_DATA (region);
     region->data = NULL;
+}
+PIXMAN_EXPORT void
+PREFIX (_clear) (region_type_t *region)
+{
+    GOOD (region);
+    FREE_DATA (region);
+    region->extents = *pixman_region_empty_box;
+    region->data = pixman_region_empty_data;
+}
 /* box is "return" value */
 PIXMAN_EXPORT int
 PREFIX (_contains_point) (region_type_t * region,
 	    *box = region->extents;
         return(TRUE);
     }
-    for (pbox = PIXREGION_BOXPTR (region), pbox_end = pbox + numRects;
-	 pbox != pbox_end;
-	 pbox++)
-    {
+    pbox = PIXREGION_BOXPTR (region);
+    pbox_end = pbox + numRects;
+    pbox = find_box_for_y (pbox, pbox_end, y);
         if (y >= pbox->y2)
-	    continue;           /* not there yet */
+    for (;pbox != pbox_end; pbox++)
+    {
         if ((y < pbox->y1) || (x < pbox->x1))
+    }
     /* Validate */
     region->extents.x1 = region->extents.x2 = 0;
-    return validate (region, &i);
+    return validate (region);
+}
     if ((rx1 < rx2) && (ry1 < ry2) &&
 	(!(reg->data->numRects &&
 	   ((r-1)->y1 == ry1) && ((r-1)->y2 == ry2) &&
 	   ((r-1)->x1 <= rx1) && ((r-1)->x2 >= rx2))))
+    {
-	if (!reg->data ||
-	    reg->data->numRects == reg->data->size)
+	if (reg->data->numRects == reg->data->size)
+	{
 	    if (!pixman_rect_alloc (reg, 1))
 		return NULL;
 	    *first_rect = PIXREGION_BOXPTR(reg);
 	    r = *first_rect + reg->data->numRects;
     pixman_bool_t in_box, same;
     int width, height, stride;
+    PREFIX(_init) (region);
-    PREFIX(_init) (region);
+    critical_if_fail (region->data);
     return_if_fail (image->type == BITS);
     return_if_fail (image->bits.format == PIXMAN_a1);

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixman/pixman-region.c – Rev 1891 → 3931