Logo Search packages:      
Sourcecode: sane-backends version File versions

qcam.c

/* 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 "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 "sane/sane.h"
#include "sane/sanei.h"
#include "sane/saneopts.h"


#define BACKEND_NAME qcam
#include "sane/sanei_backend.h"

#ifndef PATH_MAX
# define PATH_MAX 1024
#endif

#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(__linux__) || defined (HAVE_SYS_HW_H)

#ifdef HAVE_SYS_IO_H
# include <sys/io.h>    /* GNU libc based Linux */
#elif HAVE_ASM_IO_H
# include <asm/io.h>    /* older Linux */
#elif HAVE_SYS_HW_H
# include <sys/hw.h>    /* OS/2 */
#endif

#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)

#endif /* __linux__ */

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)
{
  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_lock_wait: releasing lock for 0x%x\n", q->port);

#ifdef F_SETLK
  memset (&sfl, 0, sizeof (sfl));
#endif

  if (q->lock_fd < 0)
    return SANE_STATUS_INVAL;        /* port was not locked */

  /* clear the exclusive lock */
#ifdef F_SETLK
  sfl.l_type = F_UNLCK;
  if (fcntl (q->lock_fd, F_SETLK, &sfl) != 0)
    {
      DBG(1, "qc_lock_wait: failed to release lock (%s)\n",
        strerror (errno));
      return SANE_STATUS_INVAL;
    }
#endif
  sprintf (lockfile, "/tmp/LOCK.qcam.0x%x", q->port);
  unlink (lockfile);
  close (q->lock_fd);
  q->lock_fd = -1;
  return SANE_STATUS_GOOD;
}

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;

  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 */
  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;
  QC_Device * q;
  char *endp;

  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);
    }

  qc_unlock (q);

  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;
  return SANE_STATUS_GOOD;

unlock_and_fail:
  qc_unlock (q);
  free (q);
  return SANE_STATUS_INVAL;
}

static SANE_Status
init_options (QC_Scanner *s)
{
  int i;

  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
                   | SANE_CAP_ALWAYS_SETTABLE);
    }

  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;

  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();

  if (version_code)
    *version_code = SANE_VERSION_CODE (V_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);
  return SANE_STATUS_GOOD;
}

void
sane_exit (void)
{
  QC_Device *dev, *next;

  for (dev = first_dev; dev; dev = next)
    {
      next = dev->next;
      free ((void *) dev->sane.name);
      disable_ports (dev);
      free (dev);
    }
}

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;

  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;
  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(4, "open(%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;
  return SANE_STATUS_GOOD;
}

void
sane_close (SANE_Handle handle)
{
  QC_Scanner *prev, *s;

  /* 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);
}

const SANE_Option_Descriptor *
sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
{
  QC_Scanner *s = handle;

  if ((unsigned) option >= NUM_OPTIONS)
    return 0;
  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;

  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;

        return SANE_STATUS_GOOD;
      }
    }
  else if (action == SANE_ACTION_SET_AUTO)
    {
      switch (option)
      {
      case OPT_BRIGHTNESS:
        /* not implemented yet */
        return SANE_STATUS_GOOD;

      default:
        break;
      }
    }
  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 */

  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;

  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;

  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;
  return SANE_STATUS_GOOD;
}

SANE_Status
sane_read (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len,
         SANE_Int *lenp)
{
  QC_Scanner *s = handle;
  QC_Device *q = s->hw;
  ssize_t nread;
  size_t len;

  *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)
    {
      qc_unlock (q);                /* now we can unlock the camera */
      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(8, "read: got %d bytes\n", *lenp);
  return SANE_STATUS_GOOD;
}

void
sane_cancel (SANE_Handle handle)
{
  QC_Scanner *s = handle;
  SANE_Bool was_scanning;

  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)
    {
      qc_unlock (s->hw);
      s->holding_lock = SANE_FALSE;
    }
}

SANE_Status
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
{
  QC_Scanner *s = handle;

  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;
  return SANE_STATUS_GOOD;
}

SANE_Status
sane_get_select_fd (SANE_Handle handle, SANE_Int *fd)
{
  QC_Scanner *s = handle;

  if (!s->scanning)
    return SANE_STATUS_INVAL;

  *fd = s->read_fd;
  return SANE_STATUS_GOOD;
}

Generated by  Doxygen 1.6.0   Back to index