Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2264 insertions, 0 deletions

diff --git a/backend/qcam.c b/backend/qcam.c
new file mode 100644
index 0000000..0148bea
--- /dev/null
+++ b/backend/qcam.c
@@ -0,0 +1,2264 @@
+/* sane - Scanner Access Now Easy.
+   Copyright (C) 1997 David Mosberger-Tang
+   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.
+
+   This file implements a SANE backend for the Connectix QuickCam.  At
+   present, only the color camera is supported though the driver
+   should be able to easily accommodate black and white cameras.
+
+   Portions of this code are derived from Scott Laird's qcam driver.
+   It's copyright notice is reproduced here:
+
+   Copyright (C) 1996 by Scott Laird
+
+   Permission is hereby granted, free of charge, to any person
+   obtaining a copy of this software and associated documentation
+   files (the "Software"), to deal in the Software without
+   restriction, including without limitation the rights to use, copy,
+   modify, merge, publish, distribute, sublicense, and/or sell copies
+   of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT.  IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY
+   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+   CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
+
+#ifdef _AIX
+# include "lalloca.h"		/* MUST come first for AIX! */
+#endif
+
+#include "../include/sane/config.h"
+#include "lalloca.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <math.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+
+
+#define BACKEND_NAME qcam
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX	1024
+#endif
+
+#include "../include/sane/sanei_config.h"
+#define QCAM_CONFIG_FILE "qcam.conf"
+
+#include "qcam.h"
+
+/* status bits */
+#define NeedRamTable		(1 << 1)
+#define BlackBalanceInProgress	(1 << 6)
+#define CameraNotReady		(1 << 7)
+
+/* lpdata bits: */
+#define Cmd0_7		0xff
+#define CamRdy2		(   1 << 0)	/* byte mode */
+#define Data0_6		(0x7f << 1)	/* byte mode */
+
+/* lpstatus bits: */
+#define CamRdy1		(   1 << 3)	/* nibble mode */
+#define Nibble0_3	(0x0f << 4)	/* nibble mode */
+#define Data7_11	(0x1f << 3)	/* byte mode */
+
+/* lpcontrol bits: */
+#define Strobe		(   1 << 0)	/* unused */
+#define Autofeed	(   1 << 1)
+#define Reset_N		(   1 << 2)
+#define PCAck		(   1 << 3)
+#define BiDir		(   1 << 5)
+
+static int num_devices;
+static QC_Device *first_dev;
+static QC_Scanner *first_handle;
+
+static const SANE_String_Const resolution_list[] = {
+  "Low",			/* million-mode */
+  "High",			/* billion-mode */
+  0
+};
+
+static const SANE_Int mono_depth_list[] = {
+  2,				/* # of elements */
+  4, 6
+};
+
+static const SANE_Int color_depth_list[] = {
+  /*2 */ 1,
+  /* # of elements */
+  /*16, */ 24
+    /* "thousand" mode not implemented yet */
+};
+
+static const SANE_Int xfer_scale_list[] = {
+  3,				/* # of elements */
+  1, 2, 4
+};
+
+static const SANE_Range u8_range = {
+  /* min, max, quantization */
+  0, 255, 0
+};
+
+static const SANE_Range brightness_range = {
+  /* min, max, quantization */
+  0, 254, 0			/* 255 is bulb mode! */
+};
+
+static const SANE_Range x_range[] = {
+  /* min, max, quantization */
+  {0, 338, 2},			/* million mode */
+  {0, 676, 4},			/* billion mode */
+};
+
+static const SANE_Range odd_x_range[] = {
+  /* min, max, quantization */
+  {1, 339, 2},			/* million mode */
+  {3, 683, 4},			/* billion mode */
+};
+
+static const SANE_Range y_range[] = {
+  /* min, max, quantization */
+  {0, 249, 1},			/* million mode */
+  {0, 498, 2},			/* billion mode */
+};
+
+static const SANE_Range odd_y_range[] = {
+  /* min, max, quantization */
+  {0, 249, 1},			/* million mode */
+  {1, 499, 2},			/* billion mode */
+};
+
+static const SANE_Range bw_x_range = { 0, 334, 2 };
+static const SANE_Range odd_bw_x_range = { 1, 335, 2 };
+static const SANE_Range bw_y_range = { 0, 241, 1 };
+static const SANE_Range odd_bw_y_range = { 1, 242, 1 };
+
+#if defined(HAVE_SYS_IO_H) || defined(HAVE_ASM_IO_H) || defined (HAVE_SYS_HW_H)
+
+#ifdef HAVE_SYS_IO_H
+# include <sys/io.h>		/* GNU libc based OS */
+#elif HAVE_ASM_IO_H
+# include <asm/io.h>		/* older Linux */
+#elif HAVE_SYS_HW_H
+# include <sys/hw.h>		/* OS/2 */
+#endif
+
+#endif /* <sys/io.h> || <asm/io.h> || <sys/hw.h> */
+
+#define read_lpdata(d)		inb ((d)->port)
+#define read_lpstatus(d)	inb ((d)->port + 1)
+#define read_lpcontrol(d)	inb ((d)->port + 2)
+#define write_lpdata(d,v)	outb ((v), (d)->port)
+#define write_lpcontrol(d,v)	outb ((v), (d)->port + 2)
+
+
+static SANE_Status
+enable_ports (QC_Device * q)
+{
+  /* better safe than sorry */
+  if (q->port < 0x278 || q->port > 0x3bc)
+    return SANE_STATUS_INVAL;
+
+  if (ioperm (q->port, 3, 1) < 0)
+    return SANE_STATUS_INVAL;
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+disable_ports (QC_Device * q)
+{
+  if (ioperm (q->port, 3, 0) < 0)
+    return SANE_STATUS_INVAL;
+
+  return SANE_STATUS_GOOD;
+}
+
+/* We need a short delay loop -- somthing well under a millisecond.
+   Unfortunately, adding 2 usleep(1)'s to qc_command slowed it down by
+   a factor of over 1000 over the same loop with 2 usleep(0)'s, and
+   that's too slow -- qc_start was taking over a second to run.  This
+   seems to help, but if anyone has a good speed-independent pause
+   routine, please tell me. -- Scott
+
+   If you're worried about hogging the CPU: don't worry, the qcam
+   interface leaves you no choice, so this doesn't make the situation
+   any worse... */
+
+static int
+qc_wait (QC_Device * q)
+{
+  return read_lpstatus (q);
+}
+
+
+/* This function uses POSIX fcntl-style locking on a file created in
+   the /tmp directory.  Because it uses the Unix record locking
+   facility, locks are relinquished automatically on process
+   termination, so "dead locks" are not a problem.  (FYI, the lock
+   file will remain after process termination, but this is actually
+   desired so that the next process need not re-creat(2)e it... just
+   lock it.)  The wait argument indicates whether or not this funciton
+   should "block" waiting for the previous lock to be relinquished.
+   This is ideal so that multiple processes (eg. qcam) taking
+   "snapshots" can peacefully coexist.
+
+   -- Dave Plonka (plonka@carroll1.cc.edu) */
+static SANE_Status
+qc_lock_wait (QC_Device * q, int wait)
+{
+#ifdef F_SETLK
+
+#ifndef HAVE_STRUCT_FLOCK
+  struct flock
+  {
+    off_t l_start;
+    off_t l_len;
+    pid_t l_pid;
+    short l_type;
+    short l_whence;
+  };
+#endif /* !HAVE_STRUCT_FLOCK */
+  struct flock sfl;
+#endif
+
+  DBG (3, "qc_lock_wait: acquiring lock for 0x%x\n", q->port);
+
+#ifdef F_SETLK
+  memset (&sfl, 0, sizeof (sfl));
+#endif
+
+  if (q->lock_fd < 0)
+    {
+      char lockfile[128];
+
+      sprintf (lockfile, "/tmp/LOCK.qcam.0x%x", q->port);
+      q->lock_fd = open (lockfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
+      if (q->lock_fd < 0)
+	{
+	  DBG (1, "qc_lock_wait: failed to open %s (%s)\n",
+	       lockfile, strerror (errno));
+	  return SANE_STATUS_INVAL;
+	}
+
+    }
+
+#ifdef F_SETLK
+  sfl.l_type = F_WRLCK;
+  if (fcntl (q->lock_fd, wait ? F_SETLKW : F_SETLK, &sfl) != 0)
+    {
+      DBG (1, "qc_lock_wait: failed to acquire lock (%s)\n",
+	   strerror (errno));
+      return SANE_STATUS_INVAL;
+    }
+#endif
+
+  DBG (3, "qc_lock_wait: got lock for 0x%x\n", q->port);
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+qc_unlock (QC_Device * q)
+{
+  SANE_Status status;
+  char lockfile[128];
+#ifdef F_SETLK
+#ifndef HAVE_STRUCT_FLOCK
+  struct flock
+  {
+    off_t l_start;
+    off_t l_len;
+    pid_t l_pid;
+    short l_type;
+    short l_whence;
+  };
+#endif /* !HAVE_STRUCT_FLOCK */
+  struct flock sfl;
+#endif
+
+  DBG (3, "qc_unlock: releasing lock for 0x%x\n", q->port);
+
+#ifdef F_SETLK
+  memset (&sfl, 0, sizeof (sfl));
+#endif
+  if (q->lock_fd < 0)
+    {
+      DBG (3, "qc_unlock; port was not locked\n");
+      return SANE_STATUS_INVAL;
+    }
+  /* clear the exclusive lock */
+
+#ifdef F_SETLK
+  sfl.l_type = F_UNLCK;
+
+  if (fcntl (q->lock_fd, F_SETLK, &sfl) != 0)
+    {
+      DBG (3, "qc_unlock: failed to release lock (%s)\n", strerror (errno));
+      return SANE_STATUS_INVAL;
+    }
+#endif
+  sprintf (lockfile, "/tmp/LOCK.qcam.0x%x", q->port);
+  DBG (1, "qc_unlock: /tmp/LOCK.qcam.0x%x\n", q->port);
+  unlink (lockfile);
+  close (q->lock_fd);
+  q->lock_fd = -1;
+  DBG (1, "qc_unlock: exit\n");
+  status = SANE_STATUS_GOOD;
+  return status;
+}
+
+static SANE_Status
+qc_lock (QC_Device * q)
+{
+  return qc_lock_wait (q, 1);
+}
+
+/* Busy-waits for a handshake signal from the QuickCam.  Almost all
+   communication with the camera requires handshaking.  This is why
+   qcam is a CPU hog.  */
+static int
+qc_waithand (QC_Device * q, int val)
+{
+  int status;
+
+  while (((status = read_lpstatus (q)) & CamRdy1) != val);
+  return status;
+}
+
+/* This is used when the qcam is in bidirectional ("byte") mode, and
+   the handshaking signal is CamRdy2 (bit 0 of data reg) instead of
+   CamRdy1 (bit 3 of status register).  It also returns the last value
+   read, since this data is useful.  */
+static unsigned int
+qc_waithand2 (QC_Device * q, int val)
+{
+  unsigned int status;
+
+  do
+    {
+      status = read_lpdata (q);
+    }
+  while ((status & CamRdy2) != (unsigned int) val);
+  return status;
+}
+
+static unsigned int
+qc_send (QC_Device * q, unsigned int byte)
+{
+  unsigned int echo;
+  int n1, n2;
+
+  write_lpdata (q, byte);
+  qc_wait (q);
+  write_lpcontrol (q, Autofeed | Reset_N);
+  qc_wait (q);
+
+  n1 = qc_waithand (q, CamRdy1);
+
+  write_lpcontrol (q, Autofeed | Reset_N | PCAck);
+  qc_wait (q);
+  n2 = qc_waithand (q, 0);
+
+  echo = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
+#ifndef NDEBUG
+  if (echo != byte)
+    {
+      DBG (1, "qc_send: sent 0x%02x, camera echoed 0x%02x\n", byte, echo);
+      n2 = read_lpstatus (q);
+      echo = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
+      if (echo != byte)
+	DBG (1, "qc_send: (re-read does not help)\n");
+      else
+	DBG (1, "qc_send: (fixed on re-read)\n");
+    }
+#endif
+  return echo;
+}
+
+static int
+qc_readparam (QC_Device * q)
+{
+  int n1, n2;
+  int cmd;
+
+  write_lpcontrol (q, Autofeed | Reset_N);	/* clear PCAck */
+  n1 = qc_waithand (q, CamRdy1);
+
+  write_lpcontrol (q, Autofeed | Reset_N | PCAck);	/* set PCAck */
+  n2 = qc_waithand (q, 0);
+
+  cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
+  return cmd;
+}
+
+static unsigned int
+qc_getstatus (QC_Device * q)
+{
+  unsigned int status;
+
+  qc_send (q, QC_SEND_STATUS);
+  status = qc_readparam (q);
+  DBG (3, "qc_getstatus: status=0x%02x\n", status);
+  return status;
+}
+
+static void
+qc_setscanmode (QC_Scanner * s, u_int * modep)
+{
+  QC_Device *q = s->hw;
+  u_int mode = 0;
+
+  if (q->version != QC_COLOR)
+    {
+      switch (s->val[OPT_XFER_SCALE].w)
+	{
+	case 1:
+	  mode = 0;
+	  break;
+	case 2:
+	  mode = 4;
+	  break;
+	case 4:
+	  mode = 8;
+	  break;
+	}
+      switch (s->val[OPT_DEPTH].w)
+	{
+	case 4:
+	  break;
+	case 6:
+	  mode += 2;
+	  break;
+	}
+    }
+  else
+    {
+      switch (s->val[OPT_XFER_SCALE].w)
+	{
+	case 1:
+	  mode = 0;
+	  break;
+	case 2:
+	  mode = 2;
+	  break;
+	case 4:
+	  mode = 4;
+	  break;
+	}
+      if (s->resolution == QC_RES_LOW)
+	mode |= 0x18;		/* millions mode */
+      else
+	mode |= 0x10;		/* billions mode */
+    }
+  if (s->val[OPT_TEST].w)
+    mode |= 0x40;		/* test mode */
+
+  if (q->port_mode == QC_BIDIR)
+    mode |= 1;
+
+  DBG (2, "scanmode (before increment): 0x%x\n", mode);
+
+  if (q->version == QC_COLOR)
+    ++mode;
+
+  *modep = mode;
+}
+
+/* Read data bytes from the camera.  The number of bytes read is
+   returned as the function result.  Depending on the mode, it may be
+   either 1, 3 or 6.  On failure, 0 is returned.  If buffer is 0, the
+   internal state-machine is reset.  */
+static size_t
+qc_readbytes (QC_Scanner * s, unsigned char buffer[])
+{
+  QC_Device *q = s->hw;
+  unsigned int hi, lo;
+  unsigned int hi2, lo2;
+  size_t bytes = 0;
+
+  if (!buffer)
+    {
+      s->readbytes_state = 0;
+      return 0;
+    }
+
+  switch (q->port_mode)
+    {
+    case QC_BIDIR:
+      /* bi-directional port */
+
+      /* read off 24 bits: */
+      write_lpcontrol (q, Autofeed | Reset_N | BiDir);
+      lo = qc_waithand2 (q, 1) >> 1;
+      hi = (read_lpstatus (q) >> 3) & 0x1f;
+      write_lpcontrol (q, Autofeed | Reset_N | PCAck | BiDir);
+      lo2 = qc_waithand2 (q, 0) >> 1;
+      hi2 = (read_lpstatus (q) >> 3) & 0x1f;
+      if (q->version == QC_COLOR)
+	{
+	  /* is Nibble3 inverted for color quickcams only? */
+	  hi ^= 0x10;
+	  hi2 ^= 0x10;
+	}
+      switch (s->val[OPT_DEPTH].w)
+	{
+	case 4:
+	  buffer[0] = lo & 0xf;
+	  buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
+	  buffer[2] = (hi & 0x1e) >> 1;
+	  buffer[3] = lo2 & 0xf;
+	  buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
+	  buffer[5] = (hi2 & 0x1e) >> 1;
+	  bytes = 6;
+	  break;
+
+	case 6:
+	  buffer[0] = lo & 0x3f;
+	  buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
+	  buffer[2] = lo2 & 0x3f;
+	  buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
+	  bytes = 4;
+	  break;
+
+	case 24:
+	  buffer[0] = lo | ((hi & 0x1) << 7);
+	  buffer[1] = ((hi2 & 0x1e) >> 1) | ((hi & 0x1e) << 3);
+	  buffer[2] = lo2 | ((hi2 & 0x1) << 7);
+	  bytes = 3;
+	  break;
+	}
+      break;
+
+    case QC_UNIDIR:		/* Unidirectional Port */
+      write_lpcontrol (q, Autofeed | Reset_N);
+      lo = (qc_waithand (q, CamRdy1) & 0xf0) >> 4;
+      write_lpcontrol (q, Autofeed | Reset_N | PCAck);
+      hi = (qc_waithand (q, 0) & 0xf0) >> 4;
+
+      if (q->version == QC_COLOR)
+	{
+	  /* invert Nibble3 */
+	  hi ^= 8;
+	  lo ^= 8;
+	}
+
+      switch (s->val[OPT_DEPTH].w)
+	{
+	case 4:
+	  buffer[0] = lo;
+	  buffer[1] = hi;
+	  bytes = 2;
+	  break;
+
+	case 6:
+	  switch (s->readbytes_state)
+	    {
+	    case 0:
+	      buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
+	      s->saved_bits = (hi & 3) << 4;
+	      s->readbytes_state = 1;
+	      bytes = 1;
+	      break;
+
+	    case 1:
+	      buffer[0] = lo | s->saved_bits;
+	      s->saved_bits = hi << 2;
+	      s->readbytes_state = 2;
+	      bytes = 1;
+	      break;
+
+	    case 2:
+	      buffer[0] = ((lo & 0xc) >> 2) | s->saved_bits;
+	      buffer[1] = ((lo & 3) << 4) | hi;
+	      s->readbytes_state = 0;
+	      bytes = 2;
+	      break;
+
+	    default:
+	      DBG (1, "qc_readbytes: bad unidir 6-bit stat %d\n",
+		   s->readbytes_state);
+	      break;
+	    }
+	  break;
+
+	case 24:
+	  buffer[0] = (lo << 4) | hi;
+	  bytes = 1;
+	  break;
+
+	default:
+	  DBG (1, "qc_readbytes: bad unidir bit depth %d\n",
+	       s->val[OPT_DEPTH].w);
+	  break;
+	}
+      break;
+
+    default:
+      DBG (1, "qc_readbytes: bad port_mode %d\n", q->port_mode);
+      break;
+    }
+  return bytes;
+}
+
+static void
+qc_reset (QC_Device * q)
+{
+  write_lpcontrol (q, Strobe | Autofeed | Reset_N | PCAck);
+  qc_wait (q);
+  write_lpcontrol (q, Strobe | Autofeed | PCAck);
+  qc_wait (q);
+  write_lpcontrol (q, Strobe | Autofeed | Reset_N | PCAck);
+}
+
+/* This function is executed as a child process.  The reason this is
+   executed as a subprocess is because the qcam interface directly reads
+   off of a I/O port (rather than a filedescriptor).  Thus, to have
+   something to select() on, we transfer the data through a pipe.
+
+   WARNING: Since this is executed as a subprocess, it's NOT possible
+   to update any of the variables in the main process (in particular
+   the scanner state cannot be updated).  */
+
+static jmp_buf env;
+
+static void
+sighandler (int signal)
+{
+  DBG (3, "sighandler: got signal %d\n", signal);
+  longjmp (env, 1);
+}
+
+/* Original despeckling code by Patrick Reynolds <patrickr@virginia.edu> */
+
+static void
+despeckle (int width, int height, SANE_Byte * in, SANE_Byte * out)
+{
+  long x, i;
+  /* The light-check threshold.  Higher numbers remove more lights but
+     blur the image more.  30 is good for indoor lighting.  */
+# define NO_LIGHTS 30
+
+  /* macros to make the code a little more readable, p=previous, n=next */
+# define R	in[i*3]
+# define G	in[i*3+1]
+# define B	in[i*3+2]
+# define pR	in[i*3-3]
+# define pG	in[i*3-2]
+# define pB	in[i*3-1]
+# define nR	in[i*3+3]
+# define nG	in[i*3+4]
+# define nB	in[i*3+5]
+
+  DBG (1, "despeckle: width=%d, height=%d\n", width, height);
+
+  for (x = i = 0; i < width * height; ++i)
+    {
+      if (x == 0 || x == width - 1)
+	memcpy (&out[i * 3], &in[i * 3], 3);
+      else
+	{
+	  if (R - (G + B) / 2 >
+	      NO_LIGHTS + ((pR - (pG + pB) / 2) + (nR - (nG + nB) / 2)))
+	    out[i * 3] = (pR + nR) / 2;
+	  else
+	    out[i * 3] = R;
+
+	  if (G - (R + B) / 2 >
+	      NO_LIGHTS + ((pG - (pR + pB) / 2) + (nG - (nR + nB) / 2)))
+	    out[i * 3 + 1] = (pG + nG) / 2;
+	  else
+	    out[i * 3 + 1] = G;
+
+	  if (B - (G + R) / 2 >
+	      NO_LIGHTS + ((pB - (pG + pR) / 2) + (nB - (nG + nR) / 2)))
+	    out[i * 3 + 2] = (pB + nB) / 2;
+	  else
+	    out[i * 3 + 2] = B;
+	}
+      if (++x >= width)
+	x = 0;
+    }
+# undef R
+# undef G
+# undef B
+# undef pR
+# undef pG
+# undef pB
+# undef nR
+# undef nG
+# undef nB
+}
+
+static void
+despeckle32 (int width, int height, SANE_Byte * in, SANE_Byte * out)
+{
+  long x, i;
+  /* macros to make the code a little more readable, p=previous, n=next */
+# define B	in[i*4]
+# define Ga	in[i*4 + 1]
+# define Gb	in[i*4 + 1]	/* ignore Gb and use Ga instead---Gb is weird */
+# define R	in[i*4 + 3]
+# define pB	in[i*4 - 4]
+# define pGa	in[i*4 - 3]
+# define pGb	in[i*4 - 1]	/* ignore Gb and use Ga instead---Gb is weird */
+# define pR	in[i*4 - 1]
+# define nB	in[i*4 + 4]
+# define nGa	in[i*4 + 5]
+# define nGb	in[i*4 + 5]	/* ignore Gb and use Ga instead---Gb is weird */
+# define nR	in[i*4 + 7]
+
+  DBG (1, "despeckle32: width=%d, height=%d\n", width, height);
+
+  for (x = i = 0; i < width * height; ++i)
+    {
+      if (x == 0 || x == width - 1)
+	memcpy (&out[i * 4], &in[i * 4], 4);
+      else
+	{
+	  if (x >= width - 2)
+	    /* the last red pixel seems to be black at all times, use
+	       R instead: */
+	    nR = R;
+
+	  if (R - ((Ga + Gb) / 2 + B) / 2 >
+	      NO_LIGHTS + ((pR - ((pGa + pGb) / 2 + pB) / 2) +
+			   (nR - ((nGa + nGb) / 2 + nB) / 2)))
+	    out[i * 4 + 3] = (pR + nR) / 2;
+	  else
+	    out[i * 4 + 3] = R;
+
+	  if (Ga - (R + B) / 2 > NO_LIGHTS + ((pGa - (pR + pB) / 2) +
+					      (nGa - (nR + nB) / 2)))
+	    out[i * 4 + 1] = (pGa + nGa) / 2;
+	  else
+	    out[i * 4 + 1] = Ga;
+
+	  if (Gb - (R + B) / 2 > NO_LIGHTS + ((pGb - (pR + pB) / 2) +
+					      (nGb - (nR + nB) / 2)))
+	    out[i * 4 + 2] = (pGb + nGb) / 2;
+	  else
+	    out[i * 4 + 2] = Gb;
+
+	  if (B - ((Ga + Gb) / 2 + R) / 2 >
+	      NO_LIGHTS + ((pB - ((pGa + pGb) / 2 + pR) / 2) +
+			   (nB - ((nGa + nGb) / 2 + nR) / 2)))
+	    out[i * 4 + 0] = (pB + nB) / 2;
+	  else
+	    out[i * 4 + 0] = B;
+	}
+      if (++x >= width)
+	x = 0;
+    }
+# undef R
+# undef Ga
+# undef Gb
+# undef B
+# undef pR
+# undef pGa
+# undef pGb
+# undef pB
+# undef nR
+# undef nGa
+# undef nGb
+# undef nB
+}
+
+static int
+reader_process (QC_Scanner * s, int in_fd, int out_fd)
+{
+  static SANE_Byte *buffer = 0, *extra = 0;
+  static size_t buffer_size = 0;
+  size_t count, len, num_bytes;
+  QC_Device *q = s->hw;
+  QC_Scan_Request req;
+  int width, height;
+  SANE_Byte *src;
+  FILE *ofp;
+
+  DBG (5, "reader_process: enter\n");
+
+  enable_ports (q);
+
+  ofp = fdopen (out_fd, "w");
+  if (!ofp)
+    return 1;
+
+  while (1)
+    {
+      if (setjmp (env))
+	{
+	  char ch;
+
+	  /* acknowledge the signal: */
+	  DBG (1, "reader_process: sending signal ACK\n");
+	  fwrite (&ch, 1, 1, ofp);
+	  fflush (ofp);		/* force everything out the pipe */
+	  continue;
+	}
+      signal (SIGINT, sighandler);
+
+      /* the main process gets us started by writing a size_t giving
+         the number of bytes we should expect: */
+      if (read (in_fd, &req, sizeof (req)) != sizeof (req))
+	{
+	  perror ("read");
+	  return 1;
+	}
+      num_bytes = req.num_bytes;
+
+      DBG (3, "reader_process: got request for %lu bytes\n",
+	   (u_long) num_bytes);
+
+      /* Don't do this in sane_start() since there may be a long
+         timespan between it and the first sane_read(), which would
+         result in poor images.  */
+      qc_send (q, QC_SEND_VIDEO_FRAME);
+      qc_send (q, req.mode);
+
+      if (req.despeckle
+	  && (!extra || buffer_size < num_bytes
+	      || buffer_size >= 2 * num_bytes))
+	{
+	  if (extra)
+	    extra = realloc (extra, num_bytes);
+	  else
+	    extra = malloc (num_bytes);
+	  if (!extra)
+	    {
+	      DBG (1, "reader_process: malloc(%ld) failed\n",
+		   (long) num_bytes);
+	      exit (1);
+	    }
+	}
+
+      if (buffer_size < num_bytes || buffer_size >= 2 * num_bytes)
+	{
+	  if (buffer)
+	    buffer = realloc (buffer, num_bytes);
+	  else
+	    buffer = malloc (num_bytes);
+	  if (!buffer)
+	    {
+	      DBG (1, "reader_process: malloc(%ld) failed\n",
+		   (long) num_bytes);
+	      exit (1);
+	    }
+	  buffer_size = num_bytes;
+	}
+
+      if (q->port_mode == QC_BIDIR)
+	{
+	  /* turn port into input port */
+	  write_lpcontrol (q, Autofeed | Reset_N | PCAck | BiDir);
+	  usleep (3);
+	  write_lpcontrol (q, Autofeed | Reset_N | BiDir);
+	  qc_waithand (q, CamRdy1);
+	  write_lpcontrol (q, Autofeed | Reset_N | PCAck | BiDir);
+	  qc_waithand (q, 0);
+	}
+
+      if (q->version == QC_COLOR)
+	for (len = 0; len < num_bytes; len += count)
+	  count = qc_readbytes (s, buffer + len);
+      else
+	{
+	  /* strange -- should be 15:63 below, but 4bpp is odd */
+	  int shift, invert;
+	  unsigned int i;
+	  u_char val;
+
+	  switch (s->val[OPT_DEPTH].w)
+	    {
+	    case 4:
+	      invert = 16;
+	      shift = 4;
+	      break;
+
+	    case 6:
+	      invert = 63;
+	      shift = 2;
+	      break;
+
+	    default:
+	      DBG (1, "reader_process: unexpected depth %d\n",
+		   s->val[OPT_DEPTH].w);
+	      return 1;
+	    }
+
+	  for (len = 0; len < num_bytes; len += count)
+	    {
+	      count = qc_readbytes (s, buffer + len);
+	      for (i = 0; i < count; ++i)
+		{
+		  /* 4bpp is odd (again) -- inverter is 16, not 15,
+		     but output must be 0-15 */
+		  val = buffer[len + i];
+		  if (val > 0 || invert != 16)
+		    val = invert - val;
+		  buffer[len + i] = (val << shift) | (val >> (8 - 2 * shift));
+		}
+	    }
+	  qc_readbytes (s, 0);	/* reset state machine */
+	}
+      /* we're done reading this frame: */
+      DBG (2, "reader_process: frame complete\n");
+
+      if (q->port_mode == QC_BIDIR)
+	{
+	  /* return port to output mode */
+	  write_lpcontrol (q, Autofeed);
+	  usleep (3);
+	  write_lpcontrol (q, Autofeed | Reset_N);
+	  usleep (3);
+	  write_lpcontrol (q, Autofeed | Reset_N | PCAck);
+	}
+
+      if (req.resolution == QC_RES_HIGH)
+	{
+	  SANE_Byte buf[6];
+	  int x, y;
+
+	  /* in billions mode, we need to oversample the data: */
+	  src = buffer;
+	  width = req.params.pixels_per_line;
+	  height = req.params.lines;
+
+	  if (req.despeckle)
+	    {
+	      despeckle32 (width / 2, req.params.lines / 2, buffer, extra);
+	      src = extra;
+	    }
+
+	  assert (!(width & 1));	/* width must be even */
+
+	  for (y = 0; y < height; ++y)
+	    {
+	      /* even line */
+
+	      for (x = 0; x < width; x += 2)
+		{
+		  int red1, green1, blue1, green2, blue2;
+
+		  blue1 = src[0];
+		  green1 = src[1];
+		  red1 = src[3];
+		  if (x >= width - 2)
+		    {
+		      red1 = src[-1];	/* last red seems to be missing */
+		      blue2 = blue1;
+		      green2 = green1;
+		    }
+		  else
+		    {
+		      blue2 = src[4];
+		      green2 = src[5];
+		    }
+		  src += 4;
+
+		  buf[0] = red1;
+		  buf[1] = green1;
+		  buf[2] = blue1;
+		  buf[3] = red1;
+		  buf[4] = green2;
+		  buf[5] = blue2;
+		  if (fwrite (buf, 1, 6, ofp) != 6)
+		    {
+		      perror ("fwrite: short write");
+		      return 1;
+		    }
+		}
+	      if (++y >= height)
+		break;
+
+	      src -= 2 * width;	/* 4 bytes/pixel -> 2 pixels of 3 bytes each */
+
+	      /* odd line */
+	      for (x = 0; x < width; x += 2)
+		{
+		  int red1, green3, blue3, green4, blue4;
+		  int yoff;
+
+		  if (x >= width - 2)
+		    red1 = src[-1];	/* last red seems to be missing */
+		  else
+		    red1 = src[3];
+		  yoff = 2 * width;
+		  if (y >= height - 1)
+		    yoff = 0;
+		  green3 = src[yoff + 1];
+		  blue3 = src[yoff + 0];
+		  if (x >= width - 2)
+		    {
+		      blue4 = blue3;
+		      green4 = green3;
+		    }
+		  else
+		    {
+		      blue4 = src[yoff + 4];
+		      green4 = src[yoff + 5];
+		    }
+		  src += 4;
+
+		  buf[0] = red1;
+		  buf[1] = green3;
+		  buf[2] = blue3;
+		  buf[3] = red1;
+		  buf[4] = green4;
+		  buf[5] = blue4;
+		  if (fwrite (buf, 1, 6, ofp) != 6)
+		    {
+		      perror ("fwrite: short write");
+		      return 1;
+		    }
+		}
+	    }
+	}
+      else
+	{
+	  src = buffer;
+	  if (req.despeckle)
+	    {
+	      despeckle (req.params.pixels_per_line, req.params.lines,
+			 buffer, extra);
+	      src = extra;
+	    }
+
+	  /* now write the whole thing to the main process: */
+	  if (fwrite (src, 1, num_bytes, ofp) != num_bytes)
+	    {
+	      perror ("fwrite: short write");
+	      return 1;
+	    }
+	}
+      fflush (ofp);
+    }
+  assert (SANE_FALSE);		/* not reached */
+  DBG (5, "reader_process: exit\n");
+  return 1;
+}
+
+static SANE_Status
+attach (const char *devname, QC_Device ** devp)
+{
+  int i, n1, n2, s1, s2, cmd, port, force_unidir;
+  SANE_Status result, status;
+  QC_Device *q;
+  char *endp;
+
+  DBG (3, "attach: enter\n");
+  errno = 0;
+  force_unidir = 0;
+  if (devname[0] == 'u')
+    {
+      force_unidir = 1;
+      ++devname;
+    }
+  port = strtol (devname, &endp, 0);
+  if (endp == devname || errno == ERANGE)
+    {
+      DBG (1, "attach: invalid port address `%s'\n", devname);
+      return SANE_STATUS_INVAL;
+    }
+
+  for (q = first_dev; q; q = q->next)
+    if (port == q->port)
+      {
+	if (devp)
+	  *devp = q;
+	return SANE_STATUS_GOOD;
+      }
+
+  q = malloc (sizeof (*q));
+  if (!q)
+    return SANE_STATUS_NO_MEM;
+
+  memset (q, 0, sizeof (*q));
+  q->port = port;
+  q->lock_fd = -1;
+
+  result = enable_ports (q);
+  if (result != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: cannot enable ports (%s)\n", strerror (errno));
+      free (q);
+      return SANE_STATUS_INVAL;
+    }
+
+  /* lock camera while we determine its version: */
+  qc_lock (q);
+
+  qc_reset (q);
+
+  write_lpdata (q, QC_SEND_VERSION);
+  qc_wait (q);
+  write_lpcontrol (q, Autofeed | Reset_N);	/* make PCAck inactive */
+  qc_wait (q);
+
+  for (i = 0; (i < 1000) && !(s1 = (n1 = read_lpstatus (q)) & CamRdy1); i++);
+  if (!s1)
+    {
+      DBG (2, "attach: failed to get CamRdy1 at port 0x%x\n", q->port);
+      goto unlock_and_fail;
+    }
+
+  write_lpcontrol (q, Autofeed | Reset_N | PCAck);
+  qc_wait (q);
+
+  for (i = 0; (i < 1000) && (s2 = (n2 = read_lpstatus (q)) & CamRdy1); i++);
+  if (s2)
+    {
+      DBG (2, "attach: CamRdy1 failed to clear at port 0x%x\n", q->port);
+      goto unlock_and_fail;
+    }
+
+  cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
+
+  if (cmd != QC_SEND_VERSION)
+    {
+      DBG (2, "attach: got 0x%02x instead of 0x%02x\n", cmd, QC_SEND_VERSION);
+      goto unlock_and_fail;
+    }
+
+  q->version = qc_readparam (q);
+  DBG (1, "attach: found QuickCam version 0x%02x\n", q->version);
+
+  q->port_mode = QC_UNIDIR;
+  if (!force_unidir)
+    {
+      write_lpcontrol (q, BiDir);
+      write_lpdata (q, 0x75);
+      if (read_lpdata (q) != 0x75)
+	q->port_mode = QC_BIDIR;
+    }
+
+  /* For some reason the color quickcam needs two set-black commands
+     after a reset.  Thus, we now set the black-level to some
+     reasonable value (0) so that the next set-black level command
+     will really go through.  */
+  if (q->version == QC_COLOR)
+    {
+      qc_send (q, QC_SET_BLACK);
+      qc_send (q, 0);
+
+      DBG (3, "attach: resetting black_level\n");
+
+      /* wait for set black level command to finish: */
+      while (qc_getstatus (q) & (CameraNotReady | BlackBalanceInProgress))
+	usleep (10000);
+    }
+
+  status = qc_unlock (q);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: status qc_unlock NOK\n");
+      /* status = SANE_STATUS_GOOD;  */
+    }
+  q->sane.name = strdup (devname);
+  q->sane.vendor = "Connectix";
+  q->sane.model =
+    (q->version == QC_COLOR) ? "Color QuickCam" : "B&W QuickCam";
+  q->sane.type = "video camera";
+
+  ++num_devices;
+  q->next = first_dev;
+  first_dev = q;
+
+  if (devp)
+    *devp = q;
+  DBG (3, "attach: exit status OK\n");
+  status = SANE_STATUS_GOOD;
+  return status;
+
+
+unlock_and_fail:
+  status = qc_unlock (q);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: unlock_and_fail status qc_unlock NOK\n");
+    }
+  free (q);
+  DBG (3, "attach: exit status NOK\n");
+  status = SANE_STATUS_INVAL;
+  return status;
+}
+
+static SANE_Status
+init_options (QC_Scanner * s)
+{
+  int i;
+
+  DBG (3, "init_options: enter\n");
+  
+  memset (s->opt, 0, sizeof (s->opt));
+  memset (s->val, 0, sizeof (s->val));
+
+  for (i = 0; i < NUM_OPTIONS; ++i)
+    {
+      s->opt[i].size = sizeof (SANE_Word);
+      s->opt[i].cap = (SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT);
+    }
+
+  s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+  s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+  s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+  /* "Mode" group: */
+
+  s->opt[OPT_MODE_GROUP].title = "Scan Mode";
+  s->opt[OPT_MODE_GROUP].desc = "";
+  s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_MODE_GROUP].cap = 0;
+  s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* resolution */
+  s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].type = SANE_TYPE_STRING;
+  s->opt[OPT_RESOLUTION].size = 5;	/* sizeof("High") */
+  s->opt[OPT_RESOLUTION].unit = SANE_UNIT_NONE;
+  s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_RESOLUTION].constraint.string_list = resolution_list;
+  s->val[OPT_RESOLUTION].s = strdup (resolution_list[QC_RES_LOW]);
+
+  /* bit-depth */
+  s->opt[OPT_DEPTH].name = SANE_NAME_BIT_DEPTH;
+  s->opt[OPT_DEPTH].title = "Pixel depth";
+  s->opt[OPT_DEPTH].desc = "Number of bits per pixel.";
+  s->opt[OPT_DEPTH].type = SANE_TYPE_INT;
+  s->opt[OPT_DEPTH].unit = SANE_UNIT_BIT;
+  s->opt[OPT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_DEPTH].constraint.word_list = color_depth_list;
+  s->val[OPT_DEPTH].w = color_depth_list[NELEMS (color_depth_list) - 1];
+
+  /* test */
+  s->opt[OPT_TEST].name = "test-image";
+  s->opt[OPT_TEST].title = "Force test image";
+  s->opt[OPT_TEST].desc =
+    "Acquire a test-image instead of the image seen by the camera. "
+    "The test image consists of red, green, and blue squares of "
+    "32x32 pixels each.  Use this to find out whether the "
+    "camera is connected properly.";
+  s->opt[OPT_TEST].type = SANE_TYPE_BOOL;
+  s->val[OPT_TEST].w = SANE_FALSE;
+
+  /* "Geometry" group: */
+  s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
+  s->opt[OPT_GEOMETRY_GROUP].desc = "";
+  s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* top-left x */
+  s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+  s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+  s->opt[OPT_TL_X].type = SANE_TYPE_INT;
+  s->opt[OPT_TL_X].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = &x_range[QC_RES_LOW];
+  s->val[OPT_TL_X].w = 10;
+
+  /* top-left y */
+  s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].type = SANE_TYPE_INT;
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = &y_range[QC_RES_LOW];
+  s->val[OPT_TL_Y].w = 0;
+
+  /* bottom-right x */
+  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+  s->opt[OPT_BR_X].type = SANE_TYPE_INT;
+  s->opt[OPT_BR_X].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = &odd_x_range[QC_RES_LOW];
+  s->val[OPT_BR_X].w = 339;
+
+  /* bottom-right y */
+  s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].type = SANE_TYPE_INT;
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = &odd_y_range[QC_RES_LOW];
+  s->val[OPT_BR_Y].w = 245;
+
+  /* xfer-scale */
+  s->opt[OPT_XFER_SCALE].name = "transfer-scale";
+  s->opt[OPT_XFER_SCALE].title = "Transfer scale";
+  s->opt[OPT_XFER_SCALE].desc =
+    "The transferscale determines how many of the acquired pixels actually "
+    "get sent to the computer.  For example, a transfer scale of 2 would "
+    "request that every other acquired pixel would be omitted.  That is, "
+    "when scanning a 200 pixel wide and 100 pixel tall area, the resulting "
+    "image would be only 100x50 pixels large.  Using a large transfer scale "
+    "improves acquisition speed, but reduces resolution.";
+  s->opt[OPT_XFER_SCALE].type = SANE_TYPE_INT;
+  s->opt[OPT_XFER_SCALE].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_XFER_SCALE].constraint.word_list = xfer_scale_list;
+  s->val[OPT_XFER_SCALE].w = xfer_scale_list[1];
+
+  /* despeckle */
+  s->opt[OPT_DESPECKLE].name = "despeckle";
+  s->opt[OPT_DESPECKLE].title = "Speckle filter";
+  s->opt[OPT_DESPECKLE].desc = "Turning on this filter will remove the "
+    "christmas lights that are typically present in dark images.";
+  s->opt[OPT_DESPECKLE].type = SANE_TYPE_BOOL;
+  s->opt[OPT_DESPECKLE].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_DESPECKLE].w = 0;
+
+
+  /* "Enhancement" group: */
+
+  s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
+  s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+  s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* brightness */
+  s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS
+    "  In a conventional camera, this control corresponds to the "
+    "exposure time.";
+  s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
+  s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_AUTOMATIC;
+  s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BRIGHTNESS].constraint.range = &brightness_range;
+  s->val[OPT_BRIGHTNESS].w = 135;
+
+  /* contrast */
+  s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
+  s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
+  s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
+  s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
+  s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_CONTRAST].constraint.range = &u8_range;
+  s->val[OPT_CONTRAST].w = 104;
+
+  /* black-level */
+  s->opt[OPT_BLACK_LEVEL].name = SANE_NAME_BLACK_LEVEL;
+  s->opt[OPT_BLACK_LEVEL].title = SANE_TITLE_BLACK_LEVEL;
+  s->opt[OPT_BLACK_LEVEL].desc = SANE_DESC_BLACK_LEVEL
+    " This value should be selected so that black areas just start "
+    "to look really black (not gray).";
+  s->opt[OPT_BLACK_LEVEL].type = SANE_TYPE_INT;
+  s->opt[OPT_BLACK_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BLACK_LEVEL].constraint.range = &u8_range;
+  s->val[OPT_BLACK_LEVEL].w = 0;
+
+  /* white-level */
+  s->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL;
+  s->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL;
+  s->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL
+    " This value should be selected so that white areas just start "
+    "to look really white (not gray).";
+  s->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_INT;
+  s->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_WHITE_LEVEL].constraint.range = &u8_range;
+  s->val[OPT_WHITE_LEVEL].w = 150;
+
+  /* hue */
+  s->opt[OPT_HUE].name = SANE_NAME_HUE;
+  s->opt[OPT_HUE].title = SANE_TITLE_HUE;
+  s->opt[OPT_HUE].desc = SANE_DESC_HUE;
+  s->opt[OPT_HUE].type = SANE_TYPE_INT;
+  s->opt[OPT_HUE].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_HUE].constraint.range = &u8_range;
+  s->val[OPT_HUE].w = 128;
+
+  /* saturation */
+  s->opt[OPT_SATURATION].name = SANE_NAME_SATURATION;
+  s->opt[OPT_SATURATION].title = SANE_TITLE_SATURATION;
+  s->opt[OPT_SATURATION].desc = SANE_DESC_SATURATION;
+  s->opt[OPT_SATURATION].type = SANE_TYPE_INT;
+  s->opt[OPT_SATURATION].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_SATURATION].constraint.range = &u8_range;
+  s->val[OPT_SATURATION].w = 100;
+
+  DBG (3, "init_options: exit\n");
+  
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  char dev_name[PATH_MAX], *str;
+  size_t len;
+  FILE *fp;
+  authorize = authorize;	/* silence compilation warnings */
+
+  DBG_INIT ();
+
+  DBG (1, "sane_init: enter\n");
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+  fp = sanei_config_open (QCAM_CONFIG_FILE);
+  if (!fp)
+    {
+      DBG (1, "sane_init: file `%s' not accessible\n", QCAM_CONFIG_FILE);
+      return SANE_STATUS_INVAL;
+    }
+
+  while (sanei_config_read (dev_name, sizeof (dev_name), fp))
+    {
+      if (dev_name[0] == '#')	/* ignore line comments */
+	continue;
+      len = strlen (dev_name);
+
+      if (!len)
+	continue;		/* ignore empty lines */
+
+      for (str = dev_name; *str && !isspace (*str) && *str != '#'; ++str);
+      *str = '\0';
+
+      attach (dev_name, 0);
+    }
+  fclose (fp);
+
+  DBG (1, "sane_init: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+  QC_Device *dev, *next;
+  static const SANE_Device **devlist;
+  
+  DBG (5, "sane_exit: enter\n");
+  
+  for (dev = first_dev; dev; dev = next)
+    {
+      next = dev->next;
+      free ((void *) dev->sane.name);
+      disable_ports (dev);
+      free (dev);
+    }
+  if (devlist) {
+	  free (devlist);
+          devlist = NULL;
+  }		  
+  DBG (5, "sane_exit: exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  static const SANE_Device **devlist = 0;
+  QC_Device *dev;
+  int i;
+
+  DBG (5, "sane_get_devices: enter\n");
+
+  local_only = local_only;	/* silence compilation warnings */
+
+  if (devlist)
+    free (devlist);
+
+  devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+  if (!devlist)
+    return SANE_STATUS_NO_MEM;
+
+  i = 0;
+  for (dev = first_dev; i < num_devices; dev = dev->next)
+    devlist[i++] = &dev->sane;
+  devlist[i++] = 0;
+
+  *device_list = devlist;
+  
+  DBG (5, "sane_get_devices: exit\n");
+  
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+  SANE_Status status;
+  QC_Device *dev;
+  QC_Scanner *s;
+
+  DBG (5, "sane_open: enter: (devicename = %s)\n", devicename);
+  if (devicename[0])
+    {
+      status = attach (devicename, &dev);
+      if (status != SANE_STATUS_GOOD)
+	return status;
+    }
+  else
+    /* empty devicname -> use first device */
+    dev = first_dev;
+
+  if (!dev)
+    return SANE_STATUS_INVAL;
+
+  s = malloc (sizeof (*s));
+  if (!s)
+    return SANE_STATUS_NO_MEM;
+  memset (s, 0, sizeof (*s));
+  s->user_corner = 0;
+  s->hw = dev;
+  s->value_changed = ~0;	/* ensure all options get updated */
+  s->reader_pid = -1;
+  s->to_child = -1;
+  s->from_child = -1;
+  s->read_fd = -1;
+
+  init_options (s);
+
+  /* The contrast option seems to have an effect for b&w cameras only,
+     so don't give the user the impression that this is a useful thing
+     to set... */
+  if (s->hw->version == QC_COLOR)
+    s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
+  else
+    {
+      /* Black level, Hue and Saturation are things the b&w cameras
+         know nothing about.  Despeckle might be useful, but this code
+         seems to work for color cameras only right now. The framesize
+         seems to work better in these ranges.  */
+      s->opt[OPT_DESPECKLE].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_HUE].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_SATURATION].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_RESOLUTION].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_TEST].cap |= SANE_CAP_INACTIVE;
+
+      s->opt[OPT_DEPTH].constraint.word_list = mono_depth_list;
+      s->val[OPT_DEPTH].w = mono_depth_list[NELEMS (mono_depth_list) - 1];
+      s->opt[OPT_TL_X].constraint.range = &bw_x_range;
+      s->val[OPT_TL_X].w = 14;
+      s->opt[OPT_TL_Y].constraint.range = &bw_y_range;
+      s->val[OPT_TL_Y].w = 0;
+      s->opt[OPT_BR_X].constraint.range = &odd_bw_x_range;
+      s->val[OPT_BR_X].w = 333;
+      s->opt[OPT_BR_Y].constraint.range = &odd_bw_y_range;
+      s->val[OPT_BR_Y].w = 239;
+
+      s->val[OPT_BRIGHTNESS].w = 170;
+      s->val[OPT_CONTRAST].w = 150;
+      s->val[OPT_WHITE_LEVEL].w = 150;
+    }
+
+  /* insert newly opened handle into list of open handles: */
+  s->next = first_handle;
+  first_handle = s;
+
+  *handle = s;
+
+  DBG (5, "sane_open: exit\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  QC_Scanner *prev, *s;
+
+  DBG (5, "sane_close: enter\n");
+  
+  /* remove handle from list of open handles: */
+  prev = 0;
+  for (s = first_handle; s; s = s->next)
+    {
+      if (s == handle)
+	break;
+      prev = s;
+    }
+  if (!s)
+    {
+      DBG (1, "sane_close: bad handle %p\n", handle);
+      return;			/* oops, not a handle we know about */
+    }
+  if (prev)
+    prev->next = s->next;
+  else
+    first_handle = s->next;
+
+  if (s->scanning)
+    sane_cancel (handle);
+
+  if (s->reader_pid >= 0)
+    {
+      kill (s->reader_pid, SIGTERM);
+      waitpid (s->reader_pid, 0, 0);
+      s->reader_pid = 0;
+    }
+  if (s->to_child >= 0)
+    close (s->to_child);
+  if (s->from_child >= 0)
+    close (s->from_child);
+  if (s->read_fd >= 0)
+    close (s->read_fd);
+
+  free (s);
+  
+  DBG (5, "sane_close: exit\n");
+	  
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  QC_Scanner *s = handle;
+
+  DBG (5, "sane_get_option_descriptor: enter\n");
+  
+  if ((unsigned) option >= NUM_OPTIONS)
+    return 0;
+
+  DBG (5, "sane_get_option_descriptor: exit\n");
+
+  return s->opt + option;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+		     SANE_Action action, void *val, SANE_Int * info)
+{
+  QC_Scanner *s = handle;
+  QC_Resolution old_res;
+  SANE_Status status;
+  SANE_Word cap;
+  char *old_val;
+  int i;
+
+  DBG (5, "sane_control_option: enter\n");
+  
+  if (info)
+    *info = 0;
+
+  if (option >= NUM_OPTIONS)
+    return SANE_STATUS_INVAL;
+
+  cap = s->opt[option].cap;
+
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    return SANE_STATUS_INVAL;
+
+  if (action == SANE_ACTION_GET_VALUE)
+    {
+      switch (option)
+	{
+	  /* word options: */
+	case OPT_NUM_OPTS:
+	case OPT_DEPTH:
+	case OPT_DESPECKLE:
+	case OPT_TEST:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_XFER_SCALE:
+	case OPT_BRIGHTNESS:
+	case OPT_CONTRAST:
+	case OPT_BLACK_LEVEL:
+	case OPT_WHITE_LEVEL:
+	case OPT_HUE:
+	case OPT_SATURATION:
+	  *(SANE_Word *) val = s->val[option].w;
+	  return SANE_STATUS_GOOD;
+
+	  /* string options: */
+	case OPT_RESOLUTION:
+	  strcpy (val, s->val[option].s);
+	  return SANE_STATUS_GOOD;
+
+	default:
+	  DBG (1, "control_option: option %d unknown\n", option);
+	}
+    }
+  else if (action == SANE_ACTION_SET_VALUE)
+    {
+      if (!SANE_OPTION_IS_SETTABLE (cap))
+	return SANE_STATUS_INVAL;
+
+      status = sanei_constrain_value (s->opt + option, val, info);
+      if (status != SANE_STATUS_GOOD)
+	return status;
+
+      if (option >= OPT_TL_X && option <= OPT_BR_Y)
+	s->user_corner |= 1 << (option - OPT_TL_X);
+
+      assert (option <= 31);
+      s->value_changed |= 1 << option;
+
+      switch (option)
+	{
+	  /* (mostly) side-effect-free word options: */
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_XFER_SCALE:
+	case OPT_DEPTH:
+	  if (!s->scanning && info && s->val[option].w != *(SANE_Word *) val)
+	    /* only signal the reload params if we're not scanning---no point
+	       in creating the frontend useless work */
+	    *info |= SANE_INFO_RELOAD_PARAMS;
+	  /* fall through */
+	case OPT_NUM_OPTS:
+	case OPT_TEST:
+	case OPT_DESPECKLE:
+	case OPT_BRIGHTNESS:
+	case OPT_CONTRAST:
+	case OPT_BLACK_LEVEL:
+	case OPT_WHITE_LEVEL:
+	case OPT_HUE:
+	case OPT_SATURATION:
+	  s->val[option].w = *(SANE_Word *) val;
+	  return SANE_STATUS_GOOD;
+
+	  /* options with side-effects: */
+	case OPT_RESOLUTION:
+	  old_val = s->val[OPT_RESOLUTION].s;
+
+	  if (strcmp (old_val, val) != 0)
+	    return SANE_STATUS_GOOD;	/* no change */
+
+	  if (info)
+	    {
+	      *info |= SANE_INFO_RELOAD_OPTIONS;
+	      if (!s->scanning)
+		*info |= SANE_INFO_RELOAD_PARAMS;
+	    }
+	  free (old_val);
+	  s->val[OPT_RESOLUTION].s = strdup (val);
+
+	  /* low-resolution mode: */
+	  old_res = s->resolution;
+	  s->resolution = QC_RES_LOW;
+	  if (strcmp (val, resolution_list[QC_RES_HIGH]) == 0)
+	    /* high-resolution mode: */
+	    s->resolution = QC_RES_HIGH;
+	  s->opt[OPT_TL_X].constraint.range = &x_range[s->resolution];
+	  s->opt[OPT_BR_X].constraint.range = &odd_x_range[s->resolution];
+	  s->opt[OPT_TL_Y].constraint.range = &y_range[s->resolution];
+	  s->opt[OPT_BR_Y].constraint.range = &odd_y_range[s->resolution];
+
+	  if (old_res == QC_RES_LOW && s->resolution == QC_RES_HIGH)
+	    {
+	      for (i = OPT_TL_X; i <= OPT_BR_Y; ++i)
+		s->val[i].w *= 2;
+	      s->val[OPT_BR_X].w += 1;
+	      s->val[OPT_BR_Y].w += 1;
+	      s->opt[OPT_TEST].cap |= SANE_CAP_INACTIVE;
+	    }
+	  else if (old_res == QC_RES_HIGH && s->resolution == QC_RES_LOW)
+	    {
+	      for (i = OPT_TL_X; i <= OPT_BR_Y; ++i)
+		s->val[i].w /= 2;
+	      s->opt[OPT_TEST].cap &= ~SANE_CAP_INACTIVE;
+	    }
+
+	  if (!(s->user_corner & 0x4))
+	    s->val[OPT_BR_X].w = odd_x_range[s->resolution].max;
+	  if (!(s->user_corner & 0x8))
+	    s->val[OPT_BR_Y].w = odd_y_range[s->resolution].max - 4;
+
+	  /* make sure the affected options have valid values: */
+	  for (i = OPT_TL_X; i <= OPT_BR_Y; ++i)
+	    if (s->val[i].w > s->opt[i].constraint.range->max)
+	      s->val[i].w = s->opt[i].constraint.range->max;
+
+          DBG (5, "sane_control_option: exit\n");
+	  return SANE_STATUS_GOOD;
+	}
+    }
+  else if (action == SANE_ACTION_SET_AUTO)
+    {
+      switch (option)
+	{
+	case OPT_BRIGHTNESS:
+	  /* not implemented yet */
+          DBG (5, "sane_control_option: exit\n");
+	  return SANE_STATUS_GOOD;
+
+	default:
+	  break;
+	}
+    }
+
+  DBG (5, "sane_control_option: NOK exit\n");
+  return SANE_STATUS_INVAL;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  QC_Scanner *s = handle;
+  QC_Device *q = s->hw;
+  int xfer_scale;
+  size_t Bpp = 3;		/* # of bytes per pixel */
+
+  DBG (5, "sane_get_parameters: enter\n");
+  
+  if (!s->scanning)
+    {
+      /* Only compute new parameters when not scanning---allows
+         changing width/height etc while scan is in progress.  */
+      xfer_scale = s->val[OPT_XFER_SCALE].w;
+
+      s->params.format = SANE_FRAME_RGB;
+      if (q->version != QC_COLOR)
+	{
+	  s->params.format = SANE_FRAME_GRAY;
+	  Bpp = 1;
+	}
+      s->params.last_frame = SANE_TRUE;
+
+      s->params.pixels_per_line = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w + 1;
+      s->params.pixels_per_line /= xfer_scale;
+      s->params.pixels_per_line &= ~1UL;	/* ensure it's even */
+      if (s->params.pixels_per_line < 2)
+	s->params.pixels_per_line = 2;
+
+      s->params.lines = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w + 1;
+      s->params.lines /= xfer_scale;
+      if (s->params.lines < 1)
+	s->params.lines = 1;
+
+      s->params.bytes_per_line = Bpp * s->params.pixels_per_line;
+      s->params.depth = 8;
+    }
+  if (params)
+    *params = s->params;
+
+  DBG (5, "sane_get_parameters: exit\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  int top, left, width, height, undecimated_width, undecimated_height;
+  QC_Scanner *s = handle;
+  QC_Device *q = s->hw;
+  QC_Scan_Request req;
+
+  DBG (5, "sane_start: enter\n");
+  
+  if (s->scanning)
+    return SANE_STATUS_DEVICE_BUSY;
+
+  if (s->reader_pid < 0)
+    {
+      int p2c_pipe[2];		/* parent->child pipe */
+      int c2p_pipe[2];		/* child->parent pipe */
+
+      if (pipe (p2c_pipe) < 0 || pipe (c2p_pipe) < 0)
+	{
+	  DBG (3, "start: failed to create pipes\n");
+	  return SANE_STATUS_IO_ERROR;
+	}
+
+      s->reader_pid = fork ();
+      if (s->reader_pid == 0)
+	{
+	  /* this is the child */
+	  signal (SIGHUP, SIG_DFL);
+	  signal (SIGINT, SIG_DFL);
+	  signal (SIGPIPE, SIG_DFL);
+	  signal (SIGTERM, SIG_DFL);
+	  _exit (reader_process (s, p2c_pipe[0], c2p_pipe[1]));
+	}
+      close (p2c_pipe[0]);
+      close (c2p_pipe[1]);
+      s->to_child = p2c_pipe[1];
+      s->from_child = c2p_pipe[0];
+    }
+
+  s->read_fd = dup (s->from_child);
+  sane_get_parameters (s, 0);	/* ensure uptodate parameters */
+
+  qc_lock (q);
+  s->holding_lock = SANE_TRUE;
+
+  if (q->version == QC_COLOR)
+    {
+      qc_send (q, QC_SET_SPEED);
+      qc_send (q, 2);
+
+      /* wait for camera to become ready: */
+      while (qc_getstatus (q) & CameraNotReady)
+	usleep (10000);
+
+      /* Only send black_level if necessary; this optimization may
+         fail if two applications access the camera in an interleaved
+         fashion; but the black-level command is slow enough that it
+         cannot be issued for every image acquisition.  */
+      if (s->value_changed & (1 << OPT_BLACK_LEVEL))
+	{
+	  s->value_changed &= ~(1 << OPT_BLACK_LEVEL);
+
+	  qc_send (q, QC_SET_BLACK);
+	  qc_send (q, s->val[OPT_BLACK_LEVEL].w);
+
+	  DBG (3, "start: black_level=%d\n", s->val[OPT_BLACK_LEVEL].w);
+
+	  /* wait for set black level command to finish: */
+	  while (qc_getstatus (q) & (CameraNotReady | BlackBalanceInProgress))
+	    usleep (10000);
+	}
+
+      if (s->value_changed & (1 << OPT_HUE))
+	{
+	  s->value_changed &= ~(1 << OPT_HUE);
+	  qc_send (q, QC_COL_SET_HUE);
+	  qc_send (q, s->val[OPT_HUE].w);
+	}
+
+      if (s->value_changed & (1 << OPT_SATURATION))
+	{
+	  s->value_changed &= ~(1 << OPT_SATURATION);
+	  qc_send (q, QC_SET_SATURATION);
+	  qc_send (q, s->val[OPT_SATURATION].w);
+	}
+    }
+
+  if (q->version != QC_COLOR)
+    qc_reset (q);
+
+  if (s->value_changed & (1 << OPT_CONTRAST))
+    {
+      s->value_changed &= ~(1 << OPT_CONTRAST);
+      qc_send (q, ((q->version == QC_COLOR)
+		   ? QC_COL_SET_CONTRAST : QC_MONO_SET_CONTRAST));
+      qc_send (q, s->val[OPT_CONTRAST].w);
+    }
+
+  if (s->value_changed & (1 << OPT_BRIGHTNESS))
+    {
+      s->value_changed &= ~(1 << OPT_BRIGHTNESS);
+      qc_send (q, QC_SET_BRIGHTNESS);
+      qc_send (q, s->val[OPT_BRIGHTNESS].w);
+    }
+
+  width = s->params.pixels_per_line;
+  height = s->params.lines;
+  if (s->resolution == QC_RES_HIGH)
+    {
+      width /= 2;		/* the expansion occurs through oversampling */
+      height /= 2;		/* we acquire only half the lines that we generate */
+    }
+  undecimated_width = width * s->val[OPT_XFER_SCALE].w;
+  undecimated_height = height * s->val[OPT_XFER_SCALE].w;
+
+  s->num_bytes = 0;
+  s->bytes_per_frame = s->params.lines * s->params.bytes_per_line;
+
+  qc_send (q, QC_SET_NUM_V);
+  qc_send (q, undecimated_height);
+
+  if (q->version == QC_COLOR)
+    {
+      qc_send (q, QC_SET_NUM_H);
+      qc_send (q, undecimated_width / 2);
+    }
+  else
+    {
+      int val, val2;
+
+      if (q->port_mode == QC_UNIDIR && s->val[OPT_DEPTH].w == 6)
+	{
+	  val = undecimated_width;
+	  val2 = s->val[OPT_XFER_SCALE].w * 4;
+	}
+      else
+	{
+	  val = undecimated_width * s->val[OPT_DEPTH].w;
+	  val2 =
+	    ((q->port_mode == QC_BIDIR) ? 24 : 8) * s->val[OPT_XFER_SCALE].w;
+	}
+      val = (val + val2 - 1) / val2;
+      qc_send (q, QC_SET_NUM_H);
+      qc_send (q, val);
+    }
+
+  left = s->val[OPT_TL_X].w / 2;
+  top = s->val[OPT_TL_Y].w;
+  if (s->resolution == QC_RES_HIGH)
+    {
+      left /= 2;
+      top /= 2;
+    }
+
+  DBG (3, "sane_start: top=%d, left=%d, white=%d, bright=%d, contr=%d\n",
+       top, left, s->val[OPT_WHITE_LEVEL].w, s->val[OPT_BRIGHTNESS].w,
+       s->val[OPT_CONTRAST].w);
+
+  qc_send (q, QC_SET_LEFT);
+  qc_send (q, left);
+
+  qc_send (q, QC_SET_TOP);
+  qc_send (q, top + 1);		/* not sure why this is so... ;-( */
+
+  if (s->value_changed & (1 << OPT_WHITE_LEVEL))
+    {
+      s->value_changed &= ~(1 << OPT_WHITE_LEVEL);
+      qc_send (q, QC_SET_WHITE);
+      qc_send (q, s->val[OPT_WHITE_LEVEL].w);
+    }
+
+  DBG (2, "start: %s %d lines of %d pixels each (%ld bytes) => %dx%d\n",
+       (q->port_mode == QC_BIDIR) ? "bidir" : "unidir",
+       height, width, (long) s->bytes_per_frame,
+       s->params.pixels_per_line, s->params.lines);
+
+  /* send scan request to reader process: */
+  qc_setscanmode (s, &req.mode);
+  req.num_bytes = width * height;
+  if (q->version == QC_COLOR)
+    {
+      if (s->resolution == QC_RES_LOW)
+	req.num_bytes *= 3;
+      else
+	req.num_bytes *= 4;
+    }
+  req.resolution = s->resolution;
+  req.params = s->params;
+  req.despeckle = s->val[OPT_DESPECKLE].w;
+  write (s->to_child, &req, sizeof (req));
+
+  s->scanning = SANE_TRUE;
+  s->deliver_eof = 0;
+
+  DBG (5, "sane_start: exit\n");
+  
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+	   SANE_Int * lenp)
+{
+  SANE_Status status;
+  QC_Scanner *s = handle;
+  QC_Device *q = s->hw;
+  ssize_t nread;
+  size_t len;
+
+  DBG (5, "sane_read: enter\n");
+  
+  *lenp = 0;
+
+  if (s->deliver_eof)
+    {
+      s->deliver_eof = 0;
+      return SANE_STATUS_EOF;
+    }
+
+  if (!s->scanning)
+    return SANE_STATUS_CANCELLED;
+
+  len = max_len;
+  if (s->num_bytes + len > s->bytes_per_frame)
+    len = s->bytes_per_frame - s->num_bytes;
+
+  DBG (8, "read(buf=%p,num_bytes=%ld,max_len=%d,len=%ld)\n",
+       buf, (long) s->num_bytes, max_len, (long) len);
+
+  nread = read (s->read_fd, buf, len);
+  if (nread <= 0)
+    {
+      if (nread == 0 || errno == EAGAIN)
+	{
+	  DBG (3, "read: no more data available\n");
+	  return SANE_STATUS_GOOD;
+	}
+      DBG (3, "read: short read (%s)\n", strerror (errno));
+      return SANE_STATUS_IO_ERROR;
+    }
+
+  if (nread > 0 && s->holding_lock)
+    {
+      status = qc_unlock (q);	/* now we can unlock the camera */
+      if (status != SANE_STATUS_GOOD)
+	      DBG(3, "sane_read: qc_unlock error\n");
+      s->holding_lock = SANE_FALSE;
+    }
+
+  s->num_bytes += nread;
+  if (s->num_bytes >= s->bytes_per_frame)
+    {
+      s->scanning = SANE_FALSE;
+      close (s->read_fd);
+      s->read_fd = -1;
+      s->deliver_eof = 1;
+    }
+
+  if (lenp)
+    *lenp = nread;
+
+  DBG (5, "sane_read: exit, read got %d bytes\n", *lenp);
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  QC_Scanner *s = handle;
+  SANE_Bool was_scanning;
+  SANE_Status status;
+
+  DBG (5, "sane_cancel: enter\n");
+  
+  was_scanning = s->scanning;
+  s->scanning = SANE_FALSE;
+  s->deliver_eof = 0;
+  if (s->read_fd >= 0)
+    {
+      close (s->read_fd);
+      s->read_fd = -1;
+    }
+
+  if (s->reader_pid >= 0 && was_scanning)
+    {
+      char buf[1024];
+      ssize_t nread;
+      int flags;
+
+      DBG (1, "cancel: cancelling read request\n");
+
+      kill (s->reader_pid, SIGINT);	/* tell reader to stop reading */
+
+      /* save non-blocking i/o flags: */
+      flags = fcntl (s->from_child, F_GETFL, 0);
+
+      /* block until we read at least one byte: */
+      read (s->from_child, buf, 1);
+
+      /* put descriptor in non-blocking i/o: */
+      fcntl (s->from_child, F_SETFL, O_NONBLOCK);
+
+      /* read what's left over in the pipe/file buffer: */
+      do
+	{
+	  while ((nread = read (s->from_child, buf, sizeof (buf))) > 0);
+	  usleep (100000);
+	  nread = read (s->from_child, buf, sizeof (buf));
+	}
+      while (nread > 0);
+
+      /* now restore non-blocking i/o flag: */
+      fcntl (s->from_child, F_SETFL, flags & O_NONBLOCK);
+
+      waitpid (s->reader_pid, 0, 0);
+      s->reader_pid = 0;
+
+      DBG (1, "cancel: cancellation completed\n");
+    }
+  if (s->holding_lock)
+    {
+      status = qc_unlock (s->hw);
+      if (status != SANE_STATUS_GOOD)
+	      DBG(3, "sane_cancel: qc_unlock error\n");
+      s->holding_lock = SANE_FALSE;
+    }
+  DBG (5, "sane_cancel: exit\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  QC_Scanner *s = handle;
+
+  DBG (5, "sane_set_io_mode: enter\n");
+  
+  if (!s->scanning)
+    return SANE_STATUS_INVAL;
+
+  if (fcntl (s->read_fd, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0)
+    return SANE_STATUS_IO_ERROR;
+  DBG (5, "sane_set_io_mode: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+  QC_Scanner *s = handle;
+
+  DBG (5, "sane_get_select_fd: enter\n");
+  if (!s->scanning)
+    return SANE_STATUS_INVAL;
+
+  *fd = s->read_fd;
+  DBG (5, "sane_get_select_fd: exit\n");
+  return SANE_STATUS_GOOD;
+}