Bug 688210: Add psdcmyk16 and psdrgb16 devices

So the patch that was provided was far from sufficient in making this
work.  There was significant work that needed to be done in the
pdf14 device to ensure that the transparency put_image operation
worked correctly.  Not sure if the author was paid a bounty but I
question if it was properly tested.

I tested this with some extreme altona files and others and
everything seems to be working well now.  Having the psdcmyk16 device
is nice as it is our only device to have full spot color support and
16 bit output precision.

13 files changed, 274 insertions, 102 deletions

diff --git a/base/gdevmpla.c b/base/gdevmpla.c
index 120b3a64d..94cb3b4c3 100644
--- a/base/gdevmpla.c
+++ b/base/gdevmpla.c
@@ -261,10 +261,8 @@ mem_planar_put_image(gx_device *pdev, gx_device *pmdev, const byte **buffers, in
     gx_device_memory * const mdev = (gx_device_memory *)pmdev;
 
     /* We don't want alpha, return 0 to ask for the pdf14 device to do the
-       alpha composition. We also do not want chunky data coming in or to deal
-       with planar devices that are not 8 bit per colorant */
-    if (alpha_plane_index != 0 ||
-        mdev->planes[0].depth != 8)
+       alpha composition. We also do not want chunky data coming in */
+    if (alpha_plane_index != 0)
         return 0;
 
     put_image_copy_planes(pdev, buffers, 0, row_stride,
diff --git a/base/gdevp14.c b/base/gdevp14.c
index 6e27a07aa..3375e9993 100644
--- a/base/gdevp14.c
+++ b/base/gdevp14.c
@@ -1847,13 +1847,16 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
     byte *linebuf;
     gs_color_space *pcs;
     int x1, y1, width, height;
-    byte *buf_ptr;
+    byte *buf_ptr, *buf16_ptr = NULL;
     bool data_blended = false;
     int num_rows_left;
     gsicc_rendering_param_t render_cond;
     cmm_dev_profile_t *dev_profile;
     cmm_dev_profile_t *dev_target_profile;
     byte bg = pdev->ctx->additive ? 255 : 0;
+    bool expand = (target->color_info.depth / target->color_info.num_components == 16);
+    int planestride = buf->planestride;
+    int rowstride = buf->rowstride;
 
     /* Make sure that this is the only item on the stack. Fuzzing revealed a
        potential problem. Bug 694190 */
@@ -1872,7 +1875,7 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
 #endif
     if (width <= 0 || height <= 0 || buf->data == NULL)
         return 0;
-    buf_ptr = buf->data + rect.p.y * buf->rowstride + rect.p.x;
+    buf_ptr = buf->data + rect.p.y * rowstride + rect.p.x;
 
     /* Check that target is OK.  From fuzzing results the target could have been
        destroyed, for e.g if it were a pattern accumulator that was closed
@@ -1909,8 +1912,8 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
                 &render_cond);
 
 #if RAW_DUMP
-            dump_raw_buffer(height, width, buf->n_planes, buf->planestride,
-                buf->rowstride, "pre_blend_cs", buf_ptr);
+            dump_raw_buffer(height, width, buf->n_planes, planestride,
+                rowstride, "pre_blend_cs", buf_ptr);
             global_index++;
 #endif
 
@@ -1930,8 +1933,8 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
                 buf_ptr = cm_result->data;  /* Note the lack of offset */
 
 #if RAW_DUMP
-            dump_raw_buffer(height, width, buf->n_planes, buf->planestride,
-                buf->rowstride, "post_blend_cs", buf_ptr);
+            dump_raw_buffer(height, width, buf->n_planes, planestride,
+                rowstride, "post_blend_cs", buf_ptr);
             global_index++;
 #endif
             /* May need to adjust background value due to color space change */
@@ -1945,10 +1948,10 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
 
         /* See if the target device can handle the data with alpha component */
         for (i = 0; i < buf->n_planes; i++)
-            buf_ptrs[i] = buf_ptr + i * buf->planestride;
+            buf_ptrs[i] = buf_ptr + i * planestride;
         code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
                                             rect.p.x, rect.p.y, width, height,
-                                            buf->rowstride, alpha_offset,
+                                            rowstride, alpha_offset,
                                             tag_offset);
         if (code == 0) {
             /* Device could not handle the alpha data.  Go ahead and preblend
@@ -1960,22 +1963,33 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
                         "pre_final_blend",buf_ptr);
             global_index++;
 #endif
-            gx_blend_image_buffer(buf_ptr, width, height, buf->rowstride,
-                                  buf->planestride, num_comp, bg);
+            if (expand) {
+                buf16_ptr = gs_alloc_bytes(pdev->memory,
+                    planestride * num_comp * 2, "pdf14_put_image");
+                gx_blend_image_buffer16(buf_ptr, (unsigned short*) buf16_ptr,
+                    width, height, rowstride, planestride, num_comp, bg);
+                planestride = planestride * 2;
+                rowstride = rowstride * 2;
+                for (i = 0; i < num_comp; i++)
+                    buf_ptrs[i] = buf16_ptr + i * planestride;
+            } else {
+                gx_blend_image_buffer(buf_ptr, width, height, rowstride,
+                    buf->planestride, num_comp, bg);
 #if RAW_DUMP
-            dump_raw_buffer(height, width, buf->n_planes,
-                        pdev->ctx->stack->planestride, pdev->ctx->stack->rowstride,
-                        "post_final_blend",buf_ptr);
-            global_index++;
-            clist_band_count++;
+                dump_raw_buffer(height, width, buf->n_planes,
+                    pdev->ctx->stack->planestride, pdev->ctx->stack->rowstride,
+                    "post_final_blend", buf_ptr);
+                global_index++;
+                clist_band_count++;
 #endif
+            }
             data_blended = true;
 
             /* Try again now with just the tags */
             alpha_offset = 0;
             code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
                                                 rect.p.x, rect.p.y, width, height,
-                                                buf->rowstride, alpha_offset,
+                                                rowstride, alpha_offset,
                                                 tag_offset);
         }
         if (code > 0) {
@@ -1984,16 +1998,24 @@ pdf14_put_image(gx_device * dev, gs_gstate * pgs, gx_device * target)
             while (num_rows_left > 0) {
                 code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
                                                     rect.p.x, rect.p.y + code, width,
-                                                    num_rows_left, buf->rowstride,
+                                                    num_rows_left, rowstride,
                                                     alpha_offset, tag_offset);
                 num_rows_left = num_rows_left - code;
             }
+            if (buf16_ptr != NULL)
+                gs_free_object(pdev->memory, buf16_ptr, "pdf14_put_image");
             return 0;
         }
     }
+
     /*
      * Set color space in preparation for sending an image.
      */
+    if (buf16_ptr != NULL)
+        gs_free_object(pdev->memory, buf16_ptr, "pdf14_put_image");
+    planestride = buf->planestride;
+    rowstride = buf->rowstride;
+
     code = gs_cspace_build_ICC(&pcs, NULL, pgs->memory);
     if (pcs == NULL)
         return_error(gs_error_VMerror);
diff --git a/base/gxblend.h b/base/gxblend.h
index 7d0c42db9..2bdbb1723 100644
--- a/base/gxblend.h
+++ b/base/gxblend.h
@@ -342,7 +342,9 @@ void pdf14_cmyk_cs_to_grayspot_cm(gx_device * dev, frac c, frac m, frac y, frac
 void gx_build_blended_image_row(const byte *gs_restrict buf_ptr, int planestride,
                            int width, int num_comp, byte bg, byte *gs_restrict linebuf);
 void gx_blend_image_buffer(byte *buf_ptr, int width, int height,
-                      int rowstride, int planestride, int num_comp, byte bg);
+    int rowstride, int planestride, int num_comp, byte bg);
+void gx_blend_image_buffer16(byte *buf_ptr, unsigned short *buf_ptr_out, int width, int height,
+        int rowstride, int planestride, int num_comp, byte bg);
 int gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr,
                       int planestride, int rowstride,
                       int x0, int y0, int width, int height, int num_comp, byte bg,
diff --git a/base/gxblend1.c b/base/gxblend1.c
index 183190886..fe6492454 100644
--- a/base/gxblend1.c
+++ b/base/gxblend1.c
@@ -28,6 +28,7 @@
 #include "gdevp14.h"
 #include "gxdcconv.h"
 #include "gsicc_cache.h"
+#include "gxdevsop.h"
 
 #ifdef DUMP_TO_PNG
 #include "png_.h"
@@ -672,9 +673,50 @@ gx_blend_image_buffer(byte *buf_ptr, int width, int height, int rowstride,
     }
 }
 
+void
+gx_blend_image_buffer16(byte *buf_ptr_in, unsigned short *buf_ptr_out, int width,
+    int height, int rowstride, int planestride, int num_comp, byte bg)
+{
+    int x, y;
+    int position;
+    int comp, a;
+    int tmp, comp_num;
+    int bg_out = bg + (bg << 8);
+
+    for (y = 0; y < height; y++) {
+        position = y * rowstride;
+        for (x = 0; x < width; x++) {
+            /* composite RGBA (or CMYKA, etc.) pixel with over solid background */
+            a = buf_ptr_in[position + planestride * num_comp];
+            if (a == 0xff) {
+                for (comp_num = 0; comp_num < num_comp; comp_num++) {
+                    comp = buf_ptr_in[position + planestride * comp_num];
+                    buf_ptr_out[position + planestride * comp_num] = (comp + (comp << 8));
+                }
+            } else if (a == 0) {
+                for (comp_num = 0; comp_num < num_comp; comp_num++) {
+                    buf_ptr_out[position + planestride * comp_num] = bg_out;
+                }
+            } else {
+                a ^= 0xff;
+                a += (a << 8);
+                for (comp_num = 0; comp_num < num_comp; comp_num++) {
+                    comp = buf_ptr_in[position + planestride * comp_num];
+                    comp += (comp << 8);
+                    tmp = ((bg_out - comp) * a) + 0x8000;
+                    comp += (tmp + (tmp >> 16)) >> 16;
+                    comp = ((comp & 0xff) << 8) + ((comp & 0xff00) >> 8);
+                    buf_ptr_out[position + planestride * comp_num] = comp;
+                }
+            } 
+            position += 1;
+        }
+    }
+}
+
 int
-gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr, int planestride,
-                      int rowstride, int x0, int y0, int width, int height,
+gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr, int planestride_in,
+                      int rowstride_in, int x0, int y0, int width, int height,
                       int num_comp, byte bg, bool has_tags, gs_int_rect rect,
                       gs_separations * pseparations)
 {
@@ -690,6 +732,13 @@ gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr, int planestride,
     int output_num_comp = target->color_info.num_components;
     int num_sep = pseparations->num_separations++;
     int num_rows_left;
+    int i;
+    gx_drawing_color pdcolor;
+    gs_fixed_rect rect_fixed;
+    bool expand = (target->color_info.depth / output_num_comp == 16);
+    int planestride = planestride_in;
+    int rowstride = rowstride_in;
+    byte *buf16_ptr = NULL;
 
     /*
      * The process color model for the PDF 1.4 compositor device is CMYK plus
@@ -727,57 +776,79 @@ gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr, int planestride,
         /* See if the target device can handle the data in its current
            form with the alpha component */
         int alpha_offset = num_comp;
-        int tag_offset = has_tags ? num_comp+1 : 0;
+        int tag_offset = has_tags ? num_comp + 1 : 0;
         const byte *buf_ptrs[GS_CLIENT_COLOR_MAX_COMPONENTS];
-        int i;
+
         for (i = 0; i < num_comp; i++)
             buf_ptrs[i] = buf_ptr + i * planestride;
         code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
-                                            rect.p.x, rect.p.y, width, height,
-                                            rowstride,
-                                            num_comp,tag_offset);
+            rect.p.x, rect.p.y, width, height,
+            rowstride,
+            num_comp, tag_offset);
         if (code == 0) {
             /* Device could not handle the alpha data.  Go ahead and
                preblend now. Note that if we do this, and we end up in the
-               default below, we only need to repack in chunky not blend */
+               default below, we only need to repack in chunky not blend.  Add
+               in conversion to 16 bits if the target device is planar and
+               a 16 bit device. */
 #if RAW_DUMP
-            /* Dump before and after the blend to make sure we are doing that ok */
-            dump_raw_buffer(height, width, num_comp+1, planestride, rowstride,
-                            "pre_final_blend",buf_ptr);
+               /* Dump before and after the blend to make sure we are doing that ok */
+            dump_raw_buffer(height, width, num_comp + 1, planestride, rowstride,
+                "pre_final_blend", buf_ptr);
             global_index++;
 #endif
-            gx_blend_image_buffer(buf_ptr, width, height, rowstride,
-                                  planestride, num_comp, bg);
+            if (expand) {
+                buf16_ptr = gs_alloc_bytes(target->memory,
+                    planestride * num_comp * 2, "gx_put_blended_image_cmykspot");
+                gx_blend_image_buffer16(buf_ptr, (unsigned short*)buf16_ptr, width, height,
+                    rowstride, planestride, num_comp, bg);
+                planestride = planestride_in * 2;
+                rowstride = rowstride_in * 2;
+                for (i = 0; i < num_comp; i++)
+                    buf_ptrs[i] = buf16_ptr + i * planestride;
+            } else {
+                gx_blend_image_buffer(buf_ptr, width, height, rowstride,
+                    planestride, num_comp, bg);
 #if RAW_DUMP
-            /* Dump before and after the blend to make sure we are doing that ok */
-            dump_raw_buffer(height, width, num_comp, planestride, rowstride,
-                            "post_final_blend",buf_ptr);
-            global_index++;
-            /* clist_band_count++; */
+                /* Dump before and after the blend to make sure we are doing that ok */
+                dump_raw_buffer(height, width, num_comp, planestride, rowstride,
+                    "post_final_blend", buf_ptr);
+                global_index++;
+                /* clist_band_count++; */
 #endif
+            }
             /* Try again now */
             alpha_offset = 0;
             code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
-                                                rect.p.x, rect.p.y, width, height,
-                                                rowstride,
-                                                alpha_offset, tag_offset);
-        }
-        if (code > 0) {
-            /* We processed some or all of the rows.  Continue until we are done */
-            num_rows_left = height - code;
-            while (num_rows_left > 0) {
-                code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
-                                                    rect.p.x, rect.p.y+code, width,
-                                                    num_rows_left, rowstride,
-                                                    alpha_offset, tag_offset);
-                if (code < 0)
-                    return code;
-                num_rows_left = num_rows_left - code;
+                rect.p.x, rect.p.y, width, height,
+                rowstride, alpha_offset, tag_offset);
+            if (code > 0) {
+                /* We processed some or all of the rows.  Continue until we are done */
+                num_rows_left = height - code;
+                while (num_rows_left > 0) {
+                    code = dev_proc(target, put_image) (target, target, buf_ptrs, num_comp,
+                        rect.p.x, rect.p.y + code, width,
+                        num_rows_left, rowstride,
+                        alpha_offset, tag_offset);
+                    if (code < 0) {
+                        if (buf16_ptr != NULL)
+                            gs_free_object(target->memory, buf16_ptr, "gx_put_blended_image_cmykspot");
+                        return code;
+                    }
+                    num_rows_left = num_rows_left - code;
+                }
             }
+            if (buf16_ptr != NULL)
+                gs_free_object(target->memory, buf16_ptr, "gx_put_blended_image_cmykspot");
             return 0;
         }
     }
 
+    if (buf16_ptr != NULL)
+        gs_free_object(target->memory, buf16_ptr, "gx_put_blended_image_cmykspot");
+    planestride = planestride_in;
+    rowstride = rowstride_in;
+
     /* Clear all output colorants first */
     for (comp_num = 0; comp_num < output_num_comp; comp_num++)
         cv[comp_num] = 0;
@@ -792,7 +863,7 @@ gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr, int planestride,
             if ((a + 1) & 0xfe) {
                 /* a ^= 0xff; */  /* No inversion here! Bug 689895 */
                 for (comp_num = 0; comp_num < num_known_comp; comp_num++) {
-                    comp  = buf_ptr[x + planestride * input_map[comp_num]];
+                    comp = buf_ptr[x + planestride * input_map[comp_num]];
                     tmp = ((comp - bg) * a) + 0x80;
                     comp += tmp + (tmp >> 8);
                     cv[output_map[comp_num]] = comp;
@@ -807,8 +878,26 @@ gx_put_blended_image_cmykspot(gx_device *target, byte *buf_ptr, int planestride,
                     cv[output_map[comp_num]] = (comp << 8) + comp;
                 }
             }
-            color = dev_proc(target, encode_color)(target, cv);
-            code = dev_proc(target, fill_rectangle)(target, x + x0, y + y0, 1, 1, color);
+
+            /* If we have spot colors we need to encode and fill as a high level
+               color if the device supports it which should always be the case
+               if we are in this procedure */
+            if (dev_proc(target, dev_spec_op)(target, gxdso_supports_devn, NULL, 0)) {
+                for (i = 0; i < output_num_comp; i++) {
+                    pdcolor.colors.devn.values[i] = cv[i];
+                }
+                pdcolor.type = gx_dc_type_devn;
+                rect_fixed.p.x = int2fixed(x + x0);
+                rect_fixed.p.y = int2fixed(y + y0);
+                rect_fixed.q.x = int2fixed(x + x0 + 1);
+                rect_fixed.q.y = int2fixed(y + y0 + 1);
+                code = dev_proc(target, fill_rectangle_hl_color)(target, &rect_fixed,
+                    NULL, &pdcolor, NULL);
+            } else {
+                /* encode as a color index */
+                color = dev_proc(target, encode_color)(target, cv);
+                code = dev_proc(target, fill_rectangle)(target, x + x0, y + y0, 1, 1, color);
+            }
             if (code < 0)
                 return code;
         }
diff --git a/base/lib.mak b/base/lib.mak
index 2fb31d75e..b02f2210a 100644
--- a/base/lib.mak
+++ b/base/lib.mak
@@ -3071,7 +3071,7 @@ $(GLOBJ)gxblend.$(OBJ) : $(GLSRC)gxblend.c $(AK) $(gx_h) $(memory__h)\
 $(GLOBJ)gxblend1.$(OBJ) : $(GLSRC)gxblend1.c $(AK) $(gx_h) $(memory__h)\
  $(gstparam_h) $(gsrect_h) $(gxdcconv_h) $(gxblend_h) $(gxdevcli_h)\
  $(gxgstate_h) $(gdevdevn_h) $(gdevp14_h) $(png__h) $(gp_h)\
- $(gsicc_cache_h) $(LIB_MAK) $(MAKEDIRS)
+ $(gsicc_cache_h) $(gxdevsop_h) $(LIB_MAK) $(MAKEDIRS)
 	$(GLCC) $(GLO_)gxblend1.$(OBJ) $(C_) $(GLSRC)gxblend1.c
 
 $(GLOBJ)gdevp14.$(OBJ) : $(GLSRC)gdevp14.c $(AK) $(gx_h) $(gserrors_h)\
diff --git a/base/unix-gcc.mak b/base/unix-gcc.mak
index 2b38ff949..af692d151 100644
--- a/base/unix-gcc.mak
+++ b/base/unix-gcc.mak
@@ -563,7 +563,7 @@ DISPLAY_DEV=$(DD)bbox.dev
 # devs.mak and contrib.mak for the list of available devices.
 # DEVICE_DEVS=$(DISPLAY_DEV) $(DD)x11.dev $(DD)x11_.dev $(DD)x11alpha.dev $(DD)x11alt_.dev $(DD)x11cmyk.dev $(DD)x11cmyk2.dev $(DD)x11cmyk4.dev $(DD)x11cmyk8.dev $(DD)x11gray2.dev $(DD)x11gray4.dev $(DD)x11mono.dev $(DD)x11rg16x.dev $(DD)x11rg32x.dev
 DEVICE_DEVS=$(DISPLAY_DEV)
-DEVICE_DEVS1=$(DD)bit.dev $(DD)bitcmyk.dev $(DD)bitrgb.dev $(DD)bitrgbtags.dev $(DD)bmp16.dev $(DD)bmp16m.dev $(DD)bmp256.dev $(DD)bmp32b.dev $(DD)bmpgray.dev $(DD)bmpmono.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)ccr.dev $(DD)cif.dev $(DD)devicen.dev $(DD)eps2write.dev $(DD)fpng.dev $(DD)inferno.dev $(DD)ink_cov.dev $(DD)inkcov.dev $(DD)jpeg.dev $(DD)jpegcmyk.dev $(DD)jpeggray.dev $(DD)mgr4.dev $(DD)mgr8.dev $(DD)mgrgray2.dev $(DD)mgrgray4.dev $(DD)mgrgray8.dev $(DD)mgrmono.dev $(DD)miff24.dev $(DD)pam.dev $(DD)pamcmyk32.dev $(DD)pamcmyk4.dev $(DD)pbm.dev $(DD)pbmraw.dev $(DD)pcx16.dev $(DD)pcx24b.dev $(DD)pcx256.dev $(DD)pcxcmyk.dev $(DD)pcxgray.dev $(DD)pcxmono.dev $(DD)pdfwrite.dev $(DD)pgm.dev $(DD)pgmraw.dev $(DD)pgnm.dev $(DD)pgnmraw.dev $(DD)pkm.dev $(DD)pkmraw.dev $(DD)pksm.dev $(DD)pksmraw.dev $(DD)plan.dev $(DD)plan9bm.dev $(DD)planc.dev $(DD)plang.dev $(DD)plank.dev $(DD)planm.dev $(DD)plank.dev $(DD)plib.dev $(DD)plibc.dev $(DD)plibg.dev $(DD)plibk.dev $(DD)plibm.dev $(DD)pnm.dev $(DD)pnmraw.dev $(DD)ppm.dev $(DD)ppmraw.dev $(DD)ps2write.dev $(DD)psdcmyk.dev $(DD)psdcmykog.dev $(DD)psdf.dev $(DD)psdrgb.dev $(DD)spotcmyk.dev $(DD)txtwrite.dev $(DD)xcf.dev
+DEVICE_DEVS1=$(DD)bit.dev $(DD)bitcmyk.dev $(DD)bitrgb.dev $(DD)bitrgbtags.dev $(DD)bmp16.dev $(DD)bmp16m.dev $(DD)bmp256.dev $(DD)bmp32b.dev $(DD)bmpgray.dev $(DD)bmpmono.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)ccr.dev $(DD)cif.dev $(DD)devicen.dev $(DD)eps2write.dev $(DD)fpng.dev $(DD)inferno.dev $(DD)ink_cov.dev $(DD)inkcov.dev $(DD)jpeg.dev $(DD)jpegcmyk.dev $(DD)jpeggray.dev $(DD)mgr4.dev $(DD)mgr8.dev $(DD)mgrgray2.dev $(DD)mgrgray4.dev $(DD)mgrgray8.dev $(DD)mgrmono.dev $(DD)miff24.dev $(DD)pam.dev $(DD)pamcmyk32.dev $(DD)pamcmyk4.dev $(DD)pbm.dev $(DD)pbmraw.dev $(DD)pcx16.dev $(DD)pcx24b.dev $(DD)pcx256.dev $(DD)pcxcmyk.dev $(DD)pcxgray.dev $(DD)pcxmono.dev $(DD)pdfwrite.dev $(DD)pgm.dev $(DD)pgmraw.dev $(DD)pgnm.dev $(DD)pgnmraw.dev $(DD)pkm.dev $(DD)pkmraw.dev $(DD)pksm.dev $(DD)pksmraw.dev $(DD)plan.dev $(DD)plan9bm.dev $(DD)planc.dev $(DD)plang.dev $(DD)plank.dev $(DD)planm.dev $(DD)plank.dev $(DD)plib.dev $(DD)plibc.dev $(DD)plibg.dev $(DD)plibk.dev $(DD)plibm.dev $(DD)pnm.dev $(DD)pnmraw.dev $(DD)ppm.dev $(DD)ppmraw.dev $(DD)ps2write.dev $(DD)psdcmyk.dev $(DD)psdcmykog.dev $(DD)psdf.dev $(DD)psdrgb.dev $(DD)spotcmyk.dev $(DD)txtwrite.dev $(DD)xcf.dev $(DD)psdcmyk16.dev $(DD)psdrgb16.dev
 DEVICE_DEVS2=$(DD)ap3250.dev $(DD)atx23.dev $(DD)atx24.dev $(DD)atx38.dev $(DD)bj10e.dev $(DD)bj200.dev $(DD)bjc600.dev $(DD)bjc800.dev $(DD)cdeskjet.dev $(DD)cdj500.dev $(DD)cdj550.dev $(DD)cdjcolor.dev $(DD)cdjmono.dev $(DD)cljet5.dev $(DD)cljet5c.dev $(DD)cljet5pr.dev $(DD)coslw2p.dev $(DD)coslwxl.dev $(DD)declj250.dev $(DD)deskjet.dev $(DD)dj505j.dev $(DD)djet500.dev $(DD)djet500c.dev $(DD)dnj650c.dev $(DD)eps9high.dev $(DD)eps9mid.dev $(DD)epson.dev $(DD)epsonc.dev $(DD)escp.dev $(DD)fs600.dev $(DD)hl7x0.dev $(DD)ibmpro.dev $(DD)imagen.dev $(DD)itk24i.dev $(DD)itk38.dev $(DD)jetp3852.dev $(DD)laserjet.dev $(DD)lbp8.dev $(DD)lips3.dev $(DD)lj250.dev $(DD)lj3100sw.dev $(DD)lj4dith.dev $(DD)lj4dithp.dev $(DD)lj5gray.dev $(DD)lj5mono.dev $(DD)ljet2p.dev $(DD)ljet3.dev $(DD)ljet3d.dev $(DD)ljet4.dev $(DD)ljet4d.dev $(DD)ljet4pjl.dev $(DD)ljetplus.dev $(DD)lp2563.dev $(DD)lp8000.dev $(DD)lq850.dev $(DD)lxm5700m.dev $(DD)m8510.dev $(DD)necp6.dev $(DD)oce9050.dev $(DD)oki182.dev $(DD)okiibm.dev $(DD)paintjet.dev $(DD)photoex.dev $(DD)picty180.dev $(DD)pj.dev $(DD)pjetxl.dev $(DD)pjxl.dev $(DD)pjxl300.dev $(DD)pxlcolor.dev $(DD)pxlmono.dev $(DD)r4081.dev $(DD)rinkj.dev $(DD)sj48.dev $(DD)st800.dev $(DD)stcolor.dev $(DD)t4693d2.dev $(DD)t4693d4.dev $(DD)t4693d8.dev $(DD)tek4696.dev $(DD)uniprint.dev
 DEVICE_DEVS3=
 DEVICE_DEVS4=$(DD)ijs.dev
diff --git a/base/unixansi.mak b/base/unixansi.mak
index 5431749d5..647987446 100644
--- a/base/unixansi.mak
+++ b/base/unixansi.mak
@@ -362,7 +362,7 @@ DEVICE_DEVS17=$(DD)pnm.dev $(DD)pnmraw.dev $(DD)ppm.dev $(DD)ppmraw.dev $(DD)pkm
 DEVICE_DEVS18=
 DEVICE_DEVS19=
 DEVICE_DEVS20=
-DEVICE_DEVS21=$(DD)spotcmyk.dev $(DD)devicen.dev $(DD)xcf.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)bmp16m.dev $(DD)bmp32b.dev $(DD)psdcmyk.dev $(DD)psdrgb.dev $(DD)pamcmyk32.dev $(DD)psdcmykog.dev $(DD)fpng.dev
+DEVICE_DEVS21=$(DD)spotcmyk.dev $(DD)devicen.dev $(DD)xcf.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)bmp16m.dev $(DD)bmp32b.dev $(DD)psdcmyk.dev $(DD)psdrgb.dev $(DD)pamcmyk32.dev $(DD)psdcmykog.dev $(DD)fpng.dev  $(DD)psdcmyk16.dev $(DD)psdrgb16.dev
 
 # ---------------------------- End of options --------------------------- #
 
diff --git a/configure.ac b/configure.ac
index d78e20f02..ecaece75d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2101,7 +2101,7 @@ JPEG_DEVS='jpeg jpeggray jpegcmyk'
 
 PCX_DEVS='pcxmono pcxgray pcx16 pcx256 pcx24b pcxcmyk'
 PBM_DEVS='pbm pbmraw pgm pgmraw pgnm pgnmraw pnm pnmraw ppm ppmraw pkm pkmraw pksm pksmraw pam pamcmyk4 pamcmyk32 plan plang planm planc plank'
-PS_DEVS='psdf psdcmyk psdrgb pdfwrite ps2write eps2write bbox txtwrite inkcov ink_cov psdcmykog fpng pdfimage8 pdfimage24 pdfimage32 PCLm'
+PS_DEVS='psdf psdcmyk psdrgb psdcmyk16 psdrgb16 pdfwrite ps2write eps2write bbox txtwrite inkcov ink_cov psdcmykog fpng pdfimage8 pdfimage24 pdfimage32 PCLm'
 
 # the "display" device isn't an ideal fit in the list below, but it saves adding a "list" for just that one entry
 MISC_FDEVS='ccr cif inferno mgr4 mgr8 mgrgray2 mgrgray4 mgrgray8 mgrmono miff24 plan9bm bit bitrgb bitrgbtags bitcmyk devicen spotcmyk xcf plib plibg plibm plibc plibk gprf display'
diff --git a/devices/devs.mak b/devices/devs.mak
index 6c6f3dc2e..02bcbaf80 100644
--- a/devices/devs.mak
+++ b/devices/devs.mak
@@ -1217,6 +1217,12 @@ $(DD)psdrgb.dev : $(psd_) $(GLD)page.dev $(GDEV) $(DEVS_MAK) $(MAKEDIRS)
 $(DD)psdcmyk.dev : $(psd_) $(GLD)page.dev $(GDEV) $(DEVS_MAK) $(MAKEDIRS)
 	$(SETDEV) $(DD)psdcmyk $(psd_)
 
+$(DD)psdrgb16.dev : $(DEVS_MAK) $(psd_) $(GLD)page.dev $(GDEV)
+	$(SETDEV) $(DD)psdrgb16 $(psd_)
+
+$(DD)psdcmyk16.dev : $(DEVS_MAK) $(psd_) $(GLD)page.dev $(GDEV)
+	$(SETDEV) $(DD)psdcmyk16 $(psd_)
+
 $(DEVOBJ)gdevpsd.$(OBJ) : $(DEVSRC)gdevpsd.c $(PDEVH) $(math__h)\
  $(gdevdcrd_h) $(gscrd_h) $(gscrdp_h) $(gsparam_h) $(gxlum_h)\
  $(gstypes_h) $(gxdcconv_h) $(gdevdevn_h) $(gxdevsop_h) $(gsequivc_h)\
diff --git a/devices/gdevpsd.c b/devices/gdevpsd.c
index 05584d2f9..004909d26 100644
--- a/devices/gdevpsd.c
+++ b/devices/gdevpsd.c
@@ -289,6 +289,27 @@ const psd_device gs_psdrgb_device =
     GX_DOWNSCALER_PARAMS_DEFAULTS
 };
 
+const psd_device gs_psdrgb16_device =
+{
+    psd_device_body(spot_rgb_procs, "psdrgb16", 3, GX_CINFO_POLARITY_ADDITIVE, 48, 65535, 65535, GX_CINFO_SEP_LIN, "DeviceRGB"),
+    /* devn_params specific parameters */
+    { 16,	/* Bits per color - must match ncomp, depth, etc. above */
+    DeviceRGBComponents,	/* Names of color model colorants */
+    3,			/* Number colorants for RGB */
+    0,			/* MaxSeparations has not been specified */
+    -1,			/* PageSpotColors has not been specified */
+    { 0 },			/* SeparationNames */
+    0,			/* SeparationOrder names */
+    { 0, 1, 2, 3, 4, 5, 6, 7 }	/* Initial component SeparationOrder */
+    },
+    { true },			/* equivalent CMYK colors for spot colors */
+    /* PSD device specific parameters */
+    psd_DEVICE_RGB,		/* Color model */
+    GS_SOFT_MAX_SPOTS,           /* max_spots */
+    false,                      /* colorants not locked */
+    GX_DOWNSCALER_PARAMS_DEFAULTS
+};
+
 /*
  * PSD device with CMYK process color model and spot color support.
  */
@@ -320,6 +341,31 @@ const psd_device gs_psdcmyk_device =
     GX_DOWNSCALER_PARAMS_DEFAULTS
 };
 
+const psd_device gs_psdcmyk16_device =
+{
+    psd_device_body(spot_cmyk_procs, "psdcmyk16",
+    ARCH_SIZEOF_GX_COLOR_INDEX, /* Number of components - need a nominal 1 bit for each */
+    GX_CINFO_POLARITY_SUBTRACTIVE,
+    ARCH_SIZEOF_GX_COLOR_INDEX * 16, /* 8 bits per component (albeit in planes) */
+    65535, 65535, GX_CINFO_SEP_LIN, "DeviceCMYK"),
+    /* devn_params specific parameters */
+    { 16,	/* Bits per color - must match ncomp, depth, etc. above */
+    DeviceCMYKComponents,	/* Names of color model colorants */
+    4,			/* Number colorants for CMYK */
+    0,			/* MaxSeparations has not been specified */
+    -1,			/* PageSpotColors has not been specified */
+    { 0 },			/* SeparationNames */
+    0,			/* SeparationOrder names */
+    { 0, 1, 2, 3, 4, 5, 6, 7 }	/* Initial component SeparationOrder */
+    },
+    { true },			/* equivalent CMYK colors for spot colors */
+    /* PSD device specific parameters */
+    psd_DEVICE_CMYK,		/* Color model */
+    GS_SOFT_MAX_SPOTS,          /* max_spots */
+    false,                      /* colorants not locked */
+    GX_DOWNSCALER_PARAMS_DEFAULTS
+};
+
 /* Open the psd devices */
 int
 psd_prn_open(gx_device * pdev)
@@ -914,7 +960,7 @@ psd_setup(psd_write_ctx *xc, gx_devn_prn_device *dev, FILE *file, int w, int h)
         if (dev->devn_params.std_colorant_names[i] == NULL)
             break;
     }
-    xc->base_bytes_pp = dev->devn_params.num_std_colorant_names;
+    xc->base_num_channels = dev->devn_params.num_std_colorant_names;
     xc->num_channels = i;
     if (dev->color_info.polarity == GX_CINFO_POLARITY_SUBTRACTIVE) {
         if (dev->devn_params.num_separation_order_names == 0) {
@@ -1016,7 +1062,8 @@ int
 psd_write_header(psd_write_ctx *xc, gx_devn_prn_device *pdev)
 {
     int code = 0;
-    int bytes_pp = xc->num_channels;
+    int num_channels = xc->num_channels;
+    int bpc = pdev->devn_params.bitspercomponent;
     int chan_idx;
     int chan_names_len = 0;
     int sep_num;
@@ -1027,11 +1074,12 @@ psd_write_header(psd_write_ctx *xc, gx_devn_prn_device *pdev)
     /* Reserved 6 Bytes - Must be zero */
     psd_write_32(xc, 0);
     psd_write_16(xc, 0);
-    psd_write_16(xc, (bits16) bytes_pp); /* Channels (2 Bytes) - Supported range is 1 to 24 */
+    psd_write_16(xc, (bits16)num_channels); /* Channels (2 Bytes) - Supported range is 1 to 56 */
     psd_write_32(xc, xc->height); /* Rows */
     psd_write_32(xc, xc->width); /* Columns */
-    psd_write_16(xc, 8); /* Depth - 1, 8 and 16 */
-    psd_write_16(xc, (bits16) xc->base_bytes_pp); /* Mode - RGB=3, CMYK=4 */
+    psd_write_16(xc, bpc); /* Depth - 1, 8 and 16 */
+    /* Modes: Bitmap=0, Grayscale=1, RGB=3, CMYK=4 MultiChannel=7 Lab=9 */
+    psd_write_16(xc, (bits16) xc->base_num_channels);  /* We use 1, 3 or 4. */
 
     /* Color Mode Data */
     psd_write_32(xc, 0); 	/* No color mode data */
@@ -1051,7 +1099,7 @@ psd_write_header(psd_write_ctx *xc, gx_devn_prn_device *pdev)
         chan_names_len += (separation_name->size + 1);
     }
     psd_write_32(xc, 12 + (chan_names_len + (chan_names_len % 2))
-                        + (12 + (14 * (xc->num_channels - xc->base_bytes_pp)))
+                        + (12 + (14 * (xc->num_channels - xc->base_num_channels)))
                         + 28);
     psd_write(xc, (const byte *)"8BIM", 4);
     psd_write_16(xc, 1006); /* 0x03EE */
@@ -1079,7 +1127,7 @@ psd_write_header(psd_write_ctx *xc, gx_devn_prn_device *pdev)
     psd_write(xc, (const byte *)"8BIM", 4);
     psd_write_16(xc, 1007); /* 0x03EF */
     psd_write_16(xc, 0); /* PString */
-    psd_write_32(xc, 14 * (xc->num_channels - xc->base_bytes_pp)); /* Length */
+    psd_write_32(xc, 14 * (xc->num_channels - xc->base_num_channels)); /* Length */
     for (chan_idx = NUM_CMYK_COMPONENTS; chan_idx < xc->num_channels; chan_idx++) {
         sep_num = xc->chnl_to_orig_sep[chan_idx] - NUM_CMYK_COMPONENTS;
         psd_write_16(xc, 02); /* CMYK */
@@ -1136,7 +1184,8 @@ psd_write_header(psd_write_ctx *xc, gx_devn_prn_device *pdev)
     /* Layer and Mask information */
     psd_write_32(xc, 0); 	/* No layer or mask information */
 
-    psd_write_16(xc, 0); /* Compression */
+    /* Compression: 0=None, 1=RLE/PackBits, 2=Deflate 3=Defalte+Prediction */
+    psd_write_16(xc, 0);
 
     return code;
 }
@@ -1190,20 +1239,23 @@ psd_prn_close(gx_device *dev)
 static int
 psd_write_image_data(psd_write_ctx *xc, gx_device_printer *pdev)
 {
-    int raster_plane = bitmap_raster(pdev->width * 8);
+
+    psd_device *psd_dev = (psd_device *)pdev;
+    int bpc = psd_dev->devn_params.bitspercomponent;
+    int raster_plane = bitmap_raster(pdev->width * bpc);
     byte *planes[GS_CLIENT_COLOR_MAX_COMPONENTS];
     int code = 0;
     int i, j;
     byte *sep_line;
-    int base_bytes_pp = xc->base_bytes_pp;
+    int base_num_channels = xc->base_num_channels;
     int chan_idx;
-/*  psd_device *xdev = (psd_device *)pdev;
-    gcmmhlink_t link = xdev->output_icc_link; */
     byte * unpacked;
     int num_comp = xc->num_channels;
     gs_get_bits_params_t params;
     gx_downscaler_t ds = { NULL };
-    psd_device *psd_dev = (psd_device *)pdev;
+    int val;
+    int octets_per_component = bpc >> 3;
+    int octets_per_line = xc->width * octets_per_component;
 
     /* Return planar data */
     params.options = (GB_RETURN_POINTER | GB_RETURN_COPY |
@@ -1212,7 +1264,7 @@ psd_write_image_data(psd_write_ctx *xc, gx_device_printer *pdev)
     params.x_offset = 0;
     params.raster = bitmap_raster(pdev->width * pdev->color_info.depth);
 
-    sep_line = gs_alloc_bytes(pdev->memory, xc->width, "psd_write_sep_line");
+    sep_line = gs_alloc_bytes(pdev->memory, octets_per_line, "psd_write_sep_line");
 
     for (chan_idx = 0; chan_idx < num_comp; chan_idx++) {
         planes[chan_idx] = gs_alloc_bytes(pdev->memory, raster_plane,
@@ -1226,7 +1278,7 @@ psd_write_image_data(psd_write_ctx *xc, gx_device_printer *pdev)
         return_error(gs_error_VMerror);
 
     code = gx_downscaler_init_planar_trapped(&ds, (gx_device *)pdev, &params, num_comp,
-                                             psd_dev->downscale.downscale_factor, 0, 8, 8,
+                                             psd_dev->downscale.downscale_factor, 0, bpc, bpc,
                                              psd_dev->downscale.trap_w,
                                              psd_dev->downscale.trap_h,
                                              psd_dev->downscale.trap_order);
@@ -1243,29 +1295,25 @@ psd_write_image_data(psd_write_ctx *xc, gx_device_printer *pdev)
                     goto cleanup;
 
                 unpacked = params.data[data_pos];
-                /* To do, get ICC stuff in place for planar device */
-               // if (link == NULL) {
-                    if (base_bytes_pp == 3) {
-                        /* RGB */
-                        memcpy(sep_line, unpacked, xc->width);
-                    } else {
-                        for (i = 0; i < xc->width; ++i) {
-                            /* CMYK + spots*/
-                            sep_line[i] = 255 - unpacked[i];
-                        }
+
+                if (base_num_channels == 3) {
+                    memcpy(sep_line, unpacked, octets_per_line);
+                } else if (octets_per_component == 1) {
+                    for (i = 0; i < xc->width; ++i) {
+                        sep_line[i] = 255 - unpacked[i];
+                    }
+                } else { /* octets_per_component == 2 */
+                    for (i = 0; i < xc->width; ++i) {
+                        ((unsigned short *)sep_line)[i] = 65535 - ((unsigned short *)unpacked)[i];
                     }
-              /*  } else {
-                    psd_calib_row((gx_device*) xdev, xc, &sep_line, unpacked, data_pos,
-                        link, xdev->output_profile->num_comps,
-                        xdev->output_profile->num_comps_out);
-                } */
-                psd_write(xc, sep_line, xc->width);
+                }
+                psd_write(xc, sep_line, octets_per_line);
             }
         } else {
             if (chan_idx < NUM_CMYK_COMPONENTS) {
                 /* Write empty process color in the area */
-                memset(sep_line,255,xc->width);
-                psd_write(xc, sep_line, xc->width);
+                memset(sep_line,255,octets_per_line);
+                psd_write(xc, sep_line, octets_per_line);
             }
         }
     }
diff --git a/devices/gdevpsd.h b/devices/gdevpsd.h
index 20949bfcd..60c468802 100644
--- a/devices/gdevpsd.h
+++ b/devices/gdevpsd.h
@@ -22,9 +22,9 @@ typedef struct {
 
     int width;
     int height;
-    int base_bytes_pp;	/* almost always 3 (rgb) or 4 (CMYK) */
+    int base_num_channels;	/* almost always 3 (rgb) or 4 (CMYK) */
     int n_extra_channels;
-    int num_channels;	/* base_bytes_pp + any spot colors that are imaged */
+    int num_channels;	/* base_num_channels + any spot colors that are imaged */
     /* Map output channel number to original separation number. */
     int chnl_to_orig_sep[GX_DEVICE_COLOR_MAX_COMPONENTS];
     /* Map output channel number to gx_color_index position. */
diff --git a/doc/Devices.htm b/doc/Devices.htm
index 72e29656a..cdf42dbcd 100644
--- a/doc/Devices.htm
+++ b/doc/Devices.htm
@@ -503,7 +503,8 @@ the names of spot colors within a document.</p>
 
 <p>
 Generally Ghostscript will support a maximum of 64 process and spot
-colors.   The <code>tiffsep</code> device and the <code>psdcmyk</code> device maintain rendered data
+colors.   The <code>tiffsep</code> device the <code>psdcmyk</code> device
+and the <code>psdcmyk16</code> devices maintain rendered data
 in a planar form with a maximum of 64 planes set by the definition of
 GS_CLIENT_COLOR_MAX_COMPONENTS in the code.  That is there can be up to
 64 colorants accurately handled with overprint on a single page.  If more
@@ -537,7 +538,8 @@ the <code>tiffscaled</code> device. No composite file is produced in
 and <code>-dMinFeatureSize=</code> in 1bpp mode.</p>
 
 <p>When <code>-dDownScaleFactor=</code> is used in 8 bit mode with the <code>tiffsep</code>
-(and <code>psdcmyk</code>/<code>psdrgb</code>) device(s) 2 additional &quot;special&quot; ratios
+(and <code>psdcmyk</code>/<code>psdrgb</code>/<code>psdcmyk16</code>/<code>psdrgb16</code>)
+device(s) 2 additional &quot;special&quot; ratios
 are available, 32 and 34. 32 provides a 3:2 downscale (so from 300 to
 200 dpi, say). 34 produces a 3:4 upscale (so from 300 to 400 dpi, say).</p>
 
@@ -877,11 +879,16 @@ series of devices.
 
 <p>
 PSD is the image format used by Adobe Photoshop.
-It is supported by the <code>psdcmyk</code> and <code>psdrgb</code> devices.
-Of special interest with the <code>psdcmyk</code> device is that it supports spot
+It is supported by the <code>psdcmyk</code>, <code>psdrgb</code> 
+<code>psdcmyk16</code> and <code>psdrgb16</code> devices.
+Of special interest with the <code>psdcmyk</code> and <code>psdcmyk16</code> devices is that they support spot
 colors.  <a href="#tiffsep">See the comments under the <code>tiffsep</code> and <code>tiffsep1</code>
 device about the maximum number of spot colors supported by Ghostscript</a></p>
 <p>
+The <code>psdcmyk16</code> and <code>psdrgb16</code> devices are essentially the same
+as the <code>psdcmyk</code> and <code>psdrgb</code> devices except they provide 16 bit output. 
+</p>
+<p>
 The <code>psdcmykog</code> device produces PSD files with 6 components:
 Cyan, Magenta, Yellow, blacK, Orange, and Green.  This device does not support the -dDownScaleFactor=
 option (see below), instead it always scales down by a factor of two.</p>
diff --git a/psi/msvc.mak b/psi/msvc.mak
index 3f547122b..8da268ea9 100644
--- a/psi/msvc.mak
+++ b/psi/msvc.mak
@@ -1470,7 +1470,7 @@ DEVICE_DEVS17=$(DD)ljet3.dev $(DD)ljet3d.dev $(DD)ljet4.dev $(DD)ljet4d.dev
 DEVICE_DEVS18=$(DD)pj.dev $(DD)pjxl.dev $(DD)pjxl300.dev $(DD)jetp3852.dev $(DD)r4081.dev
 DEVICE_DEVS19=$(DD)lbp8.dev $(DD)m8510.dev $(DD)necp6.dev $(DD)bjc600.dev $(DD)bjc800.dev
 DEVICE_DEVS20=$(DD)pnm.dev $(DD)pnmraw.dev $(DD)ppm.dev $(DD)ppmraw.dev $(DD)pamcmyk32.dev $(DD)pamcmyk4.dev $(DD)pnmcmyk.dev $(DD)pam.dev
-DEVICE_DEVS21=$(DD)spotcmyk.dev $(DD)devicen.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)bmp16m.dev $(DD)bmp32b.dev $(DD)psdcmyk.dev $(DD)psdrgb.dev $(DD)gprf.dev
+DEVICE_DEVS21=$(DD)spotcmyk.dev $(DD)devicen.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)bmp16m.dev $(DD)bmp32b.dev $(DD)psdcmyk.dev $(DD)psdrgb.dev $(DD)gprf.dev $(DD)psdcmyk16.dev $(DD)psdrgb16.dev
 !endif
 CONTRIB_DEVS=$(DD)pcl3.dev $(DD)hpdjplus.dev $(DD)hpdjportable.dev $(DD)hpdj310.dev $(DD)hpdj320.dev $(DD)hpdj340.dev $(DD)hpdj400.dev $(DD)hpdj500.dev $(DD)hpdj500c.dev $(DD)hpdj510.dev $(DD)hpdj520.dev $(DD)hpdj540.dev $(DD)hpdj550c.dev $(DD)hpdj560c.dev $(DD)hpdj600.dev $(DD)hpdj660c.dev $(DD)hpdj670c.dev $(DD)hpdj680c.dev $(DD)hpdj690c.dev $(DD)hpdj850c.dev $(DD)hpdj855c.dev $(DD)hpdj870c.dev $(DD)hpdj890c.dev $(DD)hpdj1120c.dev $(DD)cdj670.dev $(DD)cdj850.dev $(DD)cdj880.dev $(DD)cdj890.dev $(DD)cdj970.dev $(DD)cdj1600.dev $(DD)cdnj500.dev $(DD)chp2200.dev $(DD)lips3.dev $(DD)lxm3200.dev $(DD)lex2050.dev $(DD)lxm3200.dev $(DD)lex5700.dev $(DD)lex7000.dev $(DD)oki4w.dev $(DD)gdi.dev $(DD)samsunggdi.dev $(DD)dl2100.dev $(DD)la50.dev $(DD)la70.dev $(DD)la75.dev $(DD)la75plus.dev $(DD)ln03.dev $(DD)xes.dev $(DD)md2k.dev $(DD)md5k.dev $(DD)lips4.dev $(DD)bj10v.dev $(DD)bj10vh.dev $(DD)md50Mono.dev $(DD)md50Eco.dev $(DD)md1xMono.dev $(DD)lp2000.dev $(DD)escpage.dev $(DD)npdl.dev $(DD)rpdl.dev $(DD)fmpr.dev $(DD)fmlbp.dev $(DD)jj100.dev $(DD)lbp310.dev $(DD)lbp320.dev $(DD)mj700v2c.dev $(DD)mj500c.dev $(DD)mj6000c.dev $(DD)mj8000c.dev $(DD)pr201.dev $(DD)pr150.dev $(DD)pr1000.dev $(DD)pr1000_4.dev $(DD)lips2p.dev $(DD)bjc880j.dev $(DD)bjcmono.dev $(DD)bjcgray.dev $(DD)bjccmyk.dev $(DD)bjccolor.dev