Remove get_bits in favour of get_bits_rectangle.

30 files changed, 314 insertions, 339 deletions

diff --git a/base/gdevdbit.c b/base/gdevdbit.c
index c4612f7c3..dbe893876 100644
--- a/base/gdevdbit.c
+++ b/base/gdevdbit.c
@@ -355,6 +355,7 @@ gx_default_copy_alpha(gx_device * dev, const byte * data, int data_x,
         int code = 0;
         gx_color_value color_cv[GX_DEVICE_COLOR_MAX_COMPONENTS];
         int ry, lx;
+        gs_int_rect rect;
 
         fit_copy(dev, data, data_x, raster, id, x, y, width, height);
         row = data;
@@ -366,6 +367,8 @@ gx_default_copy_alpha(gx_device * dev, const byte * data, int data_x,
             goto out;
         }
         (*dev_proc(dev, decode_color)) (dev, color, color_cv);
+        rect.p.x = 0;
+        rect.q.x = dev->width;
         for (ry = y; ry < y + height; row += raster, ++ry) {
             byte *line;
             int sx, rx;
@@ -374,10 +377,23 @@ gx_default_copy_alpha(gx_device * dev, const byte * data, int data_x,
             int l_dbit = 0;
             byte l_dbyte = ((l_dbit) ? (byte)(*(l_dptr) & (0xff00 >> (l_dbit))) : 0);
             int l_xprev = x;
-
-            code = (*dev_proc(dev, get_bits)) (dev, ry, lin, &line);
+            gs_get_bits_params_t params;
+
+            params.options = (GB_ALIGN_ANY |
+                              (GB_RETURN_COPY | GB_RETURN_POINTER) |
+                              GB_OFFSET_0 |
+                              GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                              GB_COLORS_NATIVE | GB_ALPHA_NONE);
+            params.x_offset = 0;
+            params.raster = bitmap_raster(dev->width * dev->color_info.depth);
+            params.data[0] = lin;
+            rect.p.y = ry;
+            rect.q.y = ry+1;
+            code = (*dev_proc(dev, get_bits_rectangle))(dev, &rect,
+                                                        &params, NULL);
             if (code < 0)
                 break;
+            line = params.data[0];
             lx = x;
             for (sx = data_x, rx = x; sx < data_x + width; ++sx, ++rx) {
                 gx_color_index previous = gx_no_color_index;
diff --git a/base/gdevdflt.c b/base/gdevdflt.c
index e083b1d43..1ef443e32 100644
--- a/base/gdevdflt.c
+++ b/base/gdevdflt.c
@@ -596,7 +596,6 @@ gx_device_fill_in_procs(register gx_device * dev)
     /* NOT fill_rectangle */
     fill_dev_proc(dev, copy_mono, gx_default_copy_mono);
     fill_dev_proc(dev, copy_color, gx_default_copy_color);
-    fill_dev_proc(dev, get_bits, gx_default_get_bits);
     fill_dev_proc(dev, get_params, gx_default_get_params);
     fill_dev_proc(dev, put_params, gx_default_put_params);
     /* see below for map_cmyk_color */
@@ -1221,7 +1220,6 @@ int gx_copy_device_procs(gx_device *dest, const gx_device *src, const gx_device
     set_dev_proc(dest, fill_rectangle, dev_proc(&prototype, fill_rectangle));
     set_dev_proc(dest, copy_mono, dev_proc(&prototype, copy_mono));
     set_dev_proc(dest, copy_color, dev_proc(&prototype, copy_color));
-    set_dev_proc(dest, get_bits, dev_proc(&prototype, get_bits));
     set_dev_proc(dest, get_params, dev_proc(&prototype, get_params));
     set_dev_proc(dest, put_params, dev_proc(&prototype, put_params));
     set_dev_proc(dest, map_cmyk_color, dev_proc(&prototype, map_cmyk_color));
diff --git a/base/gdevdgbr.c b/base/gdevdgbr.c
index ec2414fd2..ccb33f10a 100644
--- a/base/gdevdgbr.c
+++ b/base/gdevdgbr.c
@@ -24,41 +24,6 @@
 #include "gdevmem.h"
 #include "gxdevsop.h"
 
-int
-gx_no_get_bits(gx_device * dev, int y, byte * data, byte ** actual_data)
-{
-    return_error(gs_error_unknownerror);
-}
-int
-gx_default_get_bits(gx_device * dev, int y, byte * data, byte ** actual_data)
-{	/*
-         * Hand off to get_bits_rectangle, being careful to avoid a
-         * possible recursion loop.
-         */
-    dev_proc_get_bits((*save_get_bits)) = dev_proc(dev, get_bits);
-    gs_int_rect rect;
-    gs_get_bits_params_t params;
-    int code;
-
-    rect.p.x = 0, rect.p.y = y;
-    rect.q.x = dev->width, rect.q.y = y + 1;
-    params.options =
-        (actual_data ? GB_RETURN_POINTER : 0) | GB_RETURN_COPY |
-        (GB_ALIGN_STANDARD | GB_OFFSET_0 | GB_RASTER_STANDARD |
-    /* No depth specified, we always use native colors. */
-         GB_PACKING_CHUNKY | GB_COLORS_NATIVE | GB_ALPHA_NONE);
-    params.x_offset = 0;
-    params.raster = bitmap_raster(dev->width * dev->color_info.depth);
-    params.data[0] = data;
-    set_dev_proc(dev, get_bits, gx_no_get_bits);
-    code = (*dev_proc(dev, get_bits_rectangle))
-        (dev, &rect, &params, NULL);
-    if (actual_data)
-        *actual_data = params.data[0];
-    set_dev_proc(dev, get_bits, save_get_bits);
-    return code;
-}
-
 /*
  * Determine whether we can satisfy a request by simply using the stored
  * representation.  dev is used only for color_info.{num_components, depth}.
@@ -653,151 +618,71 @@ int
 gx_default_get_bits_rectangle(gx_device * dev, const gs_int_rect * prect,
                        gs_get_bits_params_t * params, gs_int_rect ** unread)
 {
-    dev_proc_get_bits_rectangle((*save_get_bits_rectangle)) =
-        dev_proc(dev, get_bits_rectangle);
     int depth = dev->color_info.depth;
-    uint min_raster = (dev->width * depth + 7) >> 3;
     gs_get_bits_options_t options = params->options;
     int code;
+    /* Do the transfer row-by-row using a buffer. */
+    int x = prect->p.x, w = prect->q.x - x;
+    int bits_per_pixel = depth;
+    byte *row;
 
-    /* Avoid a recursion loop. */
-    set_dev_proc(dev, get_bits_rectangle, gx_no_get_bits_rectangle);
-    /*
-     * If the parameters are right, try to call get_bits directly.  Note
-     * that this may fail if a device only implements get_bits_rectangle
-     * (not get_bits) for a limited set of options.  Note also that this
-     * must handle the case of the recursive call from within
-     * get_bits_rectangle (see below): because of this, and only because
-     * of this, it must handle partial scan lines.
-     */
-    if (prect->q.y == prect->p.y + 1 &&
-        !(~options &
-          (GB_RETURN_COPY | GB_PACKING_CHUNKY | GB_COLORS_NATIVE)) &&
-        (options & (GB_ALIGN_STANDARD | GB_ALIGN_ANY)) &&
-        ((options & (GB_OFFSET_0 | GB_OFFSET_ANY)) ||
-         ((options & GB_OFFSET_SPECIFIED) && params->x_offset == 0)) &&
-        ((options & (GB_RASTER_STANDARD | GB_RASTER_ANY)) ||
-         ((options & GB_RASTER_SPECIFIED) &&
-          params->raster >= min_raster)) &&
-        unread == NULL
-        ) {
-        byte *data = params->data[0];
-        byte *row = data;
-
-        if (!(prect->p.x == 0 && prect->q.x == dev->width)) {
-            /* Allocate an intermediate row buffer. */
-            row = gs_alloc_bytes(dev->memory, min_raster,
-                                 "gx_default_get_bits_rectangle");
-
-            if (row == 0) {
-                code = gs_note_error(gs_error_VMerror);
-                goto ret;
-            }
-        }
-        code = (*dev_proc(dev, get_bits)) (dev, prect->p.y, row,
-                (params->options & GB_RETURN_POINTER) ? &params->data[0]
-                                                      : NULL );
-        if (code >= 0) {
-            if (row != data) {
-                if (prect->p.x == 0 && params->data[0] != row
-                    && params->options & GB_RETURN_POINTER) {
-                    /*
-                     * get_bits returned an appropriate pointer: we can
-                     * avoid doing any copying.
-                     */
-                    DO_NOTHING;
-                } else {
-                    /* Copy the partial row into the supplied buffer. */
-                    int width_bits = (prect->q.x - prect->p.x) * depth;
-                    gx_device_memory tdev;
-
-                    tdev.width = width_bits;
-                    tdev.height = 1;
-                    tdev.line_ptrs = &tdev.base;
-                    tdev.base = data;
-                    tdev.raster = bitmap_raster(width_bits);
-                    code = mem_mono_copy_mono((gx_device *) & tdev,
-                         (params->options & GB_RETURN_POINTER) ? params->data[0] : row,
-                         prect->p.x * depth,
-                         min_raster, gx_no_bitmap_id, 0, 0, width_bits, 1,
-                         (gx_color_index) 0, (gx_color_index) 1);
-                    params->data[0] = data;
-                }
-                gs_free_object(dev->memory, row,
-                               "gx_default_get_bits_rectangle");
-            }
-            params->options =
-                GB_ALIGN_STANDARD | GB_OFFSET_0 | GB_PACKING_CHUNKY |
-                GB_ALPHA_NONE | GB_COLORS_NATIVE | GB_RASTER_STANDARD |
-                (params->data[0] == data ? GB_RETURN_COPY : GB_RETURN_POINTER);
-            goto ret;
-        }
-    } {
-        /* Do the transfer row-by-row using a buffer. */
-        int x = prect->p.x, w = prect->q.x - x;
-        int bits_per_pixel = depth;
-        byte *row;
-
-        if (options & GB_COLORS_STANDARD_ALL) {
-            /*
-             * Make sure the row buffer can hold the standard color
-             * representation, in case the device decides to use it.
-             */
-            int bpc = GB_OPTIONS_MAX_DEPTH(options);
-            int nc =
-            (options & GB_COLORS_CMYK ? 4 :
-             options & GB_COLORS_RGB ? 3 : 1) +
-            (options & (GB_ALPHA_ALL - GB_ALPHA_NONE) ? 1 : 0);
-            int bpp = bpc * nc;
-
-            if (bpp > bits_per_pixel)
-                bits_per_pixel = bpp;
-        }
-        row = gs_alloc_bytes(dev->memory, (bits_per_pixel * w + 7) >> 3,
-                             "gx_default_get_bits_rectangle");
-        if (row == 0) {
-            code = gs_note_error(gs_error_VMerror);
-        } else {
-            uint dev_raster = gx_device_raster(dev, true);
-            uint raster =
-            (options & GB_RASTER_SPECIFIED ? params->raster :
-             options & GB_ALIGN_STANDARD ? bitmap_raster(depth * w) :
-             (depth * w + 7) >> 3);
-            gs_int_rect rect;
-            gs_get_bits_params_t copy_params;
-            gs_get_bits_options_t copy_options =
+    if (options & GB_COLORS_STANDARD_ALL) {
+        /*
+         * Make sure the row buffer can hold the standard color
+         * representation, in case the device decides to use it.
+         */
+        int bpc = GB_OPTIONS_MAX_DEPTH(options);
+        int nc = (options & GB_COLORS_CMYK ? 4 :
+                  options & GB_COLORS_RGB ? 3 : 1) +
+                 (options & (GB_ALPHA_ALL - GB_ALPHA_NONE) ? 1 : 0);
+        int bpp = bpc * nc;
+
+        if (bpp > bits_per_pixel)
+            bits_per_pixel = bpp;
+    }
+    row = gs_alloc_bytes(dev->memory, (bits_per_pixel * w + 7) >> 3,
+                         "gx_default_get_bits_rectangle");
+    if (row == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+    } else {
+        uint dev_raster = gx_device_raster(dev, true);
+        uint raster =
+               (options & GB_RASTER_SPECIFIED ? params->raster :
+                options & GB_ALIGN_STANDARD ? bitmap_raster(depth * w) :
+                (depth * w + 7) >> 3);
+        gs_int_rect rect;
+        gs_get_bits_params_t copy_params;
+        gs_get_bits_options_t copy_options =
                 (GB_ALIGN_STANDARD | GB_ALIGN_ANY) |
                 (GB_RETURN_COPY | GB_RETURN_POINTER) |
                 (GB_OFFSET_0 | GB_OFFSET_ANY) |
                 (GB_RASTER_STANDARD | GB_RASTER_ANY) | GB_PACKING_CHUNKY |
                 GB_COLORS_NATIVE | (options & (GB_DEPTH_ALL | GB_COLORS_ALL)) |
                 GB_ALPHA_ALL;
-            byte *dest = params->data[0];
-            int y;
-
-            rect.p.x = x, rect.q.x = x + w;
-            code = 0;
-            for (y = prect->p.y; y < prect->q.y; ++y) {
-                rect.p.y = y, rect.q.y = y + 1;
-                copy_params.options = copy_options;
-                copy_params.data[0] = row;
-                code = (*save_get_bits_rectangle)
+        byte *dest = params->data[0];
+        int y;
+
+        rect.p.x = x, rect.q.x = x + w;
+        code = 0;
+        for (y = prect->p.y; y < prect->q.y; ++y) {
+            rect.p.y = y, rect.q.y = y + 1;
+            copy_params.options = copy_options;
+            copy_params.data[0] = row;
+            code = (*dev_proc(dev, get_bits_rectangle))
                     (dev, &rect, &copy_params, NULL);
-                if (code < 0)
-                    break;
-                if (copy_params.options & GB_OFFSET_0)
-                    copy_params.x_offset = 0;
-                params->data[0] = dest + (y - prect->p.y) * raster;
-                code = gx_get_bits_copy(dev, copy_params.x_offset, w, 1,
-                                        params, &copy_params,
-                                        copy_params.data[0], dev_raster);
-                if (code < 0)
-                    break;
-            }
-            gs_free_object(dev->memory, row, "gx_default_get_bits_rectangle");
-            params->data[0] = dest;
+            if (code < 0)
+                break;
+            if (copy_params.options & GB_OFFSET_0)
+                copy_params.x_offset = 0;
+            params->data[0] = dest + (y - prect->p.y) * raster;
+            code = gx_get_bits_copy(dev, copy_params.x_offset, w, 1,
+                                    params, &copy_params,
+                                    copy_params.data[0], dev_raster);
+            if (code < 0)
+                break;
         }
+        gs_free_object(dev->memory, row, "gx_default_get_bits_rectangle");
+        params->data[0] = dest;
     }
-  ret:set_dev_proc(dev, get_bits_rectangle, save_get_bits_rectangle);
     return (code < 0 ? code : 0);
 }
diff --git a/base/gdevepo.c b/base/gdevepo.c
index 914fa32d9..45b00b39a 100644
--- a/base/gdevepo.c
+++ b/base/gdevepo.c
@@ -68,8 +68,8 @@ static dev_proc_begin_typed_image(epo_begin_typed_image);
 static dev_proc_stroke_path(epo_stroke_path);
 static dev_proc_copy_mono(epo_copy_mono);
 static dev_proc_copy_color(epo_copy_color);
-static dev_proc_get_bits(epo_get_bits);
 static dev_proc_copy_alpha(epo_copy_alpha);
+static dev_proc_get_bits_rectangle(epo_get_bits_rectangle);
 static dev_proc_strip_tile_rectangle(epo_strip_tile_rectangle);
 static dev_proc_strip_copy_rop2(epo_strip_copy_rop2);
 static dev_proc_copy_planes(epo_copy_planes);
@@ -445,8 +445,8 @@ void epo_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, epo_fill_rectangle);
     set_dev_proc(dev, copy_mono, epo_copy_mono);
     set_dev_proc(dev, copy_color, epo_copy_color);
-    set_dev_proc(dev, get_bits, epo_get_bits);
     set_dev_proc(dev, copy_alpha, epo_copy_alpha);
+    set_dev_proc(dev, get_bits_rectangle, epo_get_bits_rectangle);
     set_dev_proc(dev, fill_path, epo_fill_path);
     set_dev_proc(dev, stroke_path, epo_stroke_path);
     set_dev_proc(dev, fill_mask, epo_fill_mask);
@@ -516,13 +516,14 @@ int epo_copy_color(gx_device *dev, const byte *data, int data_x, int raster, gx_
     return dev_proc(dev, copy_color)(dev, data, data_x, raster, id, x, y, width, height);
 }
 
-int epo_get_bits(gx_device *dev, int y, byte *data, byte **actual_data)
+int epo_get_bits_rectangle(gx_device *dev, const gs_int_rect *prect,
+                           gs_get_bits_params_t *params, gs_int_rect **unread)
 {
     int code = epo_handle_erase_page(dev);
 
     if (code != 0)
         return code;
-    return dev_proc(dev, get_bits)(dev, y, data, actual_data);
+    return dev_proc(dev, get_bits_rectangle)(dev, prect, params, unread);
 }
 
 int epo_copy_alpha(gx_device *dev, const byte *data, int data_x,
diff --git a/base/gdevflp.c b/base/gdevflp.c
index 967c005ec..8abc168f4 100644
--- a/base/gdevflp.c
+++ b/base/gdevflp.c
@@ -62,7 +62,7 @@ static dev_proc_close_device(flp_close_device);
 static dev_proc_fill_rectangle(flp_fill_rectangle);
 static dev_proc_copy_mono(flp_copy_mono);
 static dev_proc_copy_color(flp_copy_color);
-static dev_proc_get_bits(flp_get_bits);
+static dev_proc_get_bits_rectangle(flp_get_bits_rectangle);
 static dev_proc_get_params(flp_put_params);
 static dev_proc_get_alpha_bits(flp_get_alpha_bits);
 static dev_proc_copy_alpha(flp_copy_alpha);
@@ -393,18 +393,6 @@ int flp_copy_color(gx_device *dev, const byte *data, int data_x, int raster, gx_
     return 0;
 }
 
-int flp_get_bits(gx_device *dev, int y, byte *data, byte **actual_data)
-{
-    int code = SkipPage(dev);
-
-    if (code < 0)
-        return code;
-    if (!code)
-        return default_subclass_get_bits(dev, y, data, actual_data);
-
-    return gx_default_get_bits(dev, y, data, actual_data);
-}
-
 static void
 flp_rc_free_pages_list(gs_memory_t * mem, void *ptr_in, client_name_t cname)
 {
@@ -1151,7 +1139,6 @@ flp_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, flp_fill_rectangle);
     set_dev_proc(dev, copy_mono, flp_copy_mono);
     set_dev_proc(dev, copy_color, flp_copy_color);
-    set_dev_proc(dev, get_bits, flp_get_bits);
     set_dev_proc(dev, put_params, flp_put_params);
     set_dev_proc(dev, get_alpha_bits, flp_get_alpha_bits);
     set_dev_proc(dev, copy_alpha, flp_copy_alpha);
diff --git a/base/gdevmem.c b/base/gdevmem.c
index aa63caf19..01c3a93e2 100644
--- a/base/gdevmem.c
+++ b/base/gdevmem.c
@@ -886,7 +886,6 @@ void mem_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, sync_output, gx_default_sync_output);
     set_dev_proc(dev, output_page, gx_default_output_page);
     set_dev_proc(dev, close_device, mem_close);
-    set_dev_proc(dev, get_bits, gx_default_get_bits);
     set_dev_proc(dev, get_params, gx_default_get_params);
     set_dev_proc(dev, put_params, gx_default_put_params);
     set_dev_proc(dev, map_rgb_alpha_color, gx_default_map_rgb_alpha_color);
diff --git a/base/gdevnfwd.c b/base/gdevnfwd.c
index 232525cc4..ae58b5542 100644
--- a/base/gdevnfwd.c
+++ b/base/gdevnfwd.c
@@ -65,7 +65,6 @@ gx_device_forward_fill_in_procs(register gx_device_forward * dev)
     /* NOT fill_rectangle */
     /* NOT copy_mono */
     /* NOT copy_color */
-    fill_dev_proc(dev, get_bits, gx_forward_get_bits);
     fill_dev_proc(dev, get_params, gx_forward_get_params);
     fill_dev_proc(dev, put_params, gx_forward_put_params);
     fill_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
@@ -270,16 +269,6 @@ gx_forward_copy_planes(gx_device * dev, const byte * data,
 }
 
 int
-gx_forward_get_bits(gx_device * dev, int y, byte * data, byte ** actual_data)
-{
-    gx_device_forward * const fdev = (gx_device_forward *)dev;
-    gx_device *tdev = fdev->target;
-
-    return (tdev == 0 ? gx_default_get_bits(dev, y, data, actual_data) :
-            dev_proc(tdev, get_bits)(tdev, y, data, actual_data));
-}
-
-int
 gx_forward_get_params(gx_device * dev, gs_param_list * plist)
 {
     gx_device_forward * const fdev = (gx_device_forward *)dev;
@@ -1236,7 +1225,6 @@ void gx_forward_device_initialize_procs(gx_device *dev)
     fill_dev_proc(dev, fill_rectangle, gx_forward_fill_rectangle);
     fill_dev_proc(dev, copy_mono, gx_forward_copy_mono);
     fill_dev_proc(dev, copy_color, gx_forward_copy_color);
-    fill_dev_proc(dev, get_bits, gx_forward_get_bits);
     fill_dev_proc(dev, get_params, gx_forward_get_params);
     fill_dev_proc(dev, put_params, gx_forward_put_params);
     fill_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
diff --git a/base/gdevp14.c b/base/gdevp14.c
index 02c7b2324..0eabc39d5 100644
--- a/base/gdevp14.c
+++ b/base/gdevp14.c
@@ -69,6 +69,7 @@
 #define CAL_SLOP 0
 #endif
 #include "assert_.h"
+#include "gxgetbit.h"
 
 #if RAW_DUMP
 unsigned int global_index = 0;
@@ -9576,7 +9577,6 @@ pdf14_clist_init_procs(gx_device *dev,
     set_dev_proc(dev, fill_rectangle, gx_forward_fill_rectangle);
     set_dev_proc(dev, copy_mono, gx_forward_copy_mono);
     set_dev_proc(dev, copy_color, gx_forward_copy_color);
-    set_dev_proc(dev, get_bits, gx_forward_get_bits);
     set_dev_proc(dev, get_params, gx_forward_get_params);
     set_dev_proc(dev, put_params, pdf14_put_params);
     set_dev_proc(dev, map_cmyk_color, pdf14_encode_color);
@@ -10517,6 +10517,7 @@ pdf14_clist_composite(gx_device	* dev, gx_device ** pcdev,
         bool save_planar = pdev->is_planar;
         gs_devn_params *target_devn_params = dev_proc(target, ret_devn_params)(target);
         int save_num_separations;
+        gs_int_rect rect;
 
         pdev->is_planar = false;		/* so gx_device_raster is for entire chunky pixel line */
         linebuf = gs_alloc_bytes(mem, gx_device_raster((gx_device *)pdev, true), "pdf14-clist_accum pop dev");
@@ -10598,10 +10599,26 @@ pdf14_clist_composite(gx_device	* dev, gx_device ** pcdev,
                                                     pgs->memory, &info);
         if (code < 0)
             goto put_accum_error;
+        rect.p.x = 0;
+        rect.q.x = tdev->width;
         for (y=0; y < tdev->height; y++) {
-            code = dev_proc(tdev, get_bits)((gx_device *)tdev, y, linebuf, &actual_data);
+            gs_get_bits_params_t params;
+
+            params.options = (GB_ALIGN_ANY |
+                              (GB_RETURN_COPY | GB_RETURN_POINTER) |
+                              GB_OFFSET_0 |
+                              GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                              GB_COLORS_NATIVE | GB_ALPHA_NONE);
+            params.x_offset = 0;
+            params.raster = bitmap_raster(dev->width * dev->color_info.depth);
+            params.data[0] = linebuf;
+            rect.p.y = y;
+            rect.q.y = y+1;
+            code = dev_proc(tdev, get_bits_rectangle)((gx_device *)tdev,
+                                                      &rect, &params, NULL);
             if (code < 0)
                 goto put_accum_error;
+            actual_data = params.data[0];
             planes.data = actual_data;
             planes.data_x = 0;
             planes.raster = tdev->width * tdev->color_info.num_components;
diff --git a/base/gdevplnx.c b/base/gdevplnx.c
index 870112f66..52b490b8f 100644
--- a/base/gdevplnx.c
+++ b/base/gdevplnx.c
@@ -91,7 +91,6 @@ plane_initialize_device_procs(gx_device *dev)
     /* Ideally the following would be initialized to the defaults
      * automatically, but this does not currently work. */
     set_dev_proc(dev, close_device, gx_default_close_device);
-    set_dev_proc(dev, get_bits, gx_default_get_bits);
     set_dev_proc(dev, fill_trapezoid, gx_default_fill_trapezoid);
     set_dev_proc(dev, draw_thin_line, gx_default_draw_thin_line);
     set_dev_proc(dev, text_begin, gx_default_text_begin);
diff --git a/base/gdevprn.c b/base/gdevprn.c
index a8c35f0ba..06e30cc6e 100644
--- a/base/gdevprn.c
+++ b/base/gdevprn.c
@@ -1604,14 +1604,35 @@ gdev_prn_get_lines(gx_device_printer *pdev, int y, int height,
 int
 gdev_prn_get_bits(gx_device_printer * pdev, int y, byte * str, byte ** actual_data)
 {
-    int code = (*dev_proc(pdev, get_bits)) ((gx_device *) pdev, y, str, actual_data);
+    int code;
     uint line_size = gdev_prn_raster(pdev);
     int last_bits = -(pdev->width * pdev->color_info.depth) & 7;
+    gs_int_rect rect;
+    gs_get_bits_params_t params;
 
+    rect.p.x = 0;
+    rect.p.y = y;
+    rect.q.x = pdev->width;
+    rect.q.y = y+1;
+
+    params.options = (GB_ALIGN_ANY |
+                      GB_RETURN_COPY |
+                      GB_OFFSET_0 |
+                      GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                      GB_COLORS_NATIVE | GB_ALPHA_NONE);
+    if (actual_data)
+        params.options |=  GB_RETURN_POINTER;
+    params.x_offset = 0;
+    params.raster = bitmap_raster(pdev->width * pdev->color_info.depth);
+    params.data[0] = str;
+    code = (*dev_proc(pdev, get_bits_rectangle))((gx_device *)pdev, &rect,
+                                                 &params, NULL);
     if (code < 0)
         return code;
+    if (actual_data)
+        *actual_data = params.data[0];
     if (last_bits != 0) {
-        byte *dest = (actual_data != 0 ? *actual_data : str);
+        byte *dest = (actual_data != NULL ? *actual_data : str);
 
         dest[line_size - 1] &= 0xff << last_bits;
     }
diff --git a/base/gdevsclass.c b/base/gdevsclass.c
index 536ac39a3..e4fa367a5 100644
--- a/base/gdevsclass.c
+++ b/base/gdevsclass.c
@@ -195,14 +195,6 @@ int default_subclass_copy_color(gx_device *dev, const byte *data, int data_x, in
     return 0;
 }
 
-int default_subclass_get_bits(gx_device *dev, int y, byte *data, byte **actual_data)
-{
-    if (dev->child)
-        return dev_proc(dev->child, get_bits)(dev->child, y, data, actual_data);
-    /* else */
-    return gx_default_get_bits(dev, y, data, actual_data);
-}
-
 int default_subclass_get_params(gx_device *dev, gs_param_list *plist)
 {
     if (dev->child)
@@ -834,7 +826,6 @@ void default_subclass_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, default_subclass_fill_rectangle);
     set_dev_proc(dev, copy_mono, default_subclass_copy_mono);
     set_dev_proc(dev, copy_color, default_subclass_copy_color);
-    set_dev_proc(dev, get_bits, default_subclass_get_bits);
     set_dev_proc(dev, get_params, default_subclass_get_params);
     set_dev_proc(dev, put_params, default_subclass_put_params);
     set_dev_proc(dev, map_cmyk_color, default_subclass_map_cmyk_color);
diff --git a/base/gdevsclass.h b/base/gdevsclass.h
index 1d1ac876d..b471f7c0a 100644
--- a/base/gdevsclass.h
+++ b/base/gdevsclass.h
@@ -38,7 +38,6 @@ dev_proc_map_color_rgb(default_subclass_map_color_rgb);
 dev_proc_fill_rectangle(default_subclass_fill_rectangle);
 dev_proc_copy_mono(default_subclass_copy_mono);
 dev_proc_copy_color(default_subclass_copy_color);
-dev_proc_get_bits(default_subclass_get_bits);
 dev_proc_get_params(default_subclass_get_params);
 dev_proc_put_params(default_subclass_put_params);
 dev_proc_map_cmyk_color(default_subclass_map_cmyk_color);
diff --git a/base/gsdevice.c b/base/gsdevice.c
index 00463b77a..b5ad7a990 100644
--- a/base/gsdevice.c
+++ b/base/gsdevice.c
@@ -37,6 +37,7 @@
 #include "gxcspace.h"
 #include "gsicc_manage.h"
 #include "gscms.h"
+#include "gxgetbit.h"
 
 /* Include the extern for the device list. */
 extern_gs_lib_device_list();
@@ -236,10 +237,27 @@ gs_copyscanlines(gx_device * dev, int start_y, byte * data, uint size,
     uint count = size / line_size;
     uint i;
     byte *dest = data;
+    gs_int_rect rect;
+    gs_get_bits_params_t params;
 
-    for (i = 0; i < count; i++, dest += line_size) {
-        int code = (*dev_proc(dev, get_bits)) (dev, start_y + i, dest, NULL);
+    rect.p.x = 0;
+    rect.q.x = dev->width;
+    params.x_offset = 0;
+    params.raster = bitmap_raster(dev->width * dev->color_info.depth);
 
+    for (i = 0; i < count; i++, dest += line_size) {
+        int code;
+
+        rect.p.y = start_y+i;
+        rect.q.y = start_y+i+1;
+
+        params.options = (GB_ALIGN_ANY |
+                          GB_RETURN_COPY |
+                          GB_OFFSET_0 |
+                          GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                          GB_COLORS_NATIVE | GB_ALPHA_NONE);
+        params.data[0] = dest;
+        code = (*dev_proc(dev, get_bits_rectangle))(dev, &rect, &params, NULL);
         if (code < 0) {
             /* Might just be an overrun. */
             if (start_y + i == dev->height)
diff --git a/base/gxclip.c b/base/gxclip.c
index b89d6dce8..61ff2166b 100644
--- a/base/gxclip.c
+++ b/base/gxclip.c
@@ -98,7 +98,6 @@ clipper_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, output_page, gx_default_output_page);
     set_dev_proc(dev, close_device, gx_default_close_device);
     set_dev_proc(dev, draw_thin_line, gx_default_draw_thin_line);
-    set_dev_proc(dev, get_bits, gx_default_get_bits);
     set_dev_proc(dev, stroke_path, gx_default_stroke_path);
     set_dev_proc(dev, fill_trapezoid, gx_default_fill_trapezoid);
     set_dev_proc(dev, fill_parallelogram, gx_default_fill_parallelogram);
diff --git a/base/gxclip2.c b/base/gxclip2.c
index e1b898233..1b3424a01 100644
--- a/base/gxclip2.c
+++ b/base/gxclip2.c
@@ -48,7 +48,6 @@ tile_clipper_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, tile_clip_fill_rectangle);
     set_dev_proc(dev, copy_mono, tile_clip_copy_mono);
     set_dev_proc(dev, copy_color, tile_clip_copy_color);
-    set_dev_proc(dev, get_bits, gx_forward_get_bits);
     set_dev_proc(dev, get_params, gx_forward_get_params);
     set_dev_proc(dev, put_params, gx_forward_put_params);
     set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
diff --git a/base/gxclipm.c b/base/gxclipm.c
index 44946164e..34ef574cb 100644
--- a/base/gxclipm.c
+++ b/base/gxclipm.c
@@ -46,7 +46,6 @@ mask_clip_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, mask_clip_fill_rectangle);
     set_dev_proc(dev, copy_mono, mask_clip_copy_mono);
     set_dev_proc(dev, copy_color, mask_clip_copy_color);
-    set_dev_proc(dev, get_bits, gx_forward_get_bits);
     set_dev_proc(dev, get_params, gx_forward_get_params);
     set_dev_proc(dev, put_params, gx_forward_put_params);
     set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
diff --git a/base/gxdevcli.h b/base/gxdevcli.h
index 45b53d63d..3dabd2926 100644
--- a/base/gxdevcli.h
+++ b/base/gxdevcli.h
@@ -925,14 +925,6 @@ typedef enum FILTER_FLAGS {
 #define dev_proc_copy_color(proc)\
   dev_t_proc_copy_color(proc, gx_device)
 
-                /* Added in release 2.4 */
-
-#define dev_t_proc_get_bits(proc, dev_t)\
-  int proc(dev_t *dev,\
-    int y, byte *data, byte **actual_data)
-#define dev_proc_get_bits(proc)\
-  dev_t_proc_get_bits(proc, gx_device)
-
                 /* Added in release 2.4, changed in 2.8, */
                 /* renamed in 2.9.6 */
 
@@ -1482,7 +1474,6 @@ typedef struct {
         dev_t_proc_fill_rectangle((*fill_rectangle), dev_t);\
         dev_t_proc_copy_mono((*copy_mono), dev_t);\
         dev_t_proc_copy_color((*copy_color), dev_t);\
-        dev_t_proc_get_bits((*get_bits), dev_t);\
         dev_t_proc_get_params((*get_params), dev_t);\
         dev_t_proc_put_params((*put_params), dev_t);\
         dev_t_proc_map_cmyk_color((*map_cmyk_color), dev_t);\
diff --git a/base/gxdevice.h b/base/gxdevice.h
index 8e852fb1e..298db3adf 100644
--- a/base/gxdevice.h
+++ b/base/gxdevice.h
@@ -254,8 +254,6 @@ dev_proc_map_color_rgb(gx_default_w_b_map_color_rgb);
 #define gx_default_map_color_rgb gx_default_w_b_map_color_rgb
 dev_proc_copy_mono(gx_default_copy_mono);
 dev_proc_copy_color(gx_default_copy_color);
-dev_proc_get_bits(gx_no_get_bits);      /* gives error */
-dev_proc_get_bits(gx_default_get_bits);
 dev_proc_get_params(gx_default_get_params);
 dev_proc_put_params(gx_default_put_params);
 dev_proc_map_cmyk_color(gx_default_map_cmyk_color);
@@ -357,7 +355,6 @@ dev_proc_map_color_rgb(gx_forward_map_color_rgb);
 dev_proc_fill_rectangle(gx_forward_fill_rectangle);
 dev_proc_copy_mono(gx_forward_copy_mono);
 dev_proc_copy_color(gx_forward_copy_color);
-dev_proc_get_bits(gx_forward_get_bits);
 dev_proc_get_params(gx_forward_get_params);
 dev_proc_put_params(gx_forward_put_params);
 dev_proc_map_cmyk_color(gx_forward_map_cmyk_color);
diff --git a/base/gxdownscale.c b/base/gxdownscale.c
index fd51a6954..3d36d661d 100644
--- a/base/gxdownscale.c
+++ b/base/gxdownscale.c
@@ -1991,8 +1991,22 @@ static int
 getbits_chunky_line(gx_downscale_liner *liner_, void *buffer, int row)
 {
     liner_getbits_chunky *liner = (liner_getbits_chunky *)liner_;
+    gs_int_rect rect;
+    gs_get_bits_params_t params;
 
-    return (*dev_proc(liner->dev, get_bits))(liner->dev, row, buffer, NULL);
+    rect.p.x = 0;
+    rect.p.y = row;
+    rect.q.x = liner->dev->width;
+    rect.q.y = row+1;
+    params.x_offset = 0;
+    params.raster = bitmap_raster(liner->dev->width * liner->dev->color_info.depth);
+    params.options = (GB_ALIGN_ANY |
+                      GB_RETURN_COPY |
+                      GB_OFFSET_0 |
+                      GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                      GB_COLORS_NATIVE | GB_ALPHA_NONE);
+    params.data[0] = buffer;
+    return (*dev_proc(liner->dev, get_bits_rectangle))(liner->dev, &rect, &params, NULL);
 }
 
 static void
diff --git a/base/gxpcmap.c b/base/gxpcmap.c
index 6458c37d4..1e41b40c8 100644
--- a/base/gxpcmap.c
+++ b/base/gxpcmap.c
@@ -117,7 +117,6 @@ pattern_accum_initialize_device_procs(gx_device *dev)
 
     /* It would be much nicer if gx_device_init set the following
      * defaults for us, but that doesn't work for some reason. */
-    set_dev_proc(dev, get_bits, gx_default_get_bits);
     set_dev_proc(dev, copy_alpha, gx_default_copy_alpha);
     set_dev_proc(dev, fill_path, gx_default_fill_path);
     set_dev_proc(dev, stroke_path, gx_default_stroke_path);
@@ -632,6 +631,8 @@ blank_unmasked_bits(gx_device * mask,
     int code = 0;
     byte *ptr;
     int blank = (polarity == GX_CINFO_POLARITY_ADDITIVE ? 255 : 0);
+    gs_int_rect rect;
+    gs_get_bits_params_t params;
 
     if ((p->options & required_options) != required_options)
         return_error(gs_error_rangecheck);
@@ -640,6 +641,11 @@ blank_unmasked_bits(gx_device * mask,
     if (min == NULL)
         return_error(gs_error_VMerror);
 
+    rect.p.x = 0;
+    rect.q.x = mask->width;
+    params.x_offset = 0;
+    params.raster = bitmap_raster(mask->width * mask->color_info.depth);
+
     if (p->options & GB_PACKING_CHUNKY)
     {
         if ((depth & 7) != 0 || depth > 64)
@@ -650,9 +656,20 @@ blank_unmasked_bits(gx_device * mask,
         for (y = 0; y < h; y++)
         {
             byte *mine;
-            code = dev_proc(mask, get_bits)(mask, y+y0, min, &mine);
+
+            rect.p.y = y+y0;
+            rect.q.y = y+y0+1;
+            params.options = (GB_ALIGN_ANY |
+                              (GB_RETURN_COPY | GB_RETURN_POINTER) |
+                              GB_OFFSET_0 |
+                              GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                              GB_COLORS_NATIVE | GB_ALPHA_NONE);
+            params.data[0] = min;
+            code = (*dev_proc(mask, get_bits_rectangle))(mask, &rect,
+                                                         &params, NULL);
             if (code < 0)
                 goto fail;
+            mine = params.data[0];
             for (x = 0; x < w; x++)
             {
                 int xx = x+x0;
@@ -693,9 +710,21 @@ blank_unmasked_bits(gx_device * mask,
         {
             int c;
             byte *mine;
-            code = dev_proc(mask, get_bits)(mask, y+y0, min, &mine);
+
+            rect.p.y = y+y0;
+            rect.q.y = y+y0+1;
+            params.options = (GB_ALIGN_ANY |
+                              (GB_RETURN_COPY | GB_RETURN_POINTER) |
+                              GB_OFFSET_0 |
+                              GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                              GB_COLORS_NATIVE | GB_ALPHA_NONE);
+            params.data[0] = min;
+            code = (*dev_proc(mask, get_bits_rectangle))(mask, &rect,
+                                                         &params, NULL);
             if (code < 0)
                 goto fail;
+            mine = params.data[0];
+
             for (c = 0; c < num_comps; c++)
             {
                 if (p->data[c] == NULL)
diff --git a/devices/gdevdsp.c b/devices/gdevdsp.c
index a4d70b53b..fbcb75b9a 100644
--- a/devices/gdevdsp.c
+++ b/devices/gdevdsp.c
@@ -91,7 +91,7 @@ static dev_proc_map_color_rgb(display_map_color_rgb_bgr24);
 static dev_proc_fill_rectangle(display_fill_rectangle);
 static dev_proc_copy_mono(display_copy_mono);
 static dev_proc_copy_color(display_copy_color);
-static dev_proc_get_bits(display_get_bits);
+static dev_proc_get_bits_rectangle(display_get_bits_rectangle);
 static dev_proc_get_params(display_get_params);
 static dev_proc_put_params(display_put_params);
 static dev_proc_initialize_device_procs(display_initialize_device_procs);
@@ -813,12 +813,14 @@ display_copy_color(gx_device * dev,
 }
 
 static int
-display_get_bits(gx_device * dev, int y, byte * str, byte ** actual_data)
+display_get_bits_rectangle(gx_device * dev, const gs_int_rect *rect,
+                           gs_get_bits_params_t *params,
+                           gs_int_rect ** unread)
 {
     gx_device_display *ddev = (gx_device_display *) dev;
     if (ddev->callback == NULL)
         return gs_error_Fatal;
-    return ddev->mutated_procs.get_bits(dev, y, str, actual_data);
+    return ddev->mutated_procs.get_bits_rectangle(dev, rect, params, unread);
 }
 
 static int
@@ -1765,7 +1767,7 @@ display_alloc_bitmap(gx_device_display * ddev, gx_device * param_dev)
         ddev->procs.fill_rectangle = display_fill_rectangle;
         ddev->procs.copy_mono = display_copy_mono;
         ddev->procs.copy_color = display_copy_color;
-        ddev->procs.get_bits = display_get_bits;
+        ddev->procs.get_bits_rectangle = display_get_bits_rectangle;
     }
 
     /* In command list mode, we've already opened the device. */
diff --git a/devices/gdevijs.c b/devices/gdevijs.c
index 49bc12fe5..0252e3b5e 100644
--- a/devices/gdevijs.c
+++ b/devices/gdevijs.c
@@ -437,7 +437,6 @@ static int gsijs_k_get_bits(gx_device_printer * pdev, int y, byte ** actual_data
    int y1=raster*(y-(band_height*band_number));
 
    *actual_data = ijsdev->k_band+y1;
-
    return 0;
 }
 
diff --git a/devices/gdevpng.c b/devices/gdevpng.c
index 861abc277..584664307 100644
--- a/devices/gdevpng.c
+++ b/devices/gdevpng.c
@@ -988,6 +988,8 @@ pngalpha_copy_alpha(gx_device * dev, const byte * data, int data_x,
         int code = 0;
         gx_color_value color_cv[GX_DEVICE_COLOR_MAX_COMPONENTS];
         int ry;
+        gs_int_rect rect;
+        gs_get_bits_params_t params;
 
         fit_copy(dev, data, data_x, raster, id, x, y, width, height);
         row = data;
@@ -999,6 +1001,10 @@ pngalpha_copy_alpha(gx_device * dev, const byte * data, int data_x,
             goto out;
         }
         (*dev_proc(dev, decode_color)) (dev, color, color_cv);
+        rect.p.x = 0;
+        rect.q.x = dev->width;
+        params.x_offset = 0;
+        params.raster = bitmap_raster(dev->width * dev->color_info.depth);
         for (ry = y; ry < y + height; row += raster, ++ry) {
             byte *line;
             int sx, rx;
@@ -1008,9 +1014,19 @@ pngalpha_copy_alpha(gx_device * dev, const byte * data, int data_x,
             byte l_dbyte = ((l_dbit) ? (byte)(*(l_dptr) & (0xff00 >> (l_dbit))) : 0);
             int l_xprev = x;
 
-            code = (*dev_proc(dev, get_bits)) (dev, ry, lin, &line);
+            rect.p.y = ry;
+            rect.q.y = ry+1;
+
+            params.options = (GB_ALIGN_ANY |
+                              (GB_RETURN_COPY | GB_RETURN_POINTER) |
+                              GB_OFFSET_0 |
+                              GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                              GB_COLORS_NATIVE | GB_ALPHA_NONE);
+            params.data[0] = lin;
+            code = (*dev_proc(dev, get_bits_rectangle))(dev, &rect, &params, NULL);
             if (code < 0)
                 break;
+            line = params.data[0];
             for (sx = data_x, rx = x; sx < data_x + width; ++sx, ++rx) {
                 gx_color_index previous = gx_no_color_index;
                 gx_color_index composite;
diff --git a/devices/gdevstc.c b/devices/gdevstc.c
index 7de3d905b..f3b7e5b2a 100644
--- a/devices/gdevstc.c
+++ b/devices/gdevstc.c
@@ -139,7 +139,7 @@ stcolor_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, output_page, gdev_prn_bg_output_page);
     set_dev_proc(dev, close_device, stc_close);
     set_dev_proc(dev, map_color_rgb, stc_map_color_cmyk);
-    set_dev_proc(dev, get_bits, gx_default_get_bits);
+    set_dev_proc(dev, get_bits_rectangle, gx_default_get_bits_rectangle);
     set_dev_proc(dev, get_params, stc_get_params);
     set_dev_proc(dev, put_params, stc_put_params);
     set_dev_proc(dev, map_cmyk_color, stc_map_cmyk_color);
diff --git a/devices/gdevupd.c b/devices/gdevupd.c
index b661c9513..32e82bdcd 100644
--- a/devices/gdevupd.c
+++ b/devices/gdevupd.c
@@ -90,6 +90,7 @@ There are two compile-time options for this driver:
 
 #include "gdevprn.h" /** Printer-superclass header */
 #include "gsparam.h" /** For the Parameter-Handling (optional) */
+#include "gxgetbit.h"
 
 #include <stdlib.h>  /** for rand */
 #include <limits.h>  /** for INT_MIN */
@@ -1023,6 +1024,8 @@ upd_print_page(gx_device_printer *pdev, gp_file *out)
    const upd_p       upd   = udev->upd;
    const int *const  ints  = upd ? upd->ints : NULL;
    int error,need,yfill;
+   gs_int_rect rect;
+   gs_get_bits_params_t params;
 
 #if UPD_SIGNAL /* variables required for signal-handling only */
    void (*oldint )(int) = NULL;
@@ -1090,6 +1093,11 @@ upd_print_page(gx_device_printer *pdev, gp_file *out)
    upd->ixpass =  0;
    upd->icomp  = -1; /* Enforces initial selection */
    upd->lf     = -1; /* Enforces initial selection */
+
+   rect.p.x = 0;
+   rect.q.x = pdev->width;
+   params.x_offset = 0;
+   params.raster = bitmap_raster(pdev->width * pdev->color_info.depth);
 /*
  * Main Loop
  */
@@ -1106,14 +1114,24 @@ upd_print_page(gx_device_printer *pdev, gp_file *out)
 
          if(upd->gsheight > upd->yscnbuf)  {
 
-            if(0 > (*dev_proc(udev,get_bits))((gx_device *) udev,
-                                   upd->yscnbuf,upd->gsbuf,&upd->gsscan)) {
+            rect.p.y = upd->yscnbuf;
+            rect.q.y = upd->yscnbuf+1;
+
+            params.options = (GB_ALIGN_ANY |
+                              (GB_RETURN_COPY | GB_RETURN_POINTER) |
+                              GB_OFFSET_0 |
+                              GB_RASTER_STANDARD | GB_PACKING_CHUNKY |
+                              GB_COLORS_NATIVE | GB_ALPHA_NONE);
+            params.data[0] = upd->gsbuf;
+            if(0 > (*dev_proc(udev,get_bits_rectangle))((gx_device *) udev,
+                                   &rect,&params,NULL)) {
 #if UPD_MESSAGES & UPD_M_WARNING
                errprintf(udev->memory, "get_bits aborted with error, yscnbuf = %4d\n",
                          upd->yscnbuf);
 #endif
                break;
             }
+            upd->gsscan = params.data[0];
          } else {
 
             memset(upd->gsscan = upd->gsbuf,0,upd->ngsbuf);
diff --git a/devices/gdevxalt.c b/devices/gdevxalt.c
index 47e3e84d3..fbc206144 100644
--- a/devices/gdevxalt.c
+++ b/devices/gdevxalt.c
@@ -26,6 +26,7 @@
 #include "gsdevice.h"		/* for gs_copydevice */
 #include "gdevx.h"
 #include "gsbitops.h"
+#include "gxgetbit.h"
 
 void
 gs_shared_init(void);
@@ -297,18 +298,20 @@ x_forward_copy_color(gx_device * dev, const byte * base, int sourcex,
 }
 
 static int
-x_forward_get_bits(gx_device * dev, int y, byte * str, byte ** actual_data)
+x_forward_get_bits_rectangle(gx_device * dev, const gs_int_rect *prect,
+                             gs_get_bits_params_t *params, gs_int_rect **unused)
 {
     gx_device *tdev;
     int code;
 
     if ((code = get_dev_target(&tdev, dev)) < 0)
         return code;
-    return (*dev_proc(tdev, get_bits)) (tdev, y, str, actual_data);
+    return (*dev_proc(tdev, get_bits_rectangle)) (tdev, prect, params, unused);
 }
 
 static int
-x_wrap_get_bits(gx_device * dev, int y, byte * str, byte ** actual_data)
+x_wrap_get_bits_rectangle(gx_device * dev, const gs_int_rect *prect,
+                          gs_get_bits_params_t *params, gs_int_rect **unused)
 {
     int depth = dev->color_info.depth;
     gx_device *tdev;
@@ -332,9 +335,17 @@ x_wrap_get_bits(gx_device * dev, int y, byte * str, byte ** actual_data)
     int xi;
     int sbit;
 
-    byte *l_dptr = str;
+    byte *l_dptr = params->data[0];
     int l_dbit = 0;
     byte l_dbyte = 0;
+    gs_int_rect rect;
+    int y;
+
+    if ((~params->options & GB_RETURN_COPY) ||
+        !(params->options & (GB_OFFSET_0 | GB_OFFSET_SPECIFIED)) ||
+        !(params->options & (GB_RASTER_STANDARD | GB_RASTER_SPECIFIED))
+        )
+        return_error(gs_error_rangecheck);
 
     if ((code = get_dev_target(&tdev, dev)) < 0)
         return code;
@@ -345,53 +356,70 @@ x_wrap_get_bits(gx_device * dev, int y, byte * str, byte ** actual_data)
     row = gs_alloc_bytes(mem, dsize, "x_wrap_get_bits");
     if (row == 0)
         return_error(gs_error_VMerror);
-    code = (*dev_proc(tdev, get_bits)) (tdev, y, row, &base);
-    if (code < 0)
-        goto gx;
-    for (sbit = 0, xi = 0; xi < width; sbit += sdepth, ++xi) {
-        const byte *sptr = base + (sbit >> 3);
-        gx_color_index pixel;
-        gx_color_value rgb[3];
-        int i;
-
-        if (sdepth <= 8)
-            pixel = (*sptr >> (8 - sdepth - (sbit & 7))) & smask;
-        else {
-            pixel = 0;
-            for (i = 0; i < sdepth; i += 8, ++sptr)
-                pixel = (pixel << 8) + *sptr;
-        }
-        if (pixel != pixel_in) {
-            (*dev_proc(tdev, map_color_rgb))(tdev, pixel, rgb);
-            pixel_in = pixel;
-            if (dev->color_info.num_components <= 3)
-                pixel_out = (*dev_proc(dev, map_rgb_color))(dev, rgb);
+    rect.p.x = prect->p.x;
+    rect.q.x = prect->q.x;
+    for (y = prect->p.y; y < prect->q.y; y++)
+    {
+        gs_get_bits_params_t lparams;
+        rect.p.y = y;
+        rect.q.y = y+1;
+        lparams.options = GB_ALIGN_ANY |
+                          GB_RETURN_COPY |
+                          GB_OFFSET_0 | GB_RASTER_STANDARD |
+                          GB_PACKING_CHUNKY |
+                          GB_COLORS_NATIVE | GB_ALPHA_NONE;
+        lparams.raster = 0;
+        lparams.data[0] = row;
+        lparams.x_offset = 0;
+        code = (*dev_proc(tdev, get_bits_rectangle))(tdev, &rect, &lparams, NULL);
+        if (code < 0)
+            break;
+        base = lparams.data[0];
+        for (sbit = 0, xi = 0; xi < width; sbit += sdepth, ++xi) {
+            const byte *sptr = base + (sbit >> 3);
+            gx_color_index pixel;
+            gx_color_value rgb[3];
+            int i;
+
+            if (sdepth <= 8)
+                pixel = (*sptr >> (8 - sdepth - (sbit & 7))) & smask;
             else {
-                /* Convert RGB to CMYK. */
-                gx_color_value c = gx_max_color_value - rgb[0];
-                gx_color_value m = gx_max_color_value - rgb[1];
-                gx_color_value y = gx_max_color_value - rgb[2];
-                gx_color_value k = (c < m ? min(c, y) : min(m, y));
-
-                gx_color_value cmyk[4];
-                cmyk[0] = c - k; cmyk[1] = m - k; cmyk[2] = y - k; cmyk[3] = k;
-                pixel_out = (*dev_proc(dev, map_cmyk_color))(dev, cmyk);
+                pixel = 0;
+                for (i = 0; i < sdepth; i += 8, ++sptr)
+                    pixel = (pixel << 8) + *sptr;
+            }
+            if (pixel != pixel_in) {
+                (*dev_proc(tdev, map_color_rgb))(tdev, pixel, rgb);
+                pixel_in = pixel;
+                if (dev->color_info.num_components <= 3)
+                    pixel_out = (*dev_proc(dev, map_rgb_color))(dev, rgb);
+                else {
+                    /* Convert RGB to CMYK. */
+                    gx_color_value c = gx_max_color_value - rgb[0];
+                    gx_color_value m = gx_max_color_value - rgb[1];
+                    gx_color_value y = gx_max_color_value - rgb[2];
+                    gx_color_value k = (c < m ? min(c, y) : min(m, y));
+
+                    gx_color_value cmyk[4];
+                    cmyk[0] = c - k; cmyk[1] = m - k; cmyk[2] = y - k; cmyk[3] = k;
+                    pixel_out = (*dev_proc(dev, map_cmyk_color))(dev, cmyk);
+                }
+            }
+            if (sizeof(pixel_out) > 4) {
+                if (sample_store_next64(pixel_out, &l_dptr,
+                                        &l_dbit, depth, &l_dbyte) < 0)
+                    return_error(gs_error_rangecheck);
+            }
+            else {
+                if (sample_store_next32(pixel_out, &l_dptr,
+                                        &l_dbit, depth, &l_dbyte) < 0)
+                    return_error(gs_error_rangecheck);
             }
         }
-        if (sizeof(pixel_out) > 4) {
-            if (sample_store_next64(pixel_out, &l_dptr, &l_dbit, depth, &l_dbyte) < 0)
-                return_error(gs_error_rangecheck);
-        }
-        else {
-            if (sample_store_next32(pixel_out, &l_dptr, &l_dbit, depth, &l_dbyte) < 0)
-                return_error(gs_error_rangecheck);
-        }
+        sample_store_flush(l_dptr, l_dbit, l_dbyte);
     }
-    sample_store_flush(l_dptr, l_dbit, l_dbyte);
-gx:
     gs_free_object(mem, row, "x_wrap_get_bits");
-    if (actual_data)
-        *actual_data = str;
+
     return code;
 }
 
@@ -561,7 +589,7 @@ x_cmyk_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
     set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
     set_dev_proc(dev, copy_color, x_wrap_copy_color);
-    set_dev_proc(dev, get_bits, x_wrap_get_bits);
+    set_dev_proc(dev, get_bits_rectangle, x_wrap_get_bits_rectangle);
     set_dev_proc(dev, get_params, x_wrap_get_params);
     set_dev_proc(dev, put_params, x_cmyk_put_params);
     set_dev_proc(dev, map_cmyk_color, x_cmyk_map_cmyk_color);
@@ -691,7 +719,7 @@ x_mono_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, map_color_rgb, x_wrap_map_color_rgb);
     set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
     set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
-    set_dev_proc(dev, get_bits, x_wrap_get_bits);
+    set_dev_proc(dev, get_bits_rectangle, x_wrap_get_bits_rectangle);
     set_dev_proc(dev, get_params, x_wrap_get_params);
     set_dev_proc(dev, put_params, x_wrap_put_params);
     set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
@@ -737,7 +765,7 @@ x_gray_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
     set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
     set_dev_proc(dev, copy_color, x_wrap_copy_color);
-    set_dev_proc(dev, get_bits, x_wrap_get_bits);
+    set_dev_proc(dev, get_bits_rectangle, x_wrap_get_bits_rectangle);
     set_dev_proc(dev, get_params, x_wrap_get_params);
     set_dev_proc(dev, put_params, x_wrap_put_params);
     set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
@@ -814,7 +842,7 @@ rgbx_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
     set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
     set_dev_proc(dev, copy_color, x_forward_copy_color);
-    set_dev_proc(dev, get_bits, x_forward_get_bits);
+    set_dev_proc(dev, get_bits_rectangle, x_forward_get_bits_rectangle);
     set_dev_proc(dev, get_params, x_wrap_get_params);
     set_dev_proc(dev, put_params, x_wrap_put_params);
     set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
diff --git a/devices/vector/gdevpdf.c b/devices/vector/gdevpdf.c
index af08f2d67..1867f428e 100644
--- a/devices/vector/gdevpdf.c
+++ b/devices/vector/gdevpdf.c
@@ -232,7 +232,6 @@ pdfwrite_initialize_device_procs(gx_device *dev)
     set_dev_proc(dev, fill_rectangle, gdev_pdf_fill_rectangle);
     set_dev_proc(dev, copy_mono, gdev_pdf_copy_mono);
     set_dev_proc(dev, copy_color, gdev_pdf_copy_color);
-    set_dev_proc(dev, get_bits, psdf_get_bits);
     set_dev_proc(dev, get_params, gdev_pdf_get_params);
     set_dev_proc(dev, put_params, gdev_pdf_put_params);
     set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
diff --git a/devices/vector/gdevpsdf.h b/devices/vector/gdevpsdf.h
index b117cad44..d20b0bb2f 100644
--- a/devices/vector/gdevpsdf.h
+++ b/devices/vector/gdevpsdf.h
@@ -508,8 +508,7 @@ int psdf_set_color(gx_device_vector *vdev, const gx_drawing_color *pdc,
 /* Round a double value to a specified precision. */
 double psdf_round(double v, int precision, int radix);
 
-/* stubs to disable get_bits, get_bits_rectangle */
-dev_proc_get_bits(psdf_get_bits);
+/* stub to disable get_bits_rectangle */
 dev_proc_get_bits_rectangle(psdf_get_bits_rectangle);
 
 /* intercept and ignore overprint compositor creation */
diff --git a/devices/vector/gdevpsdu.c b/devices/vector/gdevpsdu.c
index 567f3150a..41558a712 100644
--- a/devices/vector/gdevpsdu.c
+++ b/devices/vector/gdevpsdu.c
@@ -468,18 +468,10 @@ psdf_end_binary(psdf_binary_writer * pbw)
 /* ---------------- Overprint, Get Bits ---------------- */
 
 /*
- * High level devices cannot perform get_bits or get_bits_rectangle
+ * High level devices cannot perform get_bits_rectangle
  * operations, for obvious reasons.
  */
 int
-psdf_get_bits(gx_device * dev, int y, byte * data, byte ** actual_data)
-{
-    emprintf(dev->memory,
-                  "Can't set GraphicsAlphaBits or TextAlphaBits with a vector device.\n");
-    return_error(gs_error_unregistered);
-}
-
-int
 psdf_get_bits_rectangle(
     gx_device *             dev,
     const gs_int_rect *     prect,
diff --git a/doc/Drivers.htm b/doc/Drivers.htm
index 906c6f5ef..c2c3ed7c1 100644
--- a/doc/Drivers.htm
+++ b/doc/Drivers.htm
@@ -1135,8 +1135,8 @@ the same way.</p>
 <p>As from Ghostscript 9.11 onwards, a new device function, <tt>process_page</tt>
 has been introduced to solve this. A printer driver will be called via the
 <tt>print_page</tt> or <tt>print_page_copies</tt> entry point as before, but
-rather than requesting a scan line or rectangle of pixels at a time (by
-calling <tt>get_bits</tt> or <tt>get_bits_rectangle</tt> respectively), the
+rather than requesting a rectangle of pixels at a time (by
+calling <tt>get_bits_rectangle</tt>), the
 driver can now invite Ghostscript to "process the page" in whatever sized
 chunks it chooses.</p>
 
@@ -1339,8 +1339,8 @@ the device procedure tables. This cannot fail.
 by the internal device creation code. The sole exception here is when
 a device implementation wishes to copy device function pointers from another
 device; then a blank <code>gx_device</code> can be created, and
-<code>initialize_device_procs</dd> can be used to fill out the device procs
-table so it can be copied from.
+<code>initialize_device_procs</code> can be used to fill out the device procs
+table so it can be copied from.</dd>
 </dl>
 
 <dl>
@@ -3016,31 +3016,6 @@ superset of the region actually obscured: for example, a lazy implementation
 could return a single rectangle that was the bounding box of the region.</p>
 </dl>
 
-<dl>
-<dt><code>int (*get_bits)(gx_device&nbsp;*dev, int&nbsp;y,
-byte&nbsp;*data, byte&nbsp;**actual_data)</code>
-<b><em>[OPTIONAL]</em></b></dt>
-<dd>Read scan line <code>y</code> of bits back from the device into the
-area starting at data.  This call is functionally equivalent to</dd>
-
-<blockquote>
-<pre>(*get_bits_rectangle)
-  (dev, {0, y, dev-&gt;width, y+1},
-   {(GB_ALIGN_ANY | (GB_RETURN_COPY | GB_RETURN_POINTER) | GB_OFFSET_0 |
-     GB_RASTER_STANDARD | GB_FORMAT_CHUNKY | GB_COLORS_NATIVE |
-     GB_ALPHA_NONE),
-    {data}})</pre></blockquote>
-
-<p>
-with the returned value of
-<code>params</code>-&gt;<code>data[0]</code> stored in
-<code>*actual_data</code>, and will in fact be implemented this way if
-the device defines a <code>get_bits_rectangle</code> procedure and does
-not define one for <code>get_bits</code>.  (If
-<code>actual_data</code> is <code>NULL</code>,
-<code>GB_RETURN_POINTER</code> is omitted from the options.)</p>
-</dl>
-
 <h3><a name="Parameters"></a>Parameters</h3>
 
 <p>