Clipping optimisations; avoid needless clipping device.

When filling a mask, check any clipping path given; if it trivially
includes all the mask, then don't bother creating a clipping
device. If it trivially excludes, then don't bother plotting at all.
If the bbox partially covers the area, then reduce the area
of the mask.

This gives a 6-8% speedup of customer 532's test files; they are
filling a mask with a halftone, which breaks down into lots of
short run, 1 pixel high rectangles. Avoiding the clipping device
avoids lots of function call overhead.

3 files changed, 75 insertions, 6 deletions

diff --git a/gs/base/gdevdbit.c b/gs/base/gdevdbit.c
index 99140d5f2..9631517a1 100644
--- a/gs/base/gdevdbit.c
+++ b/gs/base/gdevdbit.c
@@ -326,14 +326,44 @@ gx_default_fill_mask(gx_device * orig_dev,
                      const gx_drawing_color * pdcolor, int depth,
                      gs_logical_operation_t lop, const gx_clip_path * pcpath)
 {
-    gx_device *dev;
+    gx_device *dev = orig_dev;
     gx_device_clip cdev;
 
-    if (pcpath != 0) {
-        gx_make_clip_device_on_stack(&cdev, pcpath, orig_dev);
-        dev = (gx_device *) & cdev;
-    } else
-        dev = orig_dev;
+    if (w == 0 || h == 0)
+        return 0;
+
+    if (pcpath != 0)
+    {
+        gs_fixed_rect rect;
+        int tmp;
+
+        rect.p.x = int2fixed(x);
+        rect.p.y = int2fixed(y);
+        rect.q.x = int2fixed(x+w);
+        rect.q.y = int2fixed(y+h);
+        dev = gx_make_clip_device_on_stack_if_needed(&cdev, pcpath, dev, &rect);
+        if (dev == NULL)
+            return 0;
+        /* Clip region if possible */
+        tmp = fixed2int(rect.p.x);
+        if (tmp > x)
+        {
+            dx += tmp-x;
+            x = tmp;
+        }
+        tmp = fixed2int(rect.q.x);
+        if (tmp < x+w)
+            w = tmp-x;
+        tmp = fixed2int(rect.p.y);
+        if (tmp > y)
+        {
+            data += (tmp-y) * raster;
+            y = tmp;
+        }
+        tmp = fixed2int(rect.q.y);
+        if (tmp < y+h)
+            h = tmp-y;
+    }
     if (depth > 1) {
         /****** CAN'T DO ROP OR HALFTONE WITH ALPHA ******/
         return (*dev_proc(dev, copy_alpha))
diff --git a/gs/base/gxclip.c b/gs/base/gxclip.c
index 0350d1eb8..4504d9f26 100644
--- a/gs/base/gxclip.c
+++ b/gs/base/gxclip.c
@@ -135,6 +135,44 @@ gx_make_clip_device_on_stack(gx_device_clip * dev, const gx_clip_path *pcpath, g
     /* There is no finalization for device on stack so no rc increment */
     (*dev_proc(dev, open_device)) ((gx_device *)dev);
 }
+
+gx_device *
+gx_make_clip_device_on_stack_if_needed(gx_device_clip * dev, const gx_clip_path *pcpath, gx_device *target, gs_fixed_rect *rect)
+{
+    if (pcpath->inner_box.p.x <= rect->p.x && pcpath->inner_box.p.y <= rect->p.y &&
+        pcpath->inner_box.q.x >= rect->q.x && pcpath->inner_box.q.y >= rect->q.y)
+    {
+        /* Area is trivially included. No need for clip. */
+        return target;
+    }
+    else
+    {
+        /* Reduce area if possible */
+        if (rect->p.x < pcpath->outer_box.p.x)
+            rect->p.x = pcpath->outer_box.p.x;
+        if (rect->q.x > pcpath->outer_box.q.x)
+            rect->q.x = pcpath->outer_box.q.x;
+        if (rect->p.y < pcpath->outer_box.p.y)
+            rect->p.y = pcpath->outer_box.p.y;
+        if (rect->q.y > pcpath->outer_box.q.y)
+            rect->q.y = pcpath->outer_box.q.y;
+        /* Check for area being trivially clipped away. */
+        if (rect->p.x >= rect->q.x || rect->p.y >= rect->q.y)
+            return NULL;
+    }
+    gx_device_init((gx_device *)dev, (const gx_device *)&gs_clip_device, NULL, true);
+    dev->list = *gx_cpath_list(pcpath);
+    dev->translation.x = 0;
+    dev->translation.y = 0;
+    dev->HWResolution[0] = target->HWResolution[0];
+    dev->HWResolution[1] = target->HWResolution[1];
+    dev->sgr = target->sgr;
+    dev->target = target;
+    dev->graphics_type_tag = target->graphics_type_tag; /* initialize to same as target */
+    /* There is no finalization for device on stack so no rc increment */
+    (*dev_proc(dev, open_device)) ((gx_device *)dev);
+    return (gx_device *)dev;
+}
 void
 gx_make_clip_device_in_heap(gx_device_clip * dev, const gx_clip_path *pcpath, gx_device *target,
                               gs_memory_t *mem)
diff --git a/gs/base/gxcpath.h b/gs/base/gxcpath.h
index 6bf6bf8da..6eb34d338 100644
--- a/gs/base/gxcpath.h
+++ b/gs/base/gxcpath.h
@@ -110,6 +110,7 @@ extern_st(st_device_clip);
     "gx_device_clip", device_clip_enum_ptrs, device_clip_reloc_ptrs,\
     gx_device_finalize)
 void gx_make_clip_device_on_stack(gx_device_clip * dev, const gx_clip_path *pcpath, gx_device *target);
+gx_device *gx_make_clip_device_on_stack_if_needed(gx_device_clip * dev, const gx_clip_path *pcpath, gx_device *target, gs_fixed_rect *rect);
 void gx_make_clip_device_in_heap(gx_device_clip * dev, const gx_clip_path *pcpath, gx_device *target,
                               gs_memory_t *mem);