New upstream version 1.0.29upstream/1.0.29

1 files changed, 1187 insertions, 0 deletions

diff --git a/backend/pixma/pixma_common.c b/backend/pixma/pixma_common.c
new file mode 100644
index 0000000..7b7ecec
--- /dev/null
+++ b/backend/pixma/pixma_common.c
@@ -0,0 +1,1187 @@
+/* SANE - Scanner Access Now Easy.
+
+   Copyright (C) 2011-2019 Rolf Bensch <rolf at bensch hyphen online dot de>
+   Copyright (C) 2007-2008 Nicolas Martin, <nicols-guest at alioth dot debian dot org>
+   Copyright (C) 2006-2007 Wittawat Yamwong <wittawat@web.de>
+
+   This file is part of the SANE package.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, the authors of SANE give permission for
+   additional uses of the libraries contained in this release of SANE.
+
+   The exception is that, if you link a SANE library with other files
+   to produce an executable, this does not by itself cause the
+   resulting executable to be covered by the GNU General Public
+   License.  Your use of that executable is in no way restricted on
+   account of linking the SANE library code into it.
+
+   This exception does not, however, invalidate any other reasons why
+   the executable file might be covered by the GNU General Public
+   License.
+
+   If you submit changes to SANE to the maintainers to be included in
+   a subsequent release, you agree by submitting the changes that
+   those changes may be distributed with this exception intact.
+
+   If you write modifications of your own for SANE, it is your choice
+   whether to permit this exception to apply to your modifications.
+   If you do not wish that, delete this exception notice.
+ */
+#include "../include/sane/config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <math.h>		/* pow(C90) */
+
+#include <sys/time.h>		/* gettimeofday(4.3BSD) */
+#include <unistd.h>		/* usleep */
+
+#include "pixma_rename.h"
+#include "pixma_common.h"
+#include "pixma_io.h"
+
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/sane.h"
+
+#ifdef __GNUC__
+# define UNUSED(v) (void) v
+#else
+# define UNUSED(v)
+#endif
+
+extern const pixma_config_t pixma_mp150_devices[];
+extern const pixma_config_t pixma_mp750_devices[];
+extern const pixma_config_t pixma_mp730_devices[];
+extern const pixma_config_t pixma_mp800_devices[];
+extern const pixma_config_t pixma_iclass_devices[];
+
+static const pixma_config_t *const pixma_devices[] = {
+  pixma_mp150_devices,
+  pixma_mp750_devices,
+  pixma_mp730_devices,
+  pixma_mp800_devices,
+  pixma_iclass_devices,
+  NULL
+};
+
+static pixma_t *first_pixma = NULL;
+static time_t tstart_sec = 0;
+static uint32_t tstart_usec = 0;
+static int debug_level = 1;
+
+
+#ifndef NDEBUG
+
+static void
+u8tohex (uint8_t x, char *str)
+{
+  static const char hdigit[16] =
+    { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
+    'e', 'f'
+    };
+  str[0] = hdigit[(x >> 4) & 0xf];
+  str[1] = hdigit[x & 0xf];
+  str[2] = '\0';
+}
+
+static void
+u32tohex (uint32_t x, char *str)
+{
+  u8tohex (x >> 24, str);
+  u8tohex (x >> 16, str + 2);
+  u8tohex (x >> 8, str + 4);
+  u8tohex (x, str + 6);
+}
+
+void
+pixma_hexdump (int level, const void *d_, unsigned len)
+{
+  const uint8_t *d = (const uint8_t *) (d_);
+  unsigned ofs, c, plen;
+  char line[100];		/* actually only 1+8+1+8*3+1+8*3+1 = 61 bytes needed */
+
+  if (level > debug_level)
+    return;
+  if (level == debug_level)
+    /* if debuglevel == exact match and buffer contains more than 3 lines, print 2 lines + .... */
+    plen = (len > 64) ? 32: len;
+  else
+    plen = len;
+  ofs = 0;
+  while (ofs < plen)
+    {
+      char *p;
+      line[0] = ' ';
+      u32tohex (ofs, line + 1);
+      line[9] = ':';
+      p = line + 10;
+      for (c = 0; c != 16 && (ofs + c) < plen; c++)
+        {
+          u8tohex (d[ofs + c], p);
+          p[2] = ' ';
+          p += 3;
+          if (c == 7)
+            {
+              p[0] = ' ';
+              p++;
+            }
+        }
+      p[0] = '\0';
+      pixma_dbg (level, "%s\n", line);
+      ofs += c;
+    }
+  if (len > plen)
+    pixma_dbg(level, "......\n");
+}
+
+static void
+time2str (char *buf, unsigned size)
+{
+  time_t sec;
+  uint32_t usec;
+
+  pixma_get_time (&sec, &usec);
+  sec -= tstart_sec;
+  if (usec >= tstart_usec)
+    {
+      usec -= tstart_usec;
+    }
+  else
+    {
+      usec = 1000000 + usec - tstart_usec;
+      sec--;
+    }
+  snprintf (buf, size, "%lu.%03u", (unsigned long) sec,
+	    (unsigned) (usec / 1000));
+}
+
+void
+pixma_dump (int level, const char *type, const void *data, int len,
+	    int size, int max)
+{
+  int actual_len, print_len;
+  char buf[20];
+
+  if (level > debug_level)
+    return;
+  if (debug_level >= 20)
+    max = -1;			/* dump every bytes */
+
+  time2str (buf, sizeof (buf));
+  pixma_dbg (level, "%s T=%s len=%d\n", type, buf, len);
+
+  actual_len = (size >= 0) ? size : len;
+  print_len = (max >= 0 && max < actual_len) ? max : actual_len;
+  if (print_len >= 0)
+    {
+      pixma_hexdump (level, data, print_len);
+      if (print_len < actual_len)
+	pixma_dbg (level, " ...\n");
+    }
+  if (len < 0)
+    pixma_dbg (level, "  ERROR: %s\n", pixma_strerror (len));
+  pixma_dbg (level, "\n");
+}
+
+
+#endif /* NDEBUG */
+
+/* NOTE: non-reentrant */
+const char *
+pixma_strerror (int error)
+{
+  static char buf[50];
+
+  /* TODO: more human friendly messages */
+  switch (error)
+    {
+    case PIXMA_EIO:
+      return "EIO";
+    case PIXMA_ENODEV:
+      return "ENODEV";
+    case PIXMA_EACCES:
+      return "EACCES";
+    case PIXMA_ENOMEM:
+      return "ENOMEM";
+    case PIXMA_EINVAL:
+      return "EINVAL";
+    case PIXMA_EBUSY:
+      return "EBUSY";
+    case PIXMA_ECANCELED:
+      return "ECANCELED";
+    case PIXMA_ENOTSUP:
+      return "ENOTSUP";
+    case PIXMA_ETIMEDOUT:
+      return "ETIMEDOUT";
+    case PIXMA_EPROTO:
+      return "EPROTO";
+    case PIXMA_EPAPER_JAMMED:
+      return "EPAPER_JAMMED";
+    case PIXMA_ECOVER_OPEN:
+      return "ECOVER_OPEN";
+    case PIXMA_ENO_PAPER:
+      return "ENO_PAPER";
+    case PIXMA_EOF:
+      return "EEOF";
+    }
+  snprintf (buf, sizeof (buf), "EUNKNOWN:%d", error);
+  return buf;
+}
+
+void
+pixma_set_debug_level (int level)
+{
+  debug_level = level;
+}
+
+void
+pixma_set_be16 (uint16_t x, uint8_t * buf)
+{
+  buf[0] = x >> 8;
+  buf[1] = x;
+}
+
+void
+pixma_set_be32 (uint32_t x, uint8_t * buf)
+{
+  buf[0] = x >> 24;
+  buf[1] = x >> 16;
+  buf[2] = x >> 8;
+  buf[3] = x;
+}
+
+uint16_t
+pixma_get_be16 (const uint8_t * buf)
+{
+  return ((uint16_t) buf[0] << 8) | buf[1];
+}
+
+uint32_t
+pixma_get_be32 (const uint8_t * buf)
+{
+  return ((uint32_t) buf[0] << 24) + ((uint32_t) buf[1] << 16) +
+    ((uint32_t) buf[2] << 8) + buf[3];
+}
+
+uint8_t
+pixma_sum_bytes (const void *data, unsigned len)
+{
+  const uint8_t *d = (const uint8_t *) data;
+  unsigned i, sum = 0;
+  for (i = 0; i != len; i++)
+    sum += d[i];
+  return sum;
+}
+
+void
+pixma_sleep (unsigned long usec)
+{
+  usleep (usec);
+}
+
+void
+pixma_get_time (time_t * sec, uint32_t * usec)
+{
+  struct timeval tv;
+  gettimeofday (&tv, NULL);
+  if (sec)
+    *sec = tv.tv_sec;
+  if (usec)
+    *usec = tv.tv_usec;
+}
+
+/* convert 24/48 bit RGB to 8/16 bit ir
+ *
+ * Formular: g = R
+ *           drop G + B
+ *
+ * sptr: source color scale buffer
+ * gptr: destination gray scale buffer
+ * c == 3: 24 bit RGB -> 8 bit ir
+ * c == 6: 48 bit RGB -> 16 bit ir
+ */
+uint8_t *
+pixma_r_to_ir (uint8_t * gptr, uint8_t * sptr, unsigned w, unsigned c)
+{
+  unsigned i;
+
+  /* PDBG (pixma_dbg (4, "*pixma_rgb_to_ir*****\n")); */
+
+  for (i = 0; i < w; i++)
+    {
+      *gptr++ = *sptr++;
+      if (c == 6) *gptr++ = *sptr++;            /* 48 bit RGB: high byte */
+      sptr += (c == 6) ? 4 : 2;                 /* drop G + B */
+    }
+  return gptr;
+}
+
+/* convert 24/48 bit RGB to 8/16 bit grayscale
+ *
+ * Formular: g = (R + G + B) / 3
+ *
+ * sptr: source color scale buffer
+ * gptr: destination gray scale buffer
+ * c == 3: 24 bit RGB -> 8 bit gray
+ * c == 6: 48 bit RGB -> 16 bit gray
+ */
+uint8_t *
+pixma_rgb_to_gray (uint8_t * gptr, uint8_t * sptr, unsigned w, unsigned c)
+{
+  unsigned i, j, g;
+
+  /* PDBG (pixma_dbg (4, "*pixma_rgb_to_gray*****\n")); */
+
+  for (i = 0; i < w; i++)
+    {
+      for (j = 0, g = 0; j < 3; j++)
+        {
+          g += *sptr++;
+          if (c == 6) g += (*sptr++ << 8);      /* 48 bit RGB: high byte */
+        }
+
+      g /= 3;                                   /* 8 or 16 bit gray */
+      *gptr++ = g;
+      if (c == 6) *gptr++ = (g >> 8);           /* 16 bit gray: high byte */
+    }
+  return gptr;
+}
+
+/**
+ * This code was taken from the genesys backend
+ * uses threshold and threshold_curve to control software binarization
+ * @param sp    device set up for the scan
+ * @param dst   pointer where to store result
+ * @param src   pointer to raw data
+ * @param width width of the processed line
+ * @param c     1 for 1-channel single-byte data,
+ *              3 for 3-channel single-byte data,
+ *              6 for double-byte data
+ * */
+uint8_t *
+pixma_binarize_line(pixma_scan_param_t * sp, uint8_t * dst, uint8_t * src, unsigned width, unsigned c)
+{
+  unsigned j, x, windowX, sum = 0;
+  unsigned threshold;
+  unsigned offset, addCol;
+  int dropCol, offsetX;
+  unsigned char mask;
+  uint8_t min, max;
+
+  /* PDBG (pixma_dbg (4, "*pixma_binarize_line***** src = %u, dst = %u, width = %u, c = %u, threshold = %u, threshold_curve = %u *****\n",
+                      src, dst, width, c, sp->threshold, sp->threshold_curve)); */
+
+  /* 16 bit grayscale not supported */
+  if (c == 6)
+    {
+      PDBG (pixma_dbg (1, "*pixma_binarize_line***** Error: 16 bit grayscale not supported\n"));
+      return dst;
+    }
+
+  /* first, color convert to grayscale */
+    if (c != 1)
+      pixma_rgb_to_gray(dst, src, width, c);
+
+  /* second, normalize line */
+    min = 255;
+    max = 0;
+    for (x = 0; x < width; x++)
+      {
+        if (src[x] > max)
+          {
+            max = src[x];
+          }
+        if (src[x] < min)
+          {
+            min = src[x];
+          }
+      }
+
+    /* safeguard against dark or white areas */
+    if(min>80)
+        min=0;
+    if(max<80)
+        max=255;
+    for (x = 0; x < width; x++)
+      {
+        src[x] = ((src[x] - min) * 255) / (max - min);
+      }
+
+  /* third, create sliding window, prefill the sliding sum */
+    /* ~1mm works best, but the window needs to have odd # of pixels */
+    windowX = (6 * sp->xdpi) / 150;
+    if (!(windowX % 2))
+      windowX++;
+
+    /* to avoid conflicts with *dst start with offset */
+    offsetX = 1 + (windowX / 2) / 8;
+    for (j = offsetX; j <= windowX; j++)
+      sum += src[j];
+    /* PDBG (pixma_dbg (4, " *pixma_binarize_line***** windowX = %u, startX = %u, sum = %u\n",
+                     windowX, startX, sum)); */
+
+  /* fourth, walk the input buffer, output bits */
+    for (j = 0; j < width; j++)
+      {
+        /* output image location */
+        offset = j % 8;
+        mask = 0x80 >> offset;
+        threshold = sp->threshold;
+
+        /* move sum/update threshold only if there is a curve */
+        if (sp->threshold_curve)
+          {
+            addCol = j + windowX / 2;
+            dropCol = addCol - windowX;
+
+            if (dropCol >= offsetX && addCol < width)
+              {
+                sum += src[addCol];
+                sum -= (sum < src[dropCol] ? sum : src[dropCol]);       /* no negative sum */
+              }
+            threshold = sp->lineart_lut[sum / windowX];
+            /* PDBG (pixma_dbg (4, " *pixma_binarize_line***** addCol = %u, dropCol = %d, sum = %u, windowX = %u, lut-element = %d, threshold = %u\n",
+                             addCol, dropCol, sum, windowX, sum/windowX, threshold)); */
+          }
+
+        /* lookup threshold */
+        if (src[j] > threshold)
+            *dst &= ~mask;      /* white */
+        else
+            *dst |= mask;       /* black */
+
+        if (offset == 7)
+            dst++;
+      }
+
+  /* PDBG (pixma_dbg (4, " *pixma_binarize_line***** ready: src = %u, dst = %u *****\n", src, dst)); */
+
+  return dst;
+}
+
+/**
+   This code was taken from the genesys backend
+   Function to build a lookup table (LUT), often
+   used by scanners to implement brightness/contrast/gamma
+   or by backends to speed binarization/thresholding
+
+   offset and slope inputs are -127 to +127
+
+   slope rotates line around central input/output val,
+   0 makes horizontal line
+
+       pos           zero          neg
+       .       x     .             .  x
+       .      x      .             .   x
+   out .     x       .xxxxxxxxxxx  .    x
+       .    x        .             .     x
+       ....x.......  ............  .......x....
+            in            in            in
+
+   offset moves line vertically, and clamps to output range
+   0 keeps the line crossing the center of the table
+
+       high           low
+       .   xxxxxxxx   .
+       . x            .
+   out x              .          x
+       .              .        x
+       ............   xxxxxxxx....
+            in             in
+
+   out_min/max provide bounds on output values,
+   useful when building thresholding lut.
+   0 and 255 are good defaults otherwise.
+  * */
+static SANE_Status
+load_lut (unsigned char * lut,
+  int in_bits, int out_bits,
+  int out_min, int out_max,
+  int slope, int offset)
+{
+  int i, j;
+  double shift, rise;
+  int max_in_val = (1 << in_bits) - 1;
+  int max_out_val = (1 << out_bits) - 1;
+  unsigned char * lut_p = lut;
+
+  /* PDBG (pixma_dbg (4, "*load_lut***** start %d %d *****\n", slope, offset)); */
+
+  /* slope is converted to rise per unit run:
+   * first [-127,127] to [-1,1]
+   * then multiply by PI/2 to convert to radians
+   * then take the tangent (T.O.A)
+   * then multiply by the normal linear slope
+   * because the table may not be square, i.e. 1024x256*/
+  rise = tan((double)slope/127 * M_PI/2) * max_out_val / max_in_val;
+
+  /* line must stay vertically centered, so figure
+   * out vertical offset at central input value */
+  shift = (double)max_out_val/2 - (rise*max_in_val/2);
+
+  /* convert the user offset setting to scale of output
+   * first [-127,127] to [-1,1]
+   * then to [-max_out_val/2,max_out_val/2]*/
+  shift += (double)offset / 127 * max_out_val / 2;
+
+  for(i=0;i<=max_in_val;i++){
+    j = rise*i + shift;
+
+    if(j<out_min){
+      j=out_min;
+    }
+    else if(j>out_max){
+      j=out_max;
+    }
+
+    *lut_p=j;
+    lut_p++;
+  }
+
+  /* PDBG (pixma_dbg (4, "*load_lut***** finish *****\n")); */
+  /* PDBG (pixma_hexdump (4, lut, max_in_val+1)); */
+
+  return SANE_STATUS_GOOD;
+}
+
+int
+pixma_map_status_errno (unsigned status)
+{
+  switch (status)
+    {
+    case PIXMA_STATUS_OK:
+      return 0;
+    case PIXMA_STATUS_FAILED:
+      return PIXMA_ECANCELED;
+    case PIXMA_STATUS_BUSY:
+      return PIXMA_EBUSY;
+    default:
+      return PIXMA_EPROTO;
+    }
+}
+
+int
+pixma_check_result (pixma_cmdbuf_t * cb)
+{
+  const uint8_t *r = cb->buf;
+  unsigned header_len = cb->res_header_len;
+  unsigned expected_reslen = cb->expected_reslen;
+  int error;
+  unsigned len;
+
+  if (cb->reslen < 0)
+    return cb->reslen;
+
+  len = (unsigned) cb->reslen;
+  if (len >= header_len)
+    {
+      error = pixma_map_status_errno (pixma_get_be16 (r));
+      if (expected_reslen != 0)
+        {
+          if (len == expected_reslen)
+            {
+              if (pixma_sum_bytes (r + header_len, len - header_len) != 0)
+                 error = PIXMA_EPROTO;
+            }
+          else
+            {
+              /* This case will happen when a command cannot be completely
+                 executed, e.g. because you press the cancel button. The
+                 device will return only a header with PIXMA_STATUS_FAILED. */
+              if (len != header_len)
+                 error = PIXMA_EPROTO;
+            }
+        }
+    }
+  else
+    error = PIXMA_EPROTO;
+
+#ifndef NDEBUG
+  if (error == PIXMA_EPROTO)
+    {
+      pixma_dbg (1, "WARNING: result len=%d expected %d\n",
+		 len, cb->expected_reslen);
+      pixma_hexdump (1, r, MIN (len, 64));
+    }
+#endif
+  return error;
+}
+
+int
+pixma_cmd_transaction (pixma_t * s, const void *cmd, unsigned cmdlen,
+		       void *data, unsigned expected_len)
+{
+  int error, tmo;
+
+  error = pixma_write (s->io, cmd, cmdlen);
+  if (error != (int) cmdlen)
+    {
+      if (error >= 0)
+        {
+          /* Write timeout is too low? */
+          PDBG (pixma_dbg
+          (1, "ERROR: incomplete write, %u out of %u written\n",
+           (unsigned) error, cmdlen));
+          error = PIXMA_ETIMEDOUT;
+        }
+      return error;
+    }
+
+  /* When you send the start_session command while the scanner optic is
+     going back to the home position after the last scan session has been
+     cancelled, you won't get the response before it arrives home. This takes
+     about 5 seconds. If the last session was succeeded, the scanner will
+     immediatly answer with PIXMA_STATUS_BUSY.
+
+     Is 8 seconds timeout enough? This affects ALL commands that use
+     pixma_cmd_transaction(). Default value set in pixma_open(). */
+  tmo = s->rec_tmo;
+  do
+    {
+      error = pixma_read (s->io, data, expected_len);
+      if (error == PIXMA_ETIMEDOUT)
+      {
+        PDBG (pixma_dbg (2, "No response yet. Timed out in %d sec.\n", tmo));
+
+#ifndef HAVE_SANEI_USB_SET_TIMEOUT
+        /* 1s timeout
+           Only needed, if sanei_usb_set_timeout() isn't available.
+           pixma_read() has an internal timeout of 1 sec. */
+        pixma_sleep (1000000);
+#endif
+      }
+    }
+  while (error == PIXMA_ETIMEDOUT && --tmo != 0);
+  if (error < 0)
+    {
+      PDBG (pixma_dbg (1, "WARNING: Error in response phase. cmd:%02x%02x\n",
+		       ((const uint8_t *) cmd)[0],
+		       ((const uint8_t *) cmd)[1]));
+      PDBG (pixma_dbg (1,"  If the scanner hangs, reset it and/or unplug the "
+	                       "USB cable.\n"));
+    }
+  return error;			/* length of the result packet or error */
+}
+
+uint8_t *
+pixma_newcmd (pixma_cmdbuf_t * cb, unsigned cmd,
+	      unsigned dataout, unsigned datain)
+{
+  unsigned cmdlen = cb->cmd_header_len + dataout;
+  unsigned reslen = cb->res_header_len + datain;
+
+  if (cmdlen > cb->size || reslen > cb->size)
+    return NULL;
+  memset (cb->buf, 0, cmdlen);
+  cb->cmdlen = cmdlen;
+  cb->expected_reslen = reslen;
+  pixma_set_be16 (cmd, cb->buf);
+  pixma_set_be16 (dataout + datain, cb->buf + cb->cmd_len_field_ofs);
+  if (dataout != 0)
+    return cb->buf + cb->cmd_header_len;
+  else
+    return cb->buf + cb->res_header_len;
+}
+
+int
+pixma_exec (pixma_t * s, pixma_cmdbuf_t * cb)
+{
+  if (cb->cmdlen > cb->cmd_header_len)
+    pixma_fill_checksum (cb->buf + cb->cmd_header_len,
+			 cb->buf + cb->cmdlen - 1);
+  cb->reslen =
+    pixma_cmd_transaction (s, cb->buf, cb->cmdlen, cb->buf,
+			   cb->expected_reslen);
+  return pixma_check_result (cb);
+}
+
+int
+pixma_exec_short_cmd (pixma_t * s, pixma_cmdbuf_t * cb, unsigned cmd)
+{
+  pixma_newcmd (cb, cmd, 0, 0);
+  return pixma_exec (s, cb);
+}
+
+int
+pixma_check_dpi (unsigned dpi, unsigned max)
+{
+  /* valid dpi = 75 * 2^n */
+  unsigned temp = dpi / 75;
+  if (dpi > max || dpi < 75 || 75 * temp != dpi || (temp & (temp - 1)) != 0)
+    return PIXMA_EINVAL;
+  return 0;
+}
+
+
+int
+pixma_init (void)
+{
+  PDBG (pixma_dbg (2, "pixma version %d.%d.%d\n", PIXMA_VERSION_MAJOR,
+		   PIXMA_VERSION_MINOR, PIXMA_VERSION_BUILD));
+  PASSERT (first_pixma == NULL);
+  if (tstart_sec == 0)
+    pixma_get_time (&tstart_sec, &tstart_usec);
+  return pixma_io_init ();
+}
+
+void
+pixma_cleanup (void)
+{
+  while (first_pixma)
+    pixma_close (first_pixma);
+  pixma_io_cleanup ();
+}
+
+int
+pixma_open (unsigned devnr, pixma_t ** handle)
+{
+  int error;
+  pixma_t *s;
+  const pixma_config_t *cfg;
+
+  *handle = NULL;
+  cfg = pixma_get_device_config (devnr);
+  if (!cfg)
+    return PIXMA_EINVAL;	/* invalid devnr */
+  PDBG (pixma_dbg (2, "pixma_open(): %s\n", cfg->name));
+
+  s = (pixma_t *) calloc (1, sizeof (s[0]));
+  if (!s)
+    return PIXMA_ENOMEM;
+  s->next = first_pixma;
+  first_pixma = s;
+
+  s->cfg = cfg;
+  s->rec_tmo = 8;               /* set receive timeout to 8 seconds */
+  error = pixma_connect (devnr, &s->io);
+  if (error < 0)
+    {
+      PDBG (pixma_dbg
+	    (2, "pixma_connect() failed %s\n", pixma_strerror (error)));
+      goto rollback;
+    }
+  strncpy (s->id, pixma_get_device_id (devnr), sizeof (s->id) - 1);
+  s->ops = s->cfg->ops;
+  s->scanning = 0;
+  error = s->ops->open (s);
+  if (error < 0)
+    goto rollback;
+  error = pixma_deactivate (s->io);
+  if (error < 0)
+    goto rollback;
+  *handle = s;
+  return 0;
+
+rollback:
+  PDBG (pixma_dbg (2, "pixma_open() failed %s\n", pixma_strerror (error)));
+  pixma_close (s);
+  return error;
+}
+
+void
+pixma_close (pixma_t * s)
+{
+  pixma_t **p;
+
+  if (!s)
+    return;
+  for (p = &first_pixma; *p && *p != s; p = &((*p)->next))
+    {
+    }
+  PASSERT (*p);
+  if (!(*p))
+    return;
+  PDBG (pixma_dbg (2, "pixma_close(): %s\n", s->cfg->name));
+  if (s->io)
+    {
+      if (s->scanning)
+	{
+	  PDBG (pixma_dbg (3, "pixma_close(): scanning in progress, call"
+			   " finish_scan()\n"));
+	  s->ops->finish_scan (s);
+	}
+      s->ops->close (s);
+      pixma_disconnect (s->io);
+    }
+  *p = s->next;
+  free (s);
+}
+
+int
+pixma_scan (pixma_t * s, pixma_scan_param_t * sp)
+{
+  int error;
+
+  error = pixma_check_scan_param (s, sp);
+  if (error < 0)
+    return error;
+
+  if (sp->mode == PIXMA_SCAN_MODE_LINEART)
+    {
+      load_lut(sp->lineart_lut, 8, 8, 50, 205,
+               sp->threshold_curve, sp->threshold-127);
+    }
+
+#ifndef NDEBUG
+  pixma_dbg (3, "\n");
+  pixma_dbg (3, "pixma_scan(): start\n");
+  pixma_dbg (3, "  line_size=%"PRIu64" image_size=%"PRIu64" channels=%u depth=%u\n",
+	     sp->line_size, sp->image_size, sp->channels, sp->depth);
+  pixma_dbg (3, "  dpi=%ux%u offset=(%u,%u) dimension=%ux%u\n",
+	     sp->xdpi, sp->ydpi, sp->x, sp->y, sp->w, sp->h);
+  pixma_dbg (3, "  gamma_table=%p source=%d\n", sp->gamma_table, sp->source);
+  pixma_dbg (3, "  threshold=%d threshold_curve=%d\n", sp->threshold, sp->threshold_curve);
+  pixma_dbg (3, "  adf-wait=%d\n", sp->adf_wait);
+  pixma_dbg (3, "  ADF page count: %d\n", sp->adf_pageid);
+#endif
+
+  s->param = sp;
+  s->cancel = 0;
+  s->cur_image_size = 0;
+  s->imagebuf.wptr = NULL;
+  s->imagebuf.wend = NULL;
+  s->imagebuf.rptr = NULL;
+  s->imagebuf.rend = NULL;
+  s->underrun = 0;
+  error = s->ops->scan (s);
+  if (error >= 0)
+    {
+      s->scanning = 1;
+    }
+  else
+    {
+      PDBG (pixma_dbg
+	    (3, "pixma_scan() failed %s\n", pixma_strerror (error)));
+    }
+
+  return error;
+}
+
+static uint8_t *
+fill_pixels (pixma_t * s, uint8_t * ptr, uint8_t * end, uint8_t value)
+{
+  if (s->cur_image_size < s->param->image_size)
+    {
+      long n = s->param->image_size - s->cur_image_size;
+      if (n > (end - ptr))
+	n = end - ptr;
+      memset (ptr, value, n);
+      s->cur_image_size += n;
+      ptr += n;
+    }
+  return ptr;
+}
+
+int
+pixma_read_image (pixma_t * s, void *buf, unsigned len)
+{
+  int result;
+  pixma_imagebuf_t ib;
+
+  if (!s->scanning)
+    return 0;
+  if (s->cancel)
+    {
+      result = PIXMA_ECANCELED;
+      goto cancel;
+    }
+
+  ib = s->imagebuf;		/* get rptr and rend */
+  ib.wptr = (uint8_t *) buf;
+  ib.wend = ib.wptr + len;
+
+  if (s->underrun)
+    {
+      if (s->cur_image_size < s->param->image_size)
+        {
+          ib.wptr = fill_pixels (s, ib.wptr, ib.wend, 0xff);
+        }
+      else
+        {
+          PDBG (pixma_dbg
+          (3, "pixma_read_image(): completed (underrun detected)\n"));
+          s->scanning = 0;
+        }
+      return ib.wptr - (uint8_t *) buf;
+    }
+
+  while (ib.wptr != ib.wend)
+    {
+      if (ib.rptr == ib.rend)
+        {
+          ib.rptr = ib.rend = NULL;
+          result = s->ops->fill_buffer (s, &ib);
+          if (result < 0)
+            goto cancel;
+          if (result == 0)
+            {			/* end of image? */
+              s->ops->finish_scan (s);
+              if ((s->cur_image_size != s->param->image_size) && !s->param->mode_jpeg)
+                {
+                  pixma_dbg (1, "WARNING:image size mismatches\n");
+                  pixma_dbg (1,
+                       "    %"PRIu64" expected (%d lines) but %"PRIu64" received (%"PRIu64" lines)\n",
+                       s->param->image_size, s->param->h,
+                       s->cur_image_size,
+                       s->cur_image_size / s->param->line_size);
+                  if ((s->cur_image_size % s->param->line_size) != 0)
+                    {
+                      pixma_dbg (1,
+                     "BUG:received data not multiple of line_size\n");
+                    }
+                }
+              if ((s->cur_image_size < s->param->image_size) && !s->param->mode_jpeg)
+                {
+                  s->underrun = 1;
+                  ib.wptr = fill_pixels (s, ib.wptr, ib.wend, 0xff);
+                }
+              else
+                {
+                  PDBG (pixma_dbg (3, "pixma_read_image():completed\n"));
+                  s->scanning = 0;
+                }
+              break;
+            }
+          s->cur_image_size += result;
+
+          PASSERT (s->cur_image_size <= s->param->image_size);
+        }
+      if (ib.rptr)
+        {
+          unsigned count = MIN (ib.rend - ib.rptr, ib.wend - ib.wptr);
+          memcpy (ib.wptr, ib.rptr, count);
+          ib.rptr += count;
+          ib.wptr += count;
+        }
+    }
+  s->imagebuf = ib;		/* store rptr and rend */
+  return ib.wptr - (uint8_t *) buf;
+
+cancel:
+  s->ops->finish_scan (s);
+  s->scanning = 0;
+  if (result == PIXMA_ECANCELED)
+    {
+      PDBG (pixma_dbg (3, "pixma_read_image(): cancelled by %sware\n",
+		       (s->cancel) ? "soft" : "hard"));
+    }
+  else
+    {
+      PDBG (pixma_dbg (3, "pixma_read_image() failed %s\n",
+		       pixma_strerror (result)));
+    }
+  return result;
+}
+
+void
+pixma_cancel (pixma_t * s)
+{
+  s->cancel = 1;
+}
+
+int
+pixma_enable_background (pixma_t * s, int enabled)
+{
+  return pixma_set_interrupt_mode (s->io, enabled);
+}
+
+int
+pixma_activate_connection(pixma_t * s)
+{
+  return pixma_activate (s->io);
+}
+
+int
+pixma_deactivate_connection(pixma_t * s)
+{
+  return pixma_deactivate (s->io);
+}
+
+uint32_t
+pixma_wait_event (pixma_t * s, int timeout /*ms */ )
+{
+  unsigned events;
+
+  if (s->events == PIXMA_EV_NONE && s->ops->wait_event)
+    s->ops->wait_event (s, timeout);
+  events = s->events;
+  s->events = PIXMA_EV_NONE;
+  return events;
+}
+
+#define CLAMP2(x,w,min,max,dpi) do {		\
+    unsigned m = (max) * (dpi) / 75;		\
+    x = MIN(x, m - min);			\
+    w = MIN(w, m - x);				\
+    if (w < min)  w = min;			\
+} while(0)
+
+int
+pixma_check_scan_param (pixma_t * s, pixma_scan_param_t * sp)
+{
+  unsigned cfg_xdpi;
+
+  if (!(sp->channels == 3 ||
+	(sp->channels == 1 && (s->cfg->cap & PIXMA_CAP_GRAY) != 0)))
+    return PIXMA_EINVAL;
+
+  /* flatbed: use s->cfg->xdpi
+   * TPU/ADF: use s->cfg->adftpu_max_dpi, if configured with dpi value */
+  cfg_xdpi = ((sp->source == PIXMA_SOURCE_FLATBED
+               || s->cfg->adftpu_max_dpi == 0) ? s->cfg->xdpi
+                                               : s->cfg->adftpu_max_dpi);
+
+  if (pixma_check_dpi (sp->xdpi, cfg_xdpi) < 0 ||
+      pixma_check_dpi (sp->ydpi, s->cfg->ydpi) < 0)
+    return PIXMA_EINVAL;
+
+  /* xdpi must be equal to ydpi except that
+     xdpi = max_xdpi and ydpi = max_ydpi. */
+  if (!(sp->xdpi == sp->ydpi ||
+	(sp->xdpi == cfg_xdpi && sp->ydpi == s->cfg->ydpi)))
+    return PIXMA_EINVAL;
+
+  if (s->ops->check_param (s, sp) < 0)
+    return PIXMA_EINVAL;
+
+  /* FIXME: I assume the same minimum width and height for every model.
+   * new scanners need minimum 16 px height
+   * minimum image size: 16 px x 16 px */
+  CLAMP2 (sp->x, sp->w, 16, s->cfg->width, sp->xdpi);
+  CLAMP2 (sp->y, sp->h, 16, s->cfg->height, sp->ydpi);
+
+  switch (sp->source)
+    {
+    case PIXMA_SOURCE_FLATBED:
+      break;
+
+    case PIXMA_SOURCE_TPU:
+      if ((s->cfg->cap & PIXMA_CAP_TPU) != PIXMA_CAP_TPU)
+        {
+          sp->source = PIXMA_SOURCE_FLATBED;
+          PDBG (pixma_dbg
+          (1, "WARNING: TPU unsupported, fallback to flatbed.\n"));
+        }
+      break;
+
+    case PIXMA_SOURCE_ADF:
+      if ((s->cfg->cap & PIXMA_CAP_ADF) != PIXMA_CAP_ADF)
+        {
+          sp->source = PIXMA_SOURCE_FLATBED;
+          PDBG (pixma_dbg
+          (1, "WARNING: ADF unsupported, fallback to flatbed.\n"));
+        }
+      break;
+
+    case PIXMA_SOURCE_ADFDUP:
+      if ((s->cfg->cap & PIXMA_CAP_ADFDUP) != PIXMA_CAP_ADFDUP)
+        {
+          if (s->cfg->cap & PIXMA_CAP_ADF)
+            {
+              sp->source = PIXMA_SOURCE_ADF;
+            }
+          else
+            {
+              sp->source = PIXMA_SOURCE_FLATBED;
+            }
+          PDBG (pixma_dbg
+          (1, "WARNING: ADF duplex unsupported, fallback to %d.\n",
+           sp->source));
+        }
+      break;
+    }
+
+  if (sp->depth == 0)
+    sp->depth = 8;
+  if ((sp->depth % 8) != 0 && sp->depth != 1)
+    return PIXMA_EINVAL;
+
+  sp->line_size = 0;
+
+  if (s->ops->check_param (s, sp) < 0)
+    return PIXMA_EINVAL;
+
+  if (sp->line_size == 0)
+    sp->line_size = sp->depth / 8 * sp->channels * sp->w;
+  sp->image_size = sp->line_size * sp->h;
+
+  /* image_size for software lineart is counted in bits */
+  if (sp->software_lineart == 1)
+    sp->image_size /= 8;
+  return 0;
+}
+
+const char *
+pixma_get_string (pixma_t * s, pixma_string_index_t i)
+{
+  switch (i)
+    {
+    case PIXMA_STRING_MODEL:
+      return s->cfg->name;
+    case PIXMA_STRING_ID:
+      return s->id;
+    case PIXMA_STRING_LAST:
+      return NULL;
+    }
+  return NULL;
+}
+
+const pixma_config_t *
+pixma_get_config (pixma_t * s)
+{
+  return s->cfg;
+}
+
+void
+pixma_fill_gamma_table (double gamma, uint8_t * table, unsigned n)
+{
+  int i;
+  double r_gamma = 1.0 / gamma;
+  double out_scale = 255.0;
+  double in_scale = 1.0 / (n - 1);
+
+  for (i = 0; (unsigned) i != n; i++)
+    {
+      table[i] = (int) (out_scale * pow (i * in_scale, r_gamma) + 0.5);
+    }
+}
+
+int
+pixma_find_scanners (const char **conf_devices, SANE_Bool local_only)
+{
+  return pixma_collect_devices (conf_devices, pixma_devices, local_only);
+}
+
+const char *
+pixma_get_device_model (unsigned devnr)
+{
+  const pixma_config_t *cfg = pixma_get_device_config (devnr);
+  return (cfg) ? cfg->name : NULL;
+}
+
+
+int
+pixma_get_device_status (pixma_t * s, pixma_device_status_t * status)
+{
+  if (!status)
+    return PIXMA_EINVAL;
+  memset (status, 0, sizeof (*status));
+  return s->ops->get_status (s, status);
+}