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

artec.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 Artec/Ultima scanners.

   Copyright (C) 1998-2000 Chris Pinkham
   Released under the terms of the GPL.
   *NO WARRANTY*

   Portions contributed by:
   David Leadbetter - A6000C (3-pass)
   Dick Bruijn - AT12

   *********************************************************************
   For feedback/information:

   cpinkham@corp.infi.net
   http://www4.infi.net/~cpinkham/sane/sane-artec-doc.html
   *********************************************************************
 */

#include "../include/sane/config.h"

#include <ctype.h>
#include <limits.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "sane/sane.h"
#include "sane/saneopts.h"
#include "sane/sanei_scsi.h"
#include "sane/sanei_backend.h"
#include "sane/sanei_config.h"

#include <artec.h>

#define BACKEND_NAME    artec

#define ARTEC_MAJOR     0
#define ARTEC_MINOR     5
#define ARTEC_SUB       16
#define ARTEC_LAST_MOD  "05/26/2001 17:28 EST"

#define MM_PER_INCH     25.4

#ifndef PATH_MAX
#define PATH_MAX  1024
#endif

#define ARTEC_CONFIG_FILE "artec.conf"
#define ARTEC_MAX_READ_SIZE 32768

static int num_devices;
static const SANE_Device **devlist = 0;
static ARTEC_Device *first_dev;
static ARTEC_Scanner *first_handle;

static const SANE_String_Const mode_list[] =
{
  "Lineart", "Halftone", "Gray", "Color",
  0
};

static const SANE_String_Const filter_type_list[] =
{
  "Mono", "Red", "Green", "Blue",
  0
};

static const SANE_String_Const halftone_pattern_list[] =
{
  "User defined (unsupported)", "4x4 Spiral", "4x4 Bayer", "8x8 Spiral",
  "8x8 Bayer",
  0
};

static const SANE_Range u8_range =
{
  0,                    /* minimum */
  255,                        /* maximum */
  0                     /* quantization */
};

#define INQ_LEN   0x60
static const u_int8_t inquiry[] =
{
  0x12, 0x00, 0x00, 0x00, INQ_LEN, 0x00
};

static const u_int8_t test_unit_ready[] =
{
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

static struct
  {
    SANE_String model;        /* product model */
    SANE_String type;         /* type of scanner */
    double width;       /* width in inches */
    double height;            /* height in inches */
    SANE_Word adc_bits;       /* Analog-to-Digital Converter Bits */
    SANE_Word setwindow_cmd_size;   /* Set-Window command size */
    SANE_Word max_read_size;  /* Max Read size in bytes */
    long flags;               /* flags */
    SANE_String horz_resolution_str;      /* Horizontal resolution list */
    SANE_String vert_resolution_str;      /* Vertical resolution list */
  }
cap_data[] =
{
  {
    "AT3", "flatbed",
      8.3, 11, 8, 55, 32768,
      ARTEC_FLAG_CALIBRATE_RGB |
      ARTEC_FLAG_RGB_LINE_OFFSET |
      ARTEC_FLAG_RGB_CHAR_SHIFT |
      ARTEC_FLAG_OPT_CONTRAST |
      ARTEC_FLAG_GAMMA_SINGLE |
      ARTEC_FLAG_SEPARATE_RES |
      ARTEC_FLAG_SENSE_HANDLER |
      ARTEC_FLAG_SENSE_BYTE_19 |
      ARTEC_FLAG_ADF |
      ARTEC_FLAG_HALFTONE_PATTERN |
      ARTEC_FLAG_MBPP_NEGATIVE |
      ARTEC_FLAG_ONE_PASS_SCANNER,
      "50,100,200,300", "50,100,200,300,600"
  }
  ,
  {
    "A6000C", "flatbed",
      8.3, 14, 8, 55, 8192,
/* some have reported that Calibration does not work the same as AT3 & A6000C+
   ARTEC_FLAG_CALIBRATE_RGB |
 */
      ARTEC_FLAG_OPT_CONTRAST |
      ARTEC_FLAG_OPT_BRIGHTNESS |
      ARTEC_FLAG_SEPARATE_RES |
      ARTEC_FLAG_SENSE_HANDLER |
      ARTEC_FLAG_ADF |
      ARTEC_FLAG_HALFTONE_PATTERN,
      "50,100,200,300", "50,100,200,300,600"
  }
  ,
  {
    "A6000C PLUS", "flatbed",
      8.3, 14, 8, 55, 8192,
      ARTEC_FLAG_CALIBRATE_RGB |
      ARTEC_FLAG_RGB_LINE_OFFSET |
      ARTEC_FLAG_RGB_CHAR_SHIFT |
      ARTEC_FLAG_OPT_CONTRAST |
      ARTEC_FLAG_GAMMA_SINGLE |
      ARTEC_FLAG_SEPARATE_RES |
      ARTEC_FLAG_SENSE_HANDLER |
      ARTEC_FLAG_SENSE_BYTE_19 |
      ARTEC_FLAG_ADF |
      ARTEC_FLAG_HALFTONE_PATTERN |
      ARTEC_FLAG_MBPP_NEGATIVE |
      ARTEC_FLAG_ONE_PASS_SCANNER,
      "50,100,200,300", "50,100,200,300,600"
  }
  ,
  {
    "AT6", "flatbed",
      8.3, 11, 10, 55, 32768,
      ARTEC_FLAG_CALIBRATE_RGB |
      ARTEC_FLAG_RGB_LINE_OFFSET |
      ARTEC_FLAG_RGB_CHAR_SHIFT |
      ARTEC_FLAG_OPT_CONTRAST |
/* gamma not working totally correct yet.
   ARTEC_FLAG_GAMMA_SINGLE |
 */
      ARTEC_FLAG_SEPARATE_RES |
      ARTEC_FLAG_SENSE_HANDLER |
      ARTEC_FLAG_ADF |
      ARTEC_FLAG_HALFTONE_PATTERN |
      ARTEC_FLAG_MBPP_NEGATIVE |
      ARTEC_FLAG_ONE_PASS_SCANNER,
      "50,100,200,300", "50,100,200,300,600"
  }
  ,
  {
    "AT12", "flatbed",
      8.5, 11, 12, 67, 32768,
/* calibration works slower so disabled
   ARTEC_CALIBRATE_DARK_WHITE |
 */
/* gamma not working totally correct yet.
   ARTEC_FLAG_GAMMA |
 */
      ARTEC_FLAG_OPT_CONTRAST |
      ARTEC_FLAG_SEPARATE_RES |
      ARTEC_FLAG_SENSE_HANDLER |
      ARTEC_FLAG_SENSE_ENH_18 |
      ARTEC_FLAG_SENSE_BYTE_22 |
      ARTEC_FLAG_SC_BUFFERS_LINES |
      ARTEC_FLAG_SC_HANDLES_OFFSET |
      ARTEC_FLAG_PIXEL_AVERAGING |
      ARTEC_FLAG_ENHANCE_LINE_EDGE |
      ARTEC_FLAG_ADF |
      ARTEC_FLAG_HALFTONE_PATTERN |
      ARTEC_FLAG_MBPP_NEGATIVE |
      ARTEC_FLAG_ONE_PASS_SCANNER,
      "25,50,100,200,300,400,500,600",
      "25,50,100,200,300,400,500,600,700,800,900,1000,1100,1200"
  }
  ,
  {
    "AM12S", "flatbed",
      8.26, 11.7, 12, 67, ARTEC_MAX_READ_SIZE,
/* calibration works slower so disabled
   ARTEC_CALIBRATE_DARK_WHITE |
 */
/* gamma not working totally correct yet.
   ARTEC_FLAG_GAMMA |
 */
      ARTEC_FLAG_RGB_LINE_OFFSET |
      ARTEC_FLAG_SEPARATE_RES |
      ARTEC_FLAG_IMAGE_REV_LR |
      ARTEC_FLAG_REVERSE_WINDOW |
      ARTEC_FLAG_SENSE_HANDLER |
      ARTEC_FLAG_SENSE_ENH_18 |
      ARTEC_FLAG_MBPP_NEGATIVE |
      ARTEC_FLAG_ONE_PASS_SCANNER,
      "50,100,300,600",
      "50,100,300,600,1200"
  }
  ,
};

/* store vendor and model if hardcoded in artec.conf */
static char artec_vendor[9] = "";
static char artec_model[17] = "";

/* file descriptor for debug data output */
static int debug_fd = -1;

static char *artec_skip_whitespace (char *str)
{
  while (isspace (*str))
    ++str;
  return str;
}

static SANE_Status
artec_str_list_to_word_list (SANE_Word ** word_list_ptr, SANE_String str)
{
  SANE_Word *word_list;
  char *start;
  char *end;
  char temp_str[1024];
  int comma_count = 1;

  if ((str == NULL) ||
      (strlen (str) == 0))
    {
      /* alloc space for word which stores length (0 in this case) */
      word_list = (SANE_Word *) malloc (sizeof (SANE_Word));
      if (word_list == NULL)
      return (SANE_STATUS_NO_MEM);

      word_list[0] = 0;
      *word_list_ptr = word_list;
      return (SANE_STATUS_GOOD);
    }

  /* make temp copy of input string (only hold 1024 for now) */
  strncpy (temp_str, str, 1023);
  temp_str[1023] = '\0';

  end = strchr (temp_str, ',');
  while (end != NULL)
    {
      comma_count++;
      start = end + 1;
      end = strchr (start, ',');
    }

  word_list = (SANE_Word *) calloc (comma_count + 1,
                            sizeof (SANE_Word));

  if (word_list == NULL)
    return (SANE_STATUS_NO_MEM);

  word_list[0] = comma_count;

  comma_count = 1;
  start = temp_str;
  end = strchr (temp_str, ',');
  while (end != NULL)
    {
      *end = '\0';
      word_list[comma_count] = atol (start);

      start = end + 1;
      comma_count++;
      end = strchr (start, ',');
    }

  word_list[comma_count] = atol (start);

  *word_list_ptr = word_list;
  return (SANE_STATUS_GOOD);
}

static size_t
artec_get_str_index (const SANE_String_Const strings[], char *str)
{
  size_t index;

  index = 0;
  while ((strings[index]) && strcmp (strings[index], str))
    {
      index++;
    }

  if (!strings[index])
    {
      index = 0;
    }

  return (index);
}

static size_t
max_string_size (const SANE_String_Const strings[])
{
  size_t size, max_size = 0;
  int i;

  for (i = 0; strings[i]; ++i)
    {
      size = strlen (strings[i]) + 1;
      if (size > max_size)
      max_size = size;
    }

  return (max_size);
}

/* DB added a sense handler */
/* last argument is expected to be a pointer to a Artec_Scanner structure */
static SANE_Status
sense_handler (int fd, u_char * sense, void *arg)
{
  ARTEC_Scanner *s = (ARTEC_Scanner *)arg;
  int err;

  err = 0;

  DBG(2, "sense fd: %d, data: %02x %02x %02x %02x %02x %02x %02x %02x "
    "%02x %02x %02x %02x %02x %02x %02x %02x\n", fd,
    sense[0], sense[1], sense[2], sense[3],
    sense[4], sense[5], sense[6], sense[7],
    sense[8], sense[9], sense[10], sense[11],
    sense[12], sense[13], sense[14], sense[15]);

  /* byte 18 info pertaining to ADF */
  if ((s) && (s->hw->flags & ARTEC_FLAG_ADF))
    {
      if (sense[18] & 0x01)
      {
        DBG (2, "sense:  ADF PAPER JAM\n");
        err++;
      }
      if (sense[18] & 0x02)
      {
        DBG (2, "sense:  ADF NO DOCUMENT IN BIN\n");
        err++;
      }
      if (sense[18] & 0x04)
      {
        DBG (2, "sense:  ADF SWITCH COVER OPEN\n");
        err++;
      }
      /* DB : next is, i think no failure, so no incrementing s */
      if (sense[18] & 0x08)
      {
        DBG (2, "sense:  ADF SET CORRECTLY ON TARGET\n");
      }
      /* The following only for AT12, its reserved (zero?) on other models,  */
      if (sense[18] & 0x10)
      {
        DBG (2, "sense:  ADF LENGTH TOO SHORT\n");
        err++;
      }
    }

  /* enhanced byte 18 sense data */
  if ((s) && (s->hw->flags & ARTEC_FLAG_SENSE_ENH_18))
    {
      if (sense[18] & 0x20)
      {
        DBG (2, "sense:  LAMP FAIL : NOT WARM \n");
        err++;
      }
      if (sense[18] & 0x40)
      {
        DBG (2, "sense:  NOT READY STATE\n");
        err++;
      }
    }

  if ((s) && (s->hw->flags & ARTEC_FLAG_SENSE_BYTE_19))
    {
      if (sense[19] & 0x01)
      {
        DBG (2, "sense:  8031 program ROM checksum Error\n");
        err++;
      }
      if (sense[19] & 0x02)
      {
        DBG (2, "sense:  8031 data RAM R/W Error\n");
        err++;
      }
      if (sense[19] & 0x04)
      {
        DBG (2, "sense:  Shadow Correction RAM R/W Error\n");
        err++;
      }
      if (sense[19] & 0x08)
      {
        DBG (2, "sense:  Line RAM R/W Error\n");
        err++;
      }
      if (sense[19] & 0x10)
      {
        /* docs say "reserved to '0'" */
        DBG (2, "sense:  CCD control circuit Error\n");
        err++;
      }
      if (sense[19] & 0x20)
      {
        DBG (2, "sense:  Motor End Switch Error\n");
        err++;
      }
      if (sense[19] & 0x40)
      {
        /* docs say "reserved to '0'" */
        DBG (2, "sense:  Lamp Error\n");
        err++;
      }
      if (sense[19] & 0x80)
      {
        DBG (2, "sense:  Optical Calibration/Shading Error\n");
        err++;
      }
    }

  /* These are the self test results for tests 0-15 */
  if ((s) && (s->hw->flags & ARTEC_FLAG_SENSE_BYTE_22))
    {
      if (sense[22] & 0x01)
      {
        DBG (2, "sense:  8031 Internal Memory R/W Error\n");
        err++;
      }
      if (sense[22] & 0x02)
      {
        DBG (2, "sense:  EEPROM test pattern R/W Error\n");
        err++;
      }
      if (sense[22] & 0x04)
      {
        DBG (2, "sense:  ASIC Test Error\n");
        err++;
      }
      if (sense[22] & 0x08)
      {
        DBG (2, "sense:  Line RAM R/W Error\n");
        err++;
      }
      if (sense[22] & 0x10)
      {
        DBG (2, "sense:  PSRAM R/W Test Error\n");
        err++;
      }
      if (sense[22] & 0x20)
      {
        DBG (2, "sense:  Positioning Error\n");
        err++;
      }
      if (sense[22] & 0x40)
      {
        DBG (2, "sense:  Test 6 Error\n");
        err++;
      }
      if (sense[22] & 0x80)
      {
        DBG (2, "sense:  Test 7 Error\n");
        err++;
      }
      if (sense[23] & 0x01)
      {
        DBG (2, "sense:  Test 8 Error\n");
        err++;
      }
      if (sense[23] & 0x02)
      {
        DBG (2, "sense:  Test 9 Error\n");
        err++;
      }
      if (sense[23] & 0x04)
      {
        DBG (2, "sense:  Test 10 Error\n");
        err++;
      }
      if (sense[23] & 0x08)
      {
        DBG (2, "sense:  Test 11 Error\n");
        err++;
      }
      if (sense[23] & 0x10)
      {
        DBG (2, "sense:  Test 12 Error\n");
        err++;
      }
      if (sense[23] & 0x20)
      {
        DBG (2, "sense:  Test 13 Error\n");
        err++;
      }
      if (sense[23] & 0x40)
      {
        DBG (2, "sense:  Test 14 Error\n");
        err++;
      }
      if (sense[23] & 0x80)
      {
        DBG (2, "sense:  Test 15 Error\n");
        err++;
      }
    }

  if (err)
    return SANE_STATUS_IO_ERROR;

  switch (sense[0])
    {
    case 0x70:                /* ALWAYS */
      switch (sense[2])
      {
      case 0x00:
        DBG (2, "sense:  Successful command\n");
        return SANE_STATUS_GOOD;
      case 0x02:
        DBG (2, "sense:  Not Ready, target can not be accessed\n");
        return SANE_STATUS_IO_ERROR;
      case 0x03:
        DBG (2, "sense:  Medium Error, paper jam or misfeed during ADF\n");
        return SANE_STATUS_IO_ERROR;
      case 0x04:
        DBG (2, "sense:  Hardware Error, non-recoverable\n");
        return SANE_STATUS_IO_ERROR;
      case 0x05:
        DBG (2, "sense:  Illegal Request, bad parameter in command block\n");
        return SANE_STATUS_IO_ERROR;
      case 0x06:
        DBG (2, "sense:  Unit Attention\n");
        return SANE_STATUS_GOOD;
      default:
        DBG (2, "sense:  SENSE KEY UNKNOWN (%02x)\n", sense[2]);
        return SANE_STATUS_IO_ERROR;
      }
    default:
      DBG (2, "sense: Unkown Error Code Qualifier (%02x)\n", sense[0]);
      return SANE_STATUS_IO_ERROR;
    }

  DBG (2, "sense: Should not come here!\n");
  return SANE_STATUS_IO_ERROR;
}


/* DB added a wait routine for the scanner to come ready */
static SANE_Status
wait_ready (int fd)
{
  SANE_Status status;
  int retry = 30;       /* make this tuneable? */

  DBG (7, "wait_ready()\n");
  while (retry-- > 0)
    {
      status = sanei_scsi_cmd (fd, test_unit_ready,
                         sizeof (test_unit_ready), 0, 0);
      if (status == SANE_STATUS_GOOD)
      return status;

      if (status == SANE_STATUS_DEVICE_BUSY)
      {
        sleep (1);
        continue;
      }

      /* status != GOOD && != BUSY */
      DBG (9, "wait_ready: '%s'\n", sane_strstatus (status));
      return status;
    }

  /* BUSY after n retries */
  DBG (9, "wait_ready: '%s'\n", sane_strstatus (status));
  return status;
}

/* DB added a abort routine, executed via mode select */
static SANE_Status
abort_scan (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  u_int8_t *data, comm[22];

  DBG (7, "abort_scan()\n");
  memset (comm, 0, sizeof (comm));

  comm[0] = 0x15;
  comm[1] = 0x10;
  comm[2] = 0x00;
  comm[3] = 0x00;
  comm[4] = 0x10;
  comm[5] = 0x00;

  data = comm + 6;
  data[0] = 0x00;       /* mode data length */
  data[1] = 0x00;       /* medium type */
  data[2] = 0x00;       /* device specific parameter */
  data[3] = 0x00;       /* block descriptor length */

  data = comm + 10;
  data[0] = 0x00;       /* control page parameters */
  data[1] = 0x0a;       /* parameter length */
  data[2] = 0x02 | ((s->val[OPT_TRANSPARENCY].w == SANE_TRUE) ? 0x04 : 0x00) |
    ((s->val[OPT_ADF].w == SANE_TRUE) ? 0x00 : 0x01);
  data[3] = 0x00;       /* reserved */
  data[4] = 0x00;       /* reserved */

  DBG (9, "abort: sending abort command\n");
  sanei_scsi_cmd (s->fd, comm, 6 + comm[4], 0, 0);

  DBG (9, "abort: wait for scanner to come ready...\n");
  wait_ready (s->fd);

  DBG (9, "abort: resetting abort status\n");
  data[2] = ((s->val[OPT_TRANSPARENCY].w == SANE_TRUE) ? 0x04 : 0x00) |
    ((s->val[OPT_ADF].w == SANE_TRUE) ? 0x00 : 0x01);
  sanei_scsi_cmd (s->fd, comm, 6 + comm[4], 0, 0);

  DBG (9, "abort: wait for scanner to come ready...\n");
  return wait_ready (s->fd);
}

/* DAL - mode_select: used for transparency and ADF scanning */
/* Based on abort_scan */
static SANE_Status
artec_mode_select (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  u_int8_t *data, comm[22];

  DBG (7, "artec_mode_select()\n");
  memset (comm, 0, sizeof (comm));

  comm[0] = 0x15;
  comm[1] = 0x10;
  comm[2] = 0x00;
  comm[3] = 0x00;
  comm[4] = 0x10;
  comm[5] = 0x00;

  data = comm + 6;
  data[0] = 0x00;       /* mode data length */
  data[1] = 0x00;       /* medium type */
  data[2] = 0x00;       /* device specific parameter */
  data[3] = 0x00;       /* block descriptor length */

  data = comm + 10;
  data[0] = 0x00;       /* control page parameters */
  data[1] = 0x0a;       /* parameter length */
  data[2] = ((s->val[OPT_TRANSPARENCY].w == SANE_TRUE) ? 0x04 : 0x00) |
    ((s->val[OPT_ADF].w == SANE_TRUE) ? 0x00 : 0x01);
  data[3] = 0x00;       /* reserved */
  data[4] = 0x00;       /* reserved */

  DBG (9, "artec_mode_select: mode %d\n", data[2]);
  DBG (9, "artec_mode_select: sending mode command\n");
  sanei_scsi_cmd (s->fd, comm, 6 + comm[4], 0, 0);

  DBG (9, "artec_mode_select: wait for scanner to come ready...\n");
  return wait_ready (s->fd);
}


static SANE_Status
read_data (int fd, int data_type_code, u_char * dest, size_t * len)
{
  static u_char read_6[10];

  DBG (7, "read_data()\n");

  memset (read_6, 0, sizeof (read_6));
  read_6[0] = 0x28;
  read_6[2] = data_type_code;
  read_6[6] = *len >> 16;
  read_6[7] = *len >> 8;
  read_6[8] = *len;

  return (sanei_scsi_cmd (fd, read_6, sizeof (read_6), dest, len));
}

static int
artec_get_status (int fd)
{
  u_char write_10[10];
  u_char read_12[12];
  size_t nread;

  DBG (7, "artec_get_status()\n");

  nread = 12;

  memset (write_10, 0, 10);
  write_10[0] = 0x34;
  write_10[8] = 0x0c;

  sanei_scsi_cmd (fd, write_10, 10, read_12, &nread);

  nread = (read_12[9] << 16) + (read_12[10] << 8) + read_12[11];
  DBG (9, "artec_status: %lu\n", (u_long) nread);

  return (nread);
}

static SANE_Status
artec_reverse_line (SANE_Handle handle, SANE_Byte * data)
{
  ARTEC_Scanner *s = handle;
  SANE_Byte tmp_buf[32768];   /* max dpi 1200 * 8.5 inches * 3 = 30600 */
  SANE_Byte *to, *from;
  int len;

  DBG (8, "artec_reverse_line()\n");

  len = s->params.bytes_per_line;
  memcpy (tmp_buf, data, len);

  if (s->params.format == SANE_FRAME_RGB) /* RGB format */
    {
      for (from = tmp_buf, to = data + len - 3;
         to >= data;
         to -= 3, from += 3)
      {
        *(to + 0) = *(from + 0);    /* copy the R byte */
        *(to + 1) = *(from + 1);    /* copy the G byte */
        *(to + 2) = *(from + 2);    /* copy the B byte */
      }
    }
  else if (s->params.format == SANE_FRAME_GRAY)
    {
      if (s->params.depth == 8)     /* 256 color gray-scale */
      {
        for (from = tmp_buf, to = data + len; to >= data; to--, from++)
          {
            *to = *from;
          }
      }
      else if (s->params.depth == 1)      /* line art or halftone */
      {
        for (from = tmp_buf, to = data + len; to >= data; to--, from++)
          {
            *to = (((*from & 0x01) << 7) |
                 ((*from & 0x02) << 5) |
                 ((*from & 0x04) << 3) |
                 ((*from & 0x08) << 1) |
                 ((*from & 0x10) >> 1) |
                 ((*from & 0x20) >> 3) |
                 ((*from & 0x40) >> 5) |
                 ((*from & 0x80) >> 7));
          }
      }
    }

  return (SANE_STATUS_GOOD);
}


#if 0
static SANE_Status
artec_byte_rgb_to_line_rgb (SANE_Byte * data, SANE_Int len)
{
  SANE_Byte tmp_buf[32768];   /* max dpi 1200 * 8.5 inches * 3 = 30600 */
  int count, from;

  DBG (8, "artec_byte_rgb_to_line_rgb()\n");

  /* copy the RGBRGBRGBRGBRGB... formated data to our temp buffer */
  memcpy (tmp_buf, data, len * 3);

  /* now copy back to *data in RRRRRRRGGGGGGGBBBBBBB format */
  for (count = 0, from = 0; count < len; count++, from += 3)
    {
      data[count] = tmp_buf[from];  /* R byte */
      data[count + len] = tmp_buf[from + 1];    /* G byte */
      data[count + (len * 2)] = tmp_buf[from + 2];    /* B byte */
    }

  return (SANE_STATUS_GOOD);
}
#endif

static SANE_Status
artec_line_rgb_to_byte_rgb (SANE_Byte * data, SANE_Int len)
{
  SANE_Byte tmp_buf[32768];   /* max dpi 1200 * 8.5 inches * 3 = 30600 */
  int count, to;

  DBG (8, "artec_line_rgb_to_byte_rgb()\n");

  /* copy the rgb data to our temp buffer */
  memcpy (tmp_buf, data, len * 3);

  /* now copy back to *data in RGB format */
  for (count = 0, to = 0; count < len; count++, to += 3)
    {
      data[to] = tmp_buf[count];    /* R byte */
      data[to + 1] = tmp_buf[count + len];      /* G byte */
      data[to + 2] = tmp_buf[count + (len * 2)];      /* B byte */
    }

  return (SANE_STATUS_GOOD);
}

static SANE_Byte **line_buffer = NULL;
static SANE_Byte *tmp_line_buf = NULL;
static SANE_Int r_buf_lines;
static SANE_Int g_buf_lines;

static SANE_Status
artec_buffer_line_offset (SANE_Handle handle, SANE_Int line_offset,
                    SANE_Byte * data, size_t * len)
{
  ARTEC_Scanner *s = handle;
  static SANE_Int width;
  static SANE_Int cur_line;
  SANE_Byte *tmp_buf_ptr;
  SANE_Byte *grn_ptr;
  SANE_Byte *blu_ptr;
  SANE_Byte *out_ptr;
  int count;

  DBG (8, "artec_buffer_line_offset()\n");

  if (*len == 0)
    return (SANE_STATUS_GOOD);

  if (tmp_line_buf == NULL)
    {
      width = *len / 3;
      cur_line = 0;

      DBG (9, "buffer_line_offset: offset = %d, len = %lu\n",
         line_offset, (u_long) * len);

      tmp_line_buf = malloc (*len);
      if (tmp_line_buf == NULL)
      {
        DBG (1, "couldn't allocate memory for temp line buffer\n");
        return (SANE_STATUS_NO_MEM);
      }

      r_buf_lines = line_offset * 2;
      g_buf_lines = line_offset;

      line_buffer = malloc (r_buf_lines * sizeof (SANE_Byte *));
      if (line_buffer == NULL)
      {
        DBG (1, "couldn't allocate memory for line buffer pointers\n");
        return (SANE_STATUS_NO_MEM);
      }

      for (count = 0; count < r_buf_lines; count++)
      {
        line_buffer[count] = malloc ((*len) * sizeof (SANE_Byte));
        if (line_buffer[count] == NULL)
          {
            DBG (1, "couldn't allocate memory for line buffer %d\n",
               count);
            return (SANE_STATUS_NO_MEM);
          }
      }

      DBG (9, "buffer_line_offset: r lines = %d, g lines = %d\n",
         r_buf_lines, g_buf_lines);
    }

  cur_line++;

  if (r_buf_lines > 0)
    {
      if (cur_line > r_buf_lines)
      {
        /* copy the Red and Green portions out of the buffer */
        /* if scanner returns RRRRRRRRGGGGGGGGGBBBBBBBB format it's easier */
        if (s->hw->flags & ARTEC_FLAG_RGB_CHAR_SHIFT)
          {
            /* get the red line info from r_buf_lines ago */
            memcpy (tmp_line_buf, line_buffer[0], width);

            /* get the green line info from g_buf_lines ago */
            memcpy (tmp_line_buf + width, &line_buffer[line_offset][width],
                  width);
          }
        else
          {
            /* get the red line info from r_buf_lines ago as a whole line */
            memcpy (tmp_line_buf, line_buffer[0], *len);

            /* scanner returns RGBRGBRGB format so we do a loop for green */
            grn_ptr = &line_buffer[line_offset][1];
            out_ptr = tmp_line_buf + 1;
            for (count = 0; count < width; count++)
            {
              *out_ptr = *grn_ptr;  /* copy green pixel */

              grn_ptr += 3;
              out_ptr += 3;
            }
          }
      }

      /* move all the buffered lines down (just move the ptrs for speed) */
      tmp_buf_ptr = line_buffer[0];
      for (count = 0; count < (r_buf_lines - 1); count++)
      {
        line_buffer[count] = line_buffer[count + 1];
      }
      line_buffer[r_buf_lines - 1] = tmp_buf_ptr;

      /* insert the new line data at the end of our FIFO */
      memcpy (line_buffer[r_buf_lines - 1], data, *len);

      if (cur_line > r_buf_lines)
      {
        /* copy the Red and Green portions out of the buffer */
        /* if scanner returns RRRRRRRRGGGGGGGGGBBBBBBBB format it's easier */
        if (s->hw->flags & ARTEC_FLAG_RGB_CHAR_SHIFT)
          {
            /* copy the red and green data in with the original blue */
            memcpy (data, tmp_line_buf, width * 2);
          }
        else
          {
            /* scanner returns RGBRGBRGB format so we have to do a loop */
            /* copy the blue data into our temp buffer then copy full */
            /* temp buffer overtop of input data */
            if (s->hw->flags & ARTEC_FLAG_IMAGE_REV_LR)
            {
              blu_ptr = data;
              out_ptr = tmp_line_buf;
            }
            else
            {
              blu_ptr = data + 2;
              out_ptr = tmp_line_buf + 2;
            }

            for (count = 0; count < width; count++)
            {
              *out_ptr = *blu_ptr;  /* copy blue pixel */

              blu_ptr += 3;
              out_ptr += 3;
            }

            /* now just copy tmp_line_buf back over original data */
            memcpy (data, tmp_line_buf, *len);
          }
      }
      else
      {
        /* if in the first r_buf_lines, then don't return anything */
        *len = 0;
      }
    }

  return (SANE_STATUS_GOOD);
}

static SANE_Status
artec_buffer_line_offset_free (void)
{
  int count;

  DBG (7, "artec_buffer_line_offset_free()\n");

  free (tmp_line_buf);
  tmp_line_buf = NULL;

  for (count = 0; count < r_buf_lines; count++)
    {
      free (line_buffer[count]);
    }
  free (line_buffer);
  line_buffer = NULL;

  return (SANE_STATUS_GOOD);
}


#if 0
static SANE_Status
artec_read_gamma_table (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  char write_6[4096 + 20];    /* max gamma table is 4096 + 20 for command data */
  char *data;
  char prt_buf[128];
  char tmp_buf[128];
  int i;

  DBG (7, "artec_read_gamma_table()\n");

  memset (write_6, 0, sizeof (*write_6));

  write_6[0] = 0x28;          /* read data code */

  /* FIXME: AT12 and AM12S use 0x0E for reading all channels of data */
  write_6[2] = 0x03;          /* data type code "gamma data" */

  write_6[6] = (s->gamma_length + 9) >> 16;
  write_6[7] = (s->gamma_length + 9) >> 8;
  write_6[8] = (s->gamma_length + 9);

  /* FIXME: AT12 and AM12S have one less byte so use 18 */
  if ((!strcmp (s->hw->sane.model, "AT12")) ||
      (!strcmp (s->hw->sane.model, "AM12S")))
    {
      data = write_6 + 18;
    }
  else
    {
      data = write_6 + 19;
    }

  /* FIXME: AT12 & AM12S ignore this, it's a reserved field */
  write_6[10] = 0x08;         /* bitmask, bit 3 means mono type */

  if (!s->val[OPT_CUSTOM_GAMMA].w)
    {
      write_6[11] = 1;        /* internal gamma table #1 (hope this is default) */
    }

  DBG( 9, "Gamma Table\n" );
  DBG( 9, "==================================\n" );

  prt_buf[0] = '\0';
  for (i = 0; i < s->gamma_length; i++)
    {
      if (DBG_LEVEL >= 9)
      {
        if (!(i % 16))
          {
            if ( prt_buf[0] )
            {
              strcat( prt_buf, "\n" );
              DBG( 9, "%s", prt_buf );
            }
            sprintf (prt_buf, "%02x: ", i);
          }
        sprintf (tmp_buf, "%02x ", (int) s->gamma_table[0][i]);
        strcat (prt_buf, tmp_buf );
      }

      data[i] = s->gamma_table[0][i];
    }

  if ( prt_buf[0] )
    {
      strcat( prt_buf, "\n" );
      DBG( 9, "%s", prt_buf );
    }

  if ((!strcmp (s->hw->sane.model, "AT12")) ||
      (!strcmp (s->hw->sane.model, "AM12S")))
    {
      return (sanei_scsi_cmd (s->fd, write_6, 10 + 8 + s->gamma_length, 0, 0));
    }
  else
    {
      return (sanei_scsi_cmd (s->fd, write_6, 10 + 9 + s->gamma_length, 0, 0));
    }
}
#endif

static SANE_Status
artec_send_gamma_table (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  char write_6[4096 + 20];    /* max gamma table is 4096 + 20 for command data */
  char *data;
  char prt_buf[128];
  char tmp_buf[128];
  int i;

  DBG (7, "artec_send_gamma_table()\n");

  memset (write_6, 0, sizeof (*write_6));

  write_6[0] = 0x2a;          /* send data code */

  if (s->hw->setwindow_cmd_size > 55)
    {
      /* newer scanners support sending 3 channels of gamma, or populating all */
      /* 3 channels with same data by using code 0x0e */
      write_6[2] = 0x0e;
    }
  else
    {
      /* older scanners only support 1 channel of gamma data using code 0x3 */
      write_6[2] = 0x03;
    }

  /* FIXME: AT12 & AM!2S ignore this, it's a reserved field */
  write_6[10] = 0x08;         /* bitmask, bit 3 means mono type */

  if (!s->val[OPT_CUSTOM_GAMMA].w)
    {
      write_6[6] = 9 >> 16;
      write_6[7] = 9 >> 8;
      write_6[8] = 9;
      write_6[11] = 1;        /* internal gamma table #1 (hope this is default) */

      return (sanei_scsi_cmd (s->fd, write_6, 10 + 9, 0, 0));
    }
  else
    {
      write_6[6] = (s->gamma_length + 9) >> 16;
      write_6[7] = (s->gamma_length + 9) >> 8;
      write_6[8] = (s->gamma_length + 9);

      DBG( 9, "Gamma Table\n" );
      DBG( 9, "==================================\n" );

      /* FIXME: AT12 and AM12S have one less byte so use 18 */
      if ((!strcmp (s->hw->sane.model, "AT12")) ||
        (!strcmp (s->hw->sane.model, "AM12S")))
      {
        data = write_6 + 18;
      }
      else
      {
        data = write_6 + 19;
      }

      prt_buf[0] = '\0';
      for (i = 0; i < s->gamma_length; i++)
      {
        if (DBG_LEVEL >= 9)
          {
            if (!(i % 16))
            {
              if ( prt_buf[0] )
                {
                  strcat( prt_buf, "\n" );
                  DBG( 9, "%s", prt_buf );
                }
              sprintf (prt_buf, "%02x: ", i);
            }
            sprintf (tmp_buf, "%02x ", (int) s->gamma_table[0][i]);
            strcat (prt_buf, tmp_buf );
          }

        data[i] = s->gamma_table[0][i];
      }

      data[s->gamma_length - 1] = 0;

      if ( prt_buf[0] )
      {
        strcat( prt_buf, "\n" );
        DBG( 9, "%s", prt_buf );
      }

      /* FIXME: AT12 and AM12S have one less byte so use 18 */
      if ((!strcmp (s->hw->sane.model, "AT12")) ||
        (!strcmp (s->hw->sane.model, "AM12S")))
      {
        return (sanei_scsi_cmd (s->fd, write_6, 10 + 8 + s->gamma_length, 0, 0));
      }
      else
      {
        return (sanei_scsi_cmd (s->fd, write_6, 10 + 9 + s->gamma_length, 0, 0));
      }
    }
}

static SANE_Status
artec_set_scan_window (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  char write_6[4096];
  unsigned char *data;
  int counter;
  int reversed_x;
  int max_x;

  DBG (7, "artec_set_scan_window()\n");

  /*
   * if we can, start before the desired window since we have to throw away
   * s->line_offset number of rows because of the RGB fixup.
   */
  if ((s->line_offset) &&
      (s->tl_y) &&
      (s->tl_y >= (s->line_offset * 2)))
    {
      s->tl_y -= (s->line_offset * 2);
    }

  data = (unsigned char *)write_6 + 10;

  DBG (5, "Scan window info:\n");
  DBG (5, "  X resolution: %5d (%d-%d)\n",
       s->x_resolution, ARTEC_MIN_X (s->hw), ARTEC_MAX_X (s->hw));
  DBG (5, "  Y resolution: %5d (%d-%d)\n",
       s->y_resolution, ARTEC_MIN_Y (s->hw), ARTEC_MAX_Y (s->hw));
  DBG (5, "  TL_X (pixel): %5d\n",
       s->tl_x);
  DBG (5, "  TL_Y (pixel): %5d\n",
       s->tl_y);
  DBG (5, "  Width       : %5d (%d-%d)\n",
       s->params.pixels_per_line,
       s->hw->x_range.min,
       (int) ((SANE_UNFIX (s->hw->x_range.max) / MM_PER_INCH) *
            s->x_resolution));
  DBG (5, "  Height      : %5d (%d-%d)\n",
       s->params.lines,
       s->hw->y_range.min,
       (int) ((SANE_UNFIX (s->hw->y_range.max) / MM_PER_INCH) *
            s->y_resolution));

  DBG (5, "  Image Comp. : %s\n", s->mode);
  DBG (5, "  Line Offset : %lu\n", (u_long) s->line_offset);

  memset (write_6, 0, 4096);
  write_6[0] = 0x24;
  write_6[8] = s->hw->setwindow_cmd_size; /* total size of command */

  /* beginning of set window data header */
  /* actual SCSI command data byte count */
  data[7] = s->hw->setwindow_cmd_size - 8;

  /* x resolution */
  data[10] = s->x_resolution >> 8;
  data[11] = s->x_resolution;

  /* y resolution */
  data[12] = s->y_resolution >> 8;
  data[13] = s->y_resolution;

  if ( s->hw->flags & ARTEC_FLAG_REVERSE_WINDOW )
    {
      /* top left X value */
      /* the select area is flipped across the page, so we have to do some */
      /* calculation here to get the the real starting X value */
      max_x = (int) ((SANE_UNFIX (s->hw->x_range.max) / MM_PER_INCH) *
            s->x_resolution);
      reversed_x = max_x - s->tl_x - s->params.pixels_per_line;

      data[14] = reversed_x >> 24;
      data[15] = reversed_x >> 16;
      data[16] = reversed_x >> 8;
      data[17] = reversed_x;
    }
  else
    {
      /* top left X value */
      data[14] = s->tl_x >> 24;
      data[15] = s->tl_x >> 16;
      data[16] = s->tl_x >> 8;
      data[17] = s->tl_x;
    }

  /* top left Y value */
  data[18] = s->tl_y >> 24;
  data[19] = s->tl_y >> 16;
  data[20] = s->tl_y >> 8;
  data[21] = s->tl_y;


  /* width */
  data[22] = s->params.pixels_per_line >> 24;
  data[23] = s->params.pixels_per_line >> 16;
  data[24] = s->params.pixels_per_line >> 8;
  data[25] = s->params.pixels_per_line;

  /* height */
  data[26] = (s->params.lines + (s->line_offset * 2)) >> 24;
  data[27] = (s->params.lines + (s->line_offset * 2)) >> 16;
  data[28] = (s->params.lines + (s->line_offset * 2)) >> 8;
  data[29] = (s->params.lines + (s->line_offset * 2));

  /* misc. single-byte settings */
  /* brightness */
  if (s->hw->flags & ARTEC_FLAG_OPT_BRIGHTNESS)
    data[30] = s->val[OPT_BRIGHTNESS].w;

  data[31] = s->val[OPT_THRESHOLD].w;     /* threshold */

  /* contrast */
  if (s->hw->flags & ARTEC_FLAG_OPT_CONTRAST)
    data[32] = s->val[OPT_CONTRAST].w;

  /*
   * byte 33 is mode
   * byte 37 bit 7 is "negative" setting
   */
  if (strcmp (s->mode, "Lineart") == 0)
    {
      data[33] = ARTEC_COMP_LINEART;
      data[37] = (s->val[OPT_NEGATIVE].w == SANE_TRUE) ? 0x0 : 0x80;
    }
  else if (strcmp (s->mode, "Halftone") == 0)
    {
      data[33] = ARTEC_COMP_HALFTONE;
      data[37] = (s->val[OPT_NEGATIVE].w == SANE_TRUE) ? 0x0 : 0x80;
    }
  else if (strcmp (s->mode, "Gray") == 0)
    {
      data[33] = ARTEC_COMP_GRAY;
      data[37] = (s->val[OPT_NEGATIVE].w == SANE_TRUE) ? 0x80 : 0x0;
    }
  else if (strcmp (s->mode, "Color") == 0)
    {
      data[33] = ARTEC_COMP_COLOR;
      data[37] = (s->val[OPT_NEGATIVE].w == SANE_TRUE) ? 0x80 : 0x0;
    }

  data[34] = s->params.depth; /* bits per pixel */

  if (s->hw->flags & ARTEC_FLAG_HALFTONE_PATTERN)
    {
      data[35] = artec_get_str_index (halftone_pattern_list,
                  s->val[OPT_HALFTONE_PATTERN].s);    /* halftone pattern */
    }

  /* user supplied halftone pattern not supported for now so override with */
  /* 8x8 Bayer */
  if (data[35] == 0)
    {
      data[35] = 4;
    }

  /* NOTE: AT12 doesn't support mono according to docs. */
  data[48] = artec_get_str_index (filter_type_list,
        s->val[OPT_FILTER_TYPE].s); /* filter mode */

  if (s->hw->setwindow_cmd_size > 55)
    {
      data[48] = 0x2;         /* DB filter type green for AT12,see above */

      if (s->hw->flags & ARTEC_FLAG_SC_BUFFERS_LINES)
      {
        /* FIXME: guessing at this value, use formula instead */
        data[55] = 0x00;      /* buffer full line count */
        data[56] = 0x00;      /* buffer full line count */
        data[57] = 0x00;      /* buffer full line count */
        data[58] = 0x0a;      /* buffer full line count */

        /* FIXME: guessing at this value, use formula instead */
        data[59] = 0x00;      /* access line count */
        data[60] = 0x00;      /* access line count */
        data[61] = 0x00;      /* access line count */
        data[62] = 0x0a;      /* access line count */
      }

      if (s->hw->flags & ARTEC_FLAG_SC_HANDLES_OFFSET)
      {
        /* DB : following fields : high order bit (0x80) is enable */
        /* scanner handles line offset fixup, 0 = driver handles */
        data[63] = 0x80;
      }

      if ((s->hw->flags & ARTEC_FLAG_PIXEL_AVERAGING) &&
        (s->val[OPT_PIXEL_AVG].w))
      {
        /* enable pixel average function */
        data[64] = 0x80;
      }
      else
      {
        /* disable pixel average function */
        data[64] = 0;
      }

      if ((s->hw->flags & ARTEC_FLAG_ENHANCE_LINE_EDGE) &&
        (s->val[OPT_EDGE_ENH].w))
      {
        /* enable lineart edge enhancement function */
        data[65] = 0x80;
      }
      else
      {
        /* disable lineart edge enhancement function */
        data[65] = 0;
      }

      /* data is R-G-B format, 0x80 = G-B-R format (reversed) */
      data[66] = 0;
    }

  DBG (50, "Set Window data : \n");
  for (counter = 0; counter < s->hw->setwindow_cmd_size; counter++)
    {
      DBG (50, "  byte %2d = %02x \n", counter, data[counter] & 0xff);  /* DB */
    }
  DBG (50, "\n");

  /* set the scan window */
  return (sanei_scsi_cmd (s->fd, write_6, 10 +
                    s->hw->setwindow_cmd_size, 0, 0));
}

static SANE_Status
artec_start_scan (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  char write_7[7];

  DBG (7, "artec_start_scan()\n");

  /* setup cmd to start scanning */
  memset (write_7, 0, 7);
  write_7[0] = 0x1b;          /* code to start scan */

  /* FIXME: need to make this a flag */
  if (!strcmp (s->hw->sane.model, "AM12S"))
    {
      /* start the scan */
      return (sanei_scsi_cmd (s->fd, write_7, 6, 0, 0));
    }
  else
    {
      write_7[4] = 0x01;      /* need to send 1 data byte */

      /* start the scan */
      return (sanei_scsi_cmd (s->fd, write_7, 7, 0, 0));
    }
}

static SANE_Status
artec_software_rgb_calibrate (SANE_Handle handle, SANE_Byte * buf, int lines)
{
  ARTEC_Scanner *s = handle;
  int line, i, loop, offset;

  DBG (7, "artec_software_rgb_calibrate()\n");

  for (line = 0; line < lines; line++)
    {
      i = 0;
      offset = 0;

      if (s->x_resolution == 200)
      {
        /* skip ever 3rd byte, -= causes us to go down in count */
        if ((s->tl_x % 3) == 0)
          offset -= 1;
      }
      else
      {
        /* round down to the previous pixel */
        offset += ((s->tl_x / (300 / s->x_resolution)) *
                 (300 / s->x_resolution));
      }

      for (loop = 0; loop < s->params.pixels_per_line; loop++)
      {
        if ((DBG_LEVEL == 100) &&
            (loop < 100))
          {
            DBG (100, "  %2d-%4d R (%4d,%4d): %d * %5.2f = %d\n",
                   line, loop, i, offset, buf[i],
                   s->soft_calibrate_data[ARTEC_SOFT_CALIB_RED][offset],
                   (int) (buf[i] *
                 s->soft_calibrate_data[ARTEC_SOFT_CALIB_RED][offset]));
          }
        buf[i] = buf[i] *
          s->soft_calibrate_data[ARTEC_SOFT_CALIB_RED][offset];
        i++;

        if ((DBG_LEVEL == 100) &&
            (loop < 100))
          {
            DBG (100, "          G (%4d,%4d): %d * %5.2f = %d\n",
                   i, offset, buf[i],
                 s->soft_calibrate_data[ARTEC_SOFT_CALIB_GREEN][offset],
                   (int) (buf[i] *
               s->soft_calibrate_data[ARTEC_SOFT_CALIB_GREEN][offset]));
          }
        buf[i] = buf[i] *
          s->soft_calibrate_data[ARTEC_SOFT_CALIB_GREEN][offset];
        i++;

        if ((DBG_LEVEL == 100) &&
            (loop < 100))
          {
            DBG (100, "          B (%4d,%4d): %d * %5.2f = %d\n",
                   i, offset, buf[i],
                   s->soft_calibrate_data[ARTEC_SOFT_CALIB_BLUE][offset],
                   (int) (buf[i] *
                s->soft_calibrate_data[ARTEC_SOFT_CALIB_BLUE][offset]));
          }
        buf[i] = buf[i] *
          s->soft_calibrate_data[ARTEC_SOFT_CALIB_BLUE][offset];
        i++;

        if (s->x_resolution == 200)
          {
            offset += 1;

            /* skip every 3rd byte */
            if (((offset + 1) % 3) == 0)
            offset += 1;
          }
        else
          {
            offset += (300 / s->x_resolution);
          }
      }
    }

  return (SANE_STATUS_GOOD);
}

static SANE_Status
artec_calibrate_shading (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  SANE_Status status;         /* DB added */
  u_char buf[76800];          /* should be big enough */
  size_t len;
  SANE_Word save_x_resolution;
  SANE_Word save_pixels_per_line;
  int i;

  DBG (7, "artec_calibrate_shading()\n");

  if (s->hw->flags & ARTEC_FLAG_CALIBRATE_RGB)
    {
      /* this method scans in 4 lines each of Red, Green, and Blue */
      /* after reading line of shading data, generate data for software */
      /* calibration so we have it if user requests */
      len = 4 * 2592;         /* 4 lines of data, 2592 pixels wide */

      if ( DBG_LEVEL == 100 )
      DBG (100, "RED Software Calibration data\n");

      read_data (s->fd, ARTEC_DATA_RED_SHADING, buf, &len);
      for (i = 0; i < 2592; i++)
      {
        s->soft_calibrate_data[ARTEC_SOFT_CALIB_RED][i] =
          255.0 / ((buf[i] + buf[i + 2592] + buf[i + 5184] + buf[i + 7776]) / 4);
        if (DBG_LEVEL == 100)
          {
            DBG (100,
             "   %4d: 255.0 / (( %3d + %3d + %3d + %3d ) / 4 ) = %5.2f\n",
                 i, buf[i], buf[i + 2592], buf[i + 5184], buf[i + 7776],
                   s->soft_calibrate_data[ARTEC_SOFT_CALIB_RED][i]);
          }
      }

      if (DBG_LEVEL == 100)
      {
        DBG (100, "GREEN Software Calibration data\n");
      }

      read_data (s->fd, ARTEC_DATA_GREEN_SHADING, buf, &len);
      for (i = 0; i < 2592; i++)
      {
        s->soft_calibrate_data[ARTEC_SOFT_CALIB_GREEN][i] =
          255.0 / ((buf[i] + buf[i + 2592] + buf[i + 5184] + buf[i + 7776]) / 4);
        if (DBG_LEVEL == 100)
          {
            DBG (100,
             "   %4d: 255.0 / (( %3d + %3d + %3d + %3d ) / 4 ) = %5.2f\n",
                 i, buf[i], buf[i + 2592], buf[i + 5184], buf[i + 7776],
                   s->soft_calibrate_data[ARTEC_SOFT_CALIB_GREEN][i]);
          }
      }

      if (DBG_LEVEL == 100)
      {
        DBG (100, "BLUE Software Calibration data\n");
      }

      read_data (s->fd, ARTEC_DATA_BLUE_SHADING, buf, &len);
      for (i = 0; i < 2592; i++)
      {
        s->soft_calibrate_data[ARTEC_SOFT_CALIB_BLUE][i] =
          255.0 / ((buf[i] + buf[i + 2592] + buf[i + 5184] + buf[i + 7776]) / 4);
        if (DBG_LEVEL == 100)
          {
            DBG (100,
             "   %4d: 255.0 / (( %3d + %3d + %3d + %3d ) / 4 ) = %5.2f\n",
                 i, buf[i], buf[i + 2592], buf[i + 5184], buf[i + 7776],
                   s->soft_calibrate_data[ARTEC_SOFT_CALIB_BLUE][i]);
          }
      }
    }
  else if (s->hw->flags & ARTEC_FLAG_CALIBRATE_DARK_WHITE)
    {
      /* this method scans black, then white data */
      len = 3 * 5100;         /* 1 line of data, 5100 pixels wide, RGB data */
      read_data (s->fd, ARTEC_DATA_DARK_SHADING, buf, &len);
      save_x_resolution = s->x_resolution;
      s->x_resolution = 600;
      save_pixels_per_line = s->params.pixels_per_line;
      s->params.pixels_per_line = ARTEC_MAX_X (s->hw);
      s->params.pixels_per_line = 600 * 8.5;    /* ?this? or ?above line? */
      /* DB added wait_ready */
      status = wait_ready (s->fd);
      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "wait for scanner ready failed: %s\n", sane_strstatus (status));
        return status;
      }
      /* next line should use ARTEC_DATA_WHITE_SHADING_TRANS if using ADF */
      read_data (s->fd, ARTEC_DATA_WHITE_SHADING_OPT, buf, &len);
      s->x_resolution = save_x_resolution;
      s->params.pixels_per_line = save_pixels_per_line;
    }

  return (SANE_STATUS_GOOD);
}


static SANE_Status
end_scan (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  /* DB
     u_int8_t write_6[6] =
     {0x1B, 0, 0, 0, 0, 0};
   */

  DBG (7, "end_scan()\n");

  s->scanning = SANE_FALSE;

/*  if (s->this_pass == 3) */
  s->this_pass = 0;

  if ((s->hw->flags & ARTEC_FLAG_RGB_LINE_OFFSET) &&
      (tmp_line_buf != NULL))
    {
      artec_buffer_line_offset_free ();
    }

  /* DB
     return (sanei_scsi_cmd (s->fd, write_6, 6, 0, 0));
   */
  return abort_scan (s);
}


static SANE_Status
artec_get_cap_data (ARTEC_Device * dev, int fd)
{
  int cap_model, loop;
  SANE_Status status;
  u_char cap_buf[256];        /* buffer for cap data */

  DBG (7, "artec_get_cap_data()\n");

  /* DB always use the hard-coded capability info first 
   * if we get cap data from the scanner, we override */
  cap_model = -1;
  for (loop = 0; loop < NELEMS (cap_data); loop++)
    {
      if (strcmp (cap_data[loop].model, dev->sane.model) == 0)
      {
        cap_model = loop;
      }
    }

  if (cap_model == -1)
    {
      DBG (1, "unable to identify Artec model '%s', check artec.c\n",
         dev->sane.model);
      return (SANE_STATUS_UNSUPPORTED);
    }

  dev->x_range.min = 0;
  dev->x_range.max = SANE_FIX (cap_data[cap_model].width) * MM_PER_INCH;
  dev->x_range.quant = 1;

  dev->width = cap_data[cap_model].width;

  dev->y_range.min = 0;
  dev->y_range.max = SANE_FIX (cap_data[cap_model].height) * MM_PER_INCH;
  dev->y_range.quant = 1;

  dev->height = cap_data[cap_model].height;

  status = artec_str_list_to_word_list (&dev->horz_resolution_list,
                           cap_data[cap_model].horz_resolution_str);

  status = artec_str_list_to_word_list (&dev->vert_resolution_list,
                           cap_data[cap_model].vert_resolution_str);

  dev->contrast_range.min = 0;
  dev->contrast_range.max = 255;
  dev->contrast_range.quant = 1;

  dev->brightness_range.min = 0;
  dev->brightness_range.max = 255;
  dev->brightness_range.quant = 1;

  dev->threshold_range.min = 0;
  dev->threshold_range.max = 255;
  dev->threshold_range.quant = 1;

  dev->sane.type = cap_data[cap_model].type;

  dev->max_read_size = cap_data[cap_model].max_read_size;

  dev->flags = cap_data[cap_model].flags;

  switch (cap_data[cap_model].adc_bits)
    {
    case 8:
      dev->gamma_length = 256;
      break;

    case 10:
      dev->gamma_length = 1024;
      break;

    case 12:
      dev->gamma_length = 4096;
      break;
    }

  dev->setwindow_cmd_size = cap_data[cap_model].setwindow_cmd_size;

  if (dev->support_cap_data_retrieve)     /* DB */
    {
      /* DB added reading capability data from scanner */
      char info[80];          /* for printing debugging info */
      size_t len = sizeof (cap_buf);

      /* read the capability data from the scanner */
      DBG (9, "reading capability data from scanner...\n");

      wait_ready (fd);

      read_data (fd, ARTEC_DATA_CAPABILITY_DATA, cap_buf, &len);

      DBG (50, "scanner capability data : \n");
      strncpy (info, (const char *) &cap_buf[0], 8);
      info[8] = '\0';
      DBG (50, "  Vendor                    : %s\n", info);
      strncpy (info, (const char *) &cap_buf[8], 16);
      info[16] = '\0';
      DBG (50, "  Device Name               : %s\n", info);
      strncpy (info, (const char *) &cap_buf[24], 4);
      info[4] = '\0';
      DBG (50, "  Version Number            : %s\n", info);
      sprintf (info, "%d ", cap_buf[29]);
      DBG (50, "  CCD Type                  : %s\n", info);
      sprintf (info, "%d ", cap_buf[30]);
      DBG (50, "  AD Converter Type         : %s\n", info);
      sprintf (info, "%d ", (cap_buf[31] << 8) | cap_buf[32]);
      DBG (50, "  Buffer size               : %s\n", info);
      sprintf (info, "%d ", cap_buf[33]);
      DBG (50, "  Channels of RGB Gamma     : %s\n", info);
      sprintf (info, "%d ", (cap_buf[34] << 8) | cap_buf[35]);
      DBG (50, "  Opt. res. of R channel    : %s\n", info);
      sprintf (info, "%d ", (cap_buf[36] << 8) | cap_buf[37]);
      DBG (50, "  Opt. res. of G channel    : %s\n", info);
      sprintf (info, "%d ", (cap_buf[38] << 8) | cap_buf[39]);
      DBG (50, "  Opt. res. of B channel    : %s\n", info);
      sprintf (info, "%d ", (cap_buf[40] << 8) | cap_buf[41]);
      DBG (50, "  Min. Hor. Resolution      : %s\n", info);
      sprintf (info, "%d ", (cap_buf[42] << 8) | cap_buf[43]);
      DBG (50, "  Max. Vert. Resolution     : %s\n", info);
      sprintf (info, "%d ", (cap_buf[44] << 8) | cap_buf[45]);
      DBG (50, "  Min. Vert. Resolution     : %s\n", info);
      sprintf (info, "%s ", cap_buf[46] == 0x80 ? "yes" : "no");
      DBG (50, "  Chunky Data Format        : %s\n", info);
      sprintf (info, "%s ", cap_buf[47] == 0x80 ? "yes" : "no");
      DBG (50, "  RGB Data Format           : %s\n", info);
      sprintf (info, "%s ", cap_buf[48] == 0x80 ? "yes" : "no");
      DBG (50, "  BGR Data Format           : %s\n", info);
      sprintf (info, "%d ", cap_buf[49]);
      DBG (50, "  Line Offset               : %s\n", info);
      sprintf (info, "%s ", cap_buf[50] == 0x80 ? "yes" : "no");
      DBG (50, "  Channel Valid Sequence    : %s\n", info);
      sprintf (info, "%s ", cap_buf[51] == 0x80 ? "yes" : "no");
      DBG (50, "  True Gray                 : %s\n", info);
      sprintf (info, "%s ", cap_buf[52] == 0x80 ? "yes" : "no");
      DBG (50, "  Force Host Not Do Shading : %s\n", info);
      sprintf (info, "%s ", cap_buf[53] == 0x00 ? "AT006" : "AT010");
      DBG (50, "  ASIC                      : %s\n", info);
      sprintf (info, "%s ", cap_buf[54] == 0x82 ? "SCSI2" :
             cap_buf[54] == 0x81 ? "SCSI1" : "Parallel");
      DBG (50, "  Interface                 : %s\n", info);
      sprintf (info, "%d ", (cap_buf[55] << 8) | cap_buf[56]);
      DBG (50, "  Phys. Area Width          : %s\n", info);
      sprintf (info, "%d ", (cap_buf[57] << 8) | cap_buf[58]);
      DBG (50, "  Phys. Area Length         : %s\n", info);

      /* fill in the information we've got from the scanner */

      dev->width = ((float) ((cap_buf[55] << 8) | cap_buf[56])) / 1000;
      dev->height = ((float) ((cap_buf[57] << 8) | cap_buf[58])) / 1000;

      /* DB ----- */
    }

  DBG (9, "Scanner capability info.\n");
  DBG (9, "  Vendor      : %s\n", dev->sane.vendor);
  DBG (9, "  Model       : %s\n", dev->sane.model);
  DBG (9, "  Type        : %s\n", dev->sane.type);
  DBG (5, "  Width       : %.2f inches\n", dev->width);
  DBG (9, "  Height      : %.2f inches\n", dev->height);
  DBG (9, "  X Range(mm) : %d-%d\n",
       dev->x_range.min,
       (int) (SANE_UNFIX (dev->x_range.max)));
  DBG (9, "  Y Range(mm) : %d-%d\n",
       dev->y_range.min,
       (int) (SANE_UNFIX (dev->y_range.max)));

  DBG (9, "  Horz. DPI   : %d-%d\n", ARTEC_MIN_X (dev), ARTEC_MAX_X (dev));
  DBG (9, "  Vert. DPI   : %d-%d\n", ARTEC_MIN_Y (dev), ARTEC_MAX_Y (dev));
  DBG (9, "  Contrast    : %d-%d\n",
       dev->contrast_range.min, dev->contrast_range.max);
  DBG (9, "  REQ Sh. Cal.: %d\n",
       dev->flags & ARTEC_FLAG_CALIBRATE ? 1 : 0);
  DBG (9, "  REQ Ln. Offs: %d\n",
       dev->flags & ARTEC_FLAG_RGB_LINE_OFFSET ? 1 : 0);
  DBG (9, "  REQ Ch. Shft: %d\n",
       dev->flags & ARTEC_FLAG_RGB_CHAR_SHIFT ? 1 : 0);
  DBG (9, "  SetWind Size: %d\n",
       dev->setwindow_cmd_size);
  DBG (9, "  Calib Method: %s\n",
       dev->flags & ARTEC_FLAG_CALIBRATE_RGB ? "RGB" :
       dev->flags & ARTEC_FLAG_CALIBRATE_DARK_WHITE ? "white/black" : "N/A");

  return (SANE_STATUS_GOOD);
}

static SANE_Status
dump_inquiry (unsigned char *result)
{
  int i;
  int j;
  char prt_buf[129] = "";
  char tmp_buf[129];

  DBG (4, "dump_inquiry()\n");

  DBG (4, " === SANE/Artec backend v%d.%d.%d ===\n",
         ARTEC_MAJOR, ARTEC_MINOR, ARTEC_SUB);
  DBG (4, " ===== Scanner Inquiry Block =====\n");
  for (i = 0; i < 96; i += 16)
    {
      sprintf (prt_buf, "0x%02x: ", i);
      for (j = 0; j < 16; j++)
      {
        sprintf (tmp_buf, "%02x ", (int) result[i + j]);
        strcat( prt_buf, tmp_buf );
      }
      strcat( prt_buf, "  ");
      for (j = 0; j < 16; j++)
      {
        sprintf (tmp_buf, "%c",
               isprint (result[i + j]) ? result[i + j] : '.');
        strcat( prt_buf, tmp_buf );
      }
      strcat( prt_buf, "\n" );
      DBG(4, "%s", prt_buf );
    }

  return (SANE_STATUS_GOOD);
}

static SANE_Status
attach (const char *devname, ARTEC_Device ** devp)
{
  char result[INQ_LEN];
  char product_revision[5];
  char temp_result[33];
  char *str, *t;
  int fd;
  SANE_Status status;
  ARTEC_Device *dev;
  size_t size;

  DBG (7, "attach()\n");

  for (dev = first_dev; dev; dev = dev->next)
    {
      if (strcmp (dev->sane.name, devname) == 0)
      {
        if (devp)
          *devp = dev;
        return (SANE_STATUS_GOOD);
      }
    }

  DBG (6, "attach: opening %s\n", devname);

  status = sanei_scsi_open (devname, &fd, sense_handler, NULL);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: open failed (%s)\n", sane_strstatus (status));
      return (SANE_STATUS_INVAL);
    }

  DBG (6, "attach: sending INQUIRY\n");
  size = sizeof (result);
  status = sanei_scsi_cmd (fd, inquiry, sizeof (inquiry), result, &size);
  if (status != SANE_STATUS_GOOD || size < 16)
    {
      DBG (1, "attach: inquiry failed (%s)\n", sane_strstatus (status));
      sanei_scsi_close (fd);
      return (status);
    }

  /*
   * Check to see if this device is a scanner.
   */
  if (result[0] != 0x6)
    {
      DBG (1, "attach: device doesn't look like a scanner at all.\n");
      sanei_scsi_close (fd);
      return (SANE_STATUS_INVAL);
    }

  /*
   * The BlackWidow BW4800SP is actually a rebadged AT3, with the vendor
   * string set to 8 spaces and the product to "Flatbed Scanner ".  So,
   * if we have one of these, we'll make it look like an AT3.
   *
   * For now, to be on the safe side, we'll also check the version number
   * since BlackWidow seems to have left that intact as "1.90".
   *
   * Check that result[36] == 0x00 so we don't mistake a microtek scanner.
   */
  if ((result[36] == 0x00) &&
      (strncmp (result + 32, "1.90", 4) == 0) &&
      (strncmp (result + 8, "        ", 8) == 0) &&
      (strncmp (result + 16, "Flatbed Scanner ", 16) == 0))
    {
      DBG (6, "Found BlackWidow BW4800SP scanner, setting up like AT3\n");

      /* setup the vendor and product to mimic the Artec/Ultima AT3 */
      strncpy (result + 8, "ULTIMA", 6);
      strncpy (result + 16, "AT3             ", 16);
    }

  /*
   * The Plustek 19200S is actually a rebadged AM12S, with the vendor string
   * set to 8 spaces.
   */
  if ((strncmp (result + 8, "        ", 8) == 0) &&
      (strncmp (result + 16, "SCAN19200       ", 16) == 0))
    {
      DBG (6, "Found Plustek 19200S scanner, setting up like AM12S\n");

      /* setup the vendor and product to mimic the Artec/Ultima AM12S */
      strncpy (result + 8, "ULTIMA", 6);
      strncpy (result + 16, "AM12S           ", 16);
    }

  /*
   * Check to see if they have forced a vendor and/or model string and
   * if so, fudge the inquiry results with that info.  We do this right
   * before we check the inquiry results, otherwise we might not be forcing
   * anything.
   */
  if (artec_vendor[0] != 0x0)
    {
      /*
       * 1) copy the vendor string to our temp variable
       * 2) append 8 spaces to make sure we have at least 8 characters
       * 3) copy our fudged vendor string into the inquiry result.
       */
      strcpy (temp_result, artec_vendor);
      strcat (temp_result, "        ");
      strncpy (result + 8, temp_result, 8);
    }

  if (artec_model[0] != 0x0)
    {
      /*
       * 1) copy the model string to our temp variable
       * 2) append 16 spaces to make sure we have at least 16 characters
       * 3) copy our fudged model string into the inquiry result.
       */
      strcpy (temp_result, artec_model);
      strcat (temp_result, "                ");
      strncpy (result + 16, temp_result, 16);
    }

  /* are we really dealing with a scanner by ULTIMA/ARTEC? */
  if ((strncmp (result + 8, "ULTIMA", 6) != 0) &&
      (strncmp (result + 8, "ARTEC", 5) != 0))
    {
      DBG (1, "attach: device doesn't look like a Artec/ULTIMA scanner\n");

      strncpy (temp_result, result + 8, 8);
      temp_result[8] = 0x0;
      DBG (1, "attach: FOUND vendor = '%s'\n", temp_result);
      strncpy (temp_result, result + 16, 16);
      temp_result[16] = 0x0;
      DBG (1, "attach: FOUND model  = '%s'\n", temp_result);

      sanei_scsi_close (fd);
      return (SANE_STATUS_INVAL);
    }

  /* turn this wait OFF for now since it appears to cause problems with */
  /* AT12 models */
  /* turned off by creating an "if" that can never be true */
  if ( 1 == 2 ) {
  DBG (6, "attach: wait for scanner to come ready\n");
  status = wait_ready (fd);

  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: test unit ready failed (%s)\n",
         sane_strstatus (status));
      sanei_scsi_close (fd);
      return (status);
    }
  /* This is the end of the "if" that can never be true that in effect */
  /* comments out this wait_ready() call */
  }
  /* end of "if( 1 == 2 )" */

  dev = malloc (sizeof (*dev));
  if (!dev)
    return (SANE_STATUS_NO_MEM);

  memset (dev, 0, sizeof (*dev));

  if (DBG_LEVEL >= 4)
    dump_inquiry ((unsigned char *) result);

  dev->sane.name = strdup (devname);

  /* get the model info */
  str = malloc (17);
  memcpy (str, result + 16, 16);
  str[16] = ' ';
  t = str + 16;
  while ((*t == ' ') && (t > str))
    {
      *t = '\0';
      t--;
    }
  dev->sane.model = str;

  /* for some reason, the firmware revision is in the model info string on */
  /* the A6000C PLUS scanners instead of in it's proper place */
  if (strstr (str, "A6000C PLUS") == str)
    {
      str[11] = '\0';
      strncpy (product_revision, str + 12, 4);
    }
  else if (strstr (str, "AT3") == str)
    {
      str[3] = '\0';
      strncpy (product_revision, str + 8, 4);
    }
  else
    {
      /* get the product revision from it's normal place */
      strncpy (product_revision, result + 32, 4);
    }
  product_revision[4] = ' ';
  t = strchr (product_revision, ' ');
  if (t)
    *t = '\0';
  else
    t = "unknown revision";

  /* get the vendor info */
  str = malloc (9);
  memcpy (str, result + 8, 8);
  str[8] = ' ';
  t = strchr (str, ' ');
  *t = '\0';
  dev->sane.vendor = str;

  DBG (5, "scanner vendor: '%s', model: '%s', revision: '%s'\n",
       dev->sane.vendor, dev->sane.model, product_revision);

  /* Artec docs say if bytes 36-43 = "ULTIMA  ", then supports read cap. data */
  if (strncmp (result + 36, "ULTIMA  ", 8) == 0)
    {
      DBG (5, "scanner supports read capability data function\n");
      dev->support_cap_data_retrieve = SANE_TRUE;
    }
  else
    {
      DBG (5, "scanner does NOT support read capability data function\n");
      dev->support_cap_data_retrieve = SANE_FALSE;
    }

  DBG (6, "attach: getting scanner capability data\n");
  status = artec_get_cap_data (dev, fd);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: artec_get_cap_data failed (%s)\n",
         sane_strstatus (status));
      sanei_scsi_close (fd);
      return (status);
    }

  sanei_scsi_close (fd);

  ++num_devices;
  dev->next = first_dev;
  first_dev = dev;

  if (devp)
    *devp = dev;

  return (SANE_STATUS_GOOD);
}

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

  DBG (7, "init_options()\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].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;

  /* scan mode */
  s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
  s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
  s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
  s->opt[OPT_MODE].type = SANE_TYPE_STRING;
  s->opt[OPT_MODE].size = max_string_size (mode_list);
  s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
  s->opt[OPT_MODE].constraint.string_list = mode_list;
  s->val[OPT_MODE].s = strdup (mode_list[3]);

  /* horizontal resolution */
  s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
  s->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
  s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
  s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
  s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
  s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
  s->opt[OPT_X_RESOLUTION].constraint.word_list = s->hw->horz_resolution_list;
  s->val[OPT_X_RESOLUTION].w = 100;

  /* vertical resolution */
  s->opt[OPT_Y_RESOLUTION].name = SANE_NAME_SCAN_Y_RESOLUTION;
  s->opt[OPT_Y_RESOLUTION].title = SANE_TITLE_SCAN_Y_RESOLUTION;
  s->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_Y_RESOLUTION;
  s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
  s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
  s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
  s->opt[OPT_Y_RESOLUTION].constraint.word_list = s->hw->vert_resolution_list;
  s->opt[OPT_Y_RESOLUTION].cap |= SANE_CAP_INACTIVE;
  s->val[OPT_Y_RESOLUTION].w = 100;

  /* bind resolution */
  s->opt[OPT_RESOLUTION_BIND].name = SANE_NAME_RESOLUTION_BIND;
  s->opt[OPT_RESOLUTION_BIND].title = SANE_TITLE_RESOLUTION_BIND;
  s->opt[OPT_RESOLUTION_BIND].desc = SANE_DESC_RESOLUTION_BIND;
  s->opt[OPT_RESOLUTION_BIND].type = SANE_TYPE_BOOL;
  s->val[OPT_RESOLUTION_BIND].w = SANE_TRUE;

  if (!(s->hw->flags & ARTEC_FLAG_SEPARATE_RES))
    s->opt[OPT_RESOLUTION_BIND].cap |= SANE_CAP_INACTIVE;

  /* Preview Mode */
  s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
  s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
  s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
  s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
  s->opt[OPT_PREVIEW].unit = SANE_UNIT_NONE;
  s->opt[OPT_PREVIEW].size = sizeof (SANE_Word);
  s->val[OPT_PREVIEW].w = SANE_FALSE;

  /* Grayscale Preview Mode */
  s->opt[OPT_GRAY_PREVIEW].name = SANE_NAME_GRAY_PREVIEW;
  s->opt[OPT_GRAY_PREVIEW].title = SANE_TITLE_GRAY_PREVIEW;
  s->opt[OPT_GRAY_PREVIEW].desc = SANE_DESC_GRAY_PREVIEW;
  s->opt[OPT_GRAY_PREVIEW].type = SANE_TYPE_BOOL;
  s->opt[OPT_GRAY_PREVIEW].unit = SANE_UNIT_NONE;
  s->opt[OPT_GRAY_PREVIEW].size = sizeof (SANE_Word);
  s->val[OPT_GRAY_PREVIEW].w = SANE_FALSE;

  /* negative */
  s->opt[OPT_NEGATIVE].name = SANE_NAME_NEGATIVE;
  s->opt[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE;
  s->opt[OPT_NEGATIVE].desc = "Negative Image";
  s->opt[OPT_NEGATIVE].type = SANE_TYPE_BOOL;
  s->val[OPT_NEGATIVE].w = SANE_FALSE;

  if (!(s->hw->flags & ARTEC_FLAG_MBPP_NEGATIVE))
    {
      s->opt[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE;
    }

  /* "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_FIXED;
  s->opt[OPT_TL_X].unit = SANE_UNIT_MM;

  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_TL_X].constraint.range = &s->hw->x_range;
  s->val[OPT_TL_X].w = s->hw->x_range.min;

  /* 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_FIXED;
  s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;

  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_TL_Y].constraint.range = &s->hw->y_range;
  s->val[OPT_TL_Y].w = s->hw->y_range.min;

  /* 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_FIXED;
  s->opt[OPT_BR_X].unit = SANE_UNIT_MM;

  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_BR_X].constraint.range = &s->hw->x_range;
  s->val[OPT_BR_X].w = s->hw->x_range.max;

  /* 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_FIXED;
  s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;

  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_BR_Y].constraint.range = &s->hw->y_range;
  s->val[OPT_BR_Y].w = s->hw->y_range.max;

  /* 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 = SANE_CAP_ADVANCED;
  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;

  /* filter mode */
  s->opt[OPT_FILTER_TYPE].name = "filter-type";
  s->opt[OPT_FILTER_TYPE].title = "Filter Type";
  s->opt[OPT_FILTER_TYPE].desc = "Filter Type for mono scans";
  s->opt[OPT_FILTER_TYPE].type = SANE_TYPE_STRING;
  s->opt[OPT_FILTER_TYPE].size = max_string_size (filter_type_list);
  s->opt[OPT_FILTER_TYPE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
  s->opt[OPT_FILTER_TYPE].constraint.string_list = filter_type_list;
  s->val[OPT_FILTER_TYPE].s = strdup (filter_type_list[0]);
  s->opt[OPT_FILTER_TYPE].cap |= SANE_CAP_INACTIVE;

  /* 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].unit = SANE_UNIT_NONE;
  s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_CONTRAST].constraint.range = &s->hw->brightness_range;
  s->val[OPT_CONTRAST].w = 0x80;

  if (!(s->hw->flags & ARTEC_FLAG_OPT_CONTRAST))
    {
      s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
    }

  /* 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;
  s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
  s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
  s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_BRIGHTNESS].constraint.range = &s->hw->contrast_range;
  s->val[OPT_BRIGHTNESS].w = 0x80;

  if (!(s->hw->flags & ARTEC_FLAG_OPT_BRIGHTNESS))
    {
      s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
    }

  /* threshold */
  s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
  s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
  s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
  s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
  s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
  s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_THRESHOLD].constraint.range = &s->hw->threshold_range;
  s->val[OPT_THRESHOLD].w = 0x80;
  s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;

  /* halftone pattern */
  s->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
  s->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
  s->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
  s->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
  s->opt[OPT_HALFTONE_PATTERN].size = max_string_size (halftone_pattern_list);
  s->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST;
  s->opt[OPT_HALFTONE_PATTERN].constraint.string_list = halftone_pattern_list;
  s->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[1]);
  s->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;

  /* pixel averaging */
  s->opt[OPT_PIXEL_AVG].name = "pixel-avg";
  s->opt[OPT_PIXEL_AVG].title = "Pixel Averaging";
  s->opt[OPT_PIXEL_AVG].desc = "Enable HardWare Pixel Averaging function";
  s->opt[OPT_PIXEL_AVG].type = SANE_TYPE_BOOL;
  s->val[OPT_PIXEL_AVG].w = SANE_FALSE;

  if (!(s->hw->flags & ARTEC_FLAG_PIXEL_AVERAGING))
    {
      s->opt[OPT_PIXEL_AVG].cap |= SANE_CAP_INACTIVE;
    }

  /* lineart line edge enhancement */
  s->opt[OPT_EDGE_ENH].name = "edge-enh";
  s->opt[OPT_EDGE_ENH].title = "Line Edge Enhancement";
  s->opt[OPT_EDGE_ENH].desc = "Enable HardWare Lineart Line Edge Enhancement";
  s->opt[OPT_EDGE_ENH].type = SANE_TYPE_BOOL;
  s->val[OPT_EDGE_ENH].w = SANE_FALSE;
  s->opt[OPT_EDGE_ENH].cap |= SANE_CAP_INACTIVE;

  /* custom-gamma table */
  s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
  s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
  s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
  s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
  s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;

  /* grayscale gamma vector */
  s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
  s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
  s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
  s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
  s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
  s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
  s->val[OPT_GAMMA_VECTOR].wa = &(s->gamma_table[0][0]);
  s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
  s->opt[OPT_GAMMA_VECTOR].size = s->gamma_length * sizeof (SANE_Word);

  /* red gamma vector */
  s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
  s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
  s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
  s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
  s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
  s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
  s->val[OPT_GAMMA_VECTOR_R].wa = &(s->gamma_table[1][0]);
  s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &(s->gamma_range);
  s->opt[OPT_GAMMA_VECTOR_R].size = s->gamma_length * sizeof (SANE_Word);

  /* green gamma vector */
  s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
  s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
  s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
  s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
  s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
  s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
  s->val[OPT_GAMMA_VECTOR_G].wa = &(s->gamma_table[2][0]);
  s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &(s->gamma_range);
  s->opt[OPT_GAMMA_VECTOR_G].size = s->gamma_length * sizeof (SANE_Word);

  /* blue gamma vector */
  s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
  s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
  s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
  s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
  s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
  s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
  s->val[OPT_GAMMA_VECTOR_B].wa = &(s->gamma_table[3][0]);
  s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &(s->gamma_range);
  s->opt[OPT_GAMMA_VECTOR_B].size = s->gamma_length * sizeof (SANE_Word);

  if (s->hw->flags & ARTEC_FLAG_GAMMA_SINGLE)
    {
      s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
      s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
      s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
    }

  if (!(s->hw->flags & ARTEC_FLAG_GAMMA))
    {
      s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
      s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
      s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
      s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
      s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
    }

  /* transparency */
  s->opt[OPT_TRANSPARENCY].name = "transparency";
  s->opt[OPT_TRANSPARENCY].title = "Transparency";
  s->opt[OPT_TRANSPARENCY].desc = "Use transparency adaptor";
  s->opt[OPT_TRANSPARENCY].type = SANE_TYPE_BOOL;
  s->val[OPT_TRANSPARENCY].w = SANE_FALSE;

  /* ADF */
  s->opt[OPT_ADF].name = "adf";
  s->opt[OPT_ADF].title = "ADF";
  s->opt[OPT_ADF].desc = "Use ADF";
  s->opt[OPT_ADF].type = SANE_TYPE_BOOL;
  s->val[OPT_ADF].w = SANE_FALSE;

  /* Calibration group: */
  s->opt[OPT_CALIBRATION_GROUP].title = "Calibration";
  s->opt[OPT_CALIBRATION_GROUP].desc = "";
  s->opt[OPT_CALIBRATION_GROUP].type = SANE_TYPE_GROUP;
  s->opt[OPT_CALIBRATION_GROUP].cap = SANE_CAP_ADVANCED;
  s->opt[OPT_CALIBRATION_GROUP].constraint_type = SANE_CONSTRAINT_NONE;

  /* Calibrate Every Scan? */
  s->opt[OPT_QUALITY_CAL].name = SANE_NAME_QUALITY_CAL;
  s->opt[OPT_QUALITY_CAL].title = "Hardware Calibrate Every Scan";
  s->opt[OPT_QUALITY_CAL].desc = "Perform hardware calibration on every scan";
  s->opt[OPT_QUALITY_CAL].type = SANE_TYPE_BOOL;
  s->val[OPT_QUALITY_CAL].w = SANE_FALSE;

  if (!(s->hw->flags & ARTEC_FLAG_CALIBRATE))
    {
      s->opt[OPT_QUALITY_CAL].cap |= SANE_CAP_INACTIVE;
    }

  /* Perform Software Quality Calibration */
  s->opt[OPT_SOFTWARE_CAL].name = "software-cal";
  s->opt[OPT_SOFTWARE_CAL].title = "Software Color Calibration";
  s->opt[OPT_SOFTWARE_CAL].desc = "Perform software quality calibration in "
    "addition to hardware calibration";
  s->opt[OPT_SOFTWARE_CAL].type = SANE_TYPE_BOOL;
  s->val[OPT_SOFTWARE_CAL].w = SANE_FALSE;

  /* check for RGB calibration now because we have only implemented software */
  /* calibration in conjunction with hardware RGB calibration */
  if ((!(s->hw->flags & ARTEC_FLAG_CALIBRATE)) ||
      (!(s->hw->flags & ARTEC_FLAG_CALIBRATE_RGB)))
    {
      s->opt[OPT_SOFTWARE_CAL].cap |= SANE_CAP_INACTIVE;
    }

  return (SANE_STATUS_GOOD);
}

static SANE_Status
do_cancel (ARTEC_Scanner * s)
{
  DBG (7, "do_cancel()\n");

  s->scanning = SANE_FALSE;

  /* DAL: Terminate a three pass scan properly */
/*  if (s->this_pass == 3) */
  s->this_pass = 0;

  if ((s->hw->flags & ARTEC_FLAG_RGB_LINE_OFFSET) &&
      (tmp_line_buf != NULL))
    {
      artec_buffer_line_offset_free ();
    }

  if (s->fd >= 0)
    {
      sanei_scsi_close (s->fd);
      s->fd = -1;
    }

  return (SANE_STATUS_CANCELLED);
}


static SANE_Status
attach_one (const char *dev)
{
  DBG (7, "attach_one()\n");

  attach (dev, 0);
  return (SANE_STATUS_GOOD);
}


SANE_Status
sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
{
  char dev_name[PATH_MAX], *cp;
  size_t len;
  FILE *fp;

  DBG_INIT ();

  DBG (1, "Artec/Ultima backend version %d.%d.%d, last mod: %s\n",
       ARTEC_MAJOR, ARTEC_MINOR, ARTEC_SUB, ARTEC_LAST_MOD);
  DBG (1, "http://www4.infi.net/~cpinkham/sane-artec-doc.html\n");

  DBG (7, "sane_init()\n" );

  devlist = 0;
  /* make sure these 2 are empty */
  strcpy (artec_vendor, "");
  strcpy (artec_model, "");

  if (version_code)
    *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, 0);

  if (authorize)
    DBG (7, "sane_init(), authorize callback specified as %p\n", (void *) authorize);

  fp = sanei_config_open (ARTEC_CONFIG_FILE);
  if (!fp)
    {
      /* default to /dev/scanner instead of insisting on config file */
      attach ("/dev/scanner", 0);
      return (SANE_STATUS_GOOD);
    }

  while (sanei_config_read (dev_name, sizeof (dev_name), fp))
    {
      cp = artec_skip_whitespace (dev_name);

      /* ignore line comments and blank lines */
      if ((!*cp) || (*cp == '#'))
      continue;

      len = strlen (cp);

      /* ignore empty lines */
      if (!len)
      continue;

      DBG (50, "%s line: '%s', len = %lu\n", ARTEC_CONFIG_FILE, cp,
         (u_long) len);

      /* check to see if they forced a vendor string in artec.conf */
      if ((strncmp (cp, "vendor", 6) == 0) && isspace (cp[6]))
      {
        cp += 7;
        cp = artec_skip_whitespace (cp);

        strcpy (artec_vendor, cp);
        DBG (5, "sane_init: Forced vendor string '%s' in %s.\n",
             cp, ARTEC_CONFIG_FILE);
      }
      /* OK, maybe they forced the model string in artec.conf */
      else if ((strncmp (cp, "model", 5) == 0) && isspace (cp[5]))
      {
        cp += 6;
        cp = artec_skip_whitespace (cp);

        strcpy (artec_model, cp);
        DBG (5, "sane_init: Forced model string '%s' in %s.\n",
             cp, ARTEC_CONFIG_FILE);
      }
      /* well, nothing else to do but attempt the attach */
      else
      {
        sanei_config_attach_matching_devices (dev_name, attach_one);
        strcpy (artec_vendor, "");
        strcpy (artec_model, "");
      }
    }
  fclose (fp);

  return (SANE_STATUS_GOOD);
}

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

  DBG (7, "sane_exit()\n");

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

  if (devlist)
    free (devlist);
}

SANE_Status
sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
{
  ARTEC_Device *dev;
  int i;

  DBG (7, "sane_get_devices( device_list, local_only = %d )\n", local_only );

  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;
  ARTEC_Device *dev;
  ARTEC_Scanner *s;
  int i, j;

  DBG (7, "sane_open()\n");

  if (devicename[0])
    {
      for (dev = first_dev; dev; dev = dev->next)
      if (strcmp (dev->sane.name, devicename) == 0)
        break;

      if (!dev)
      {
        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->fd = -1;
  s->hw = dev;
  s->this_pass = 0;

  s->gamma_length = s->hw->gamma_length;
  s->gamma_range.min = 0;
  s->gamma_range.max = s->gamma_length - 1;
  s->gamma_range.quant = 0;

  /* not sure if I need this or not, it was in the umax backend though. :-) */
  for (j = 0; j < s->gamma_length; ++j)
    {
      s->gamma_table[0][j] = j * (s->gamma_length - 1) / s->gamma_length;
    }

  for (i = 1; i < 4; i++)
    {
      for (j = 0; j < s->gamma_length; ++j)
      {
        s->gamma_table[i][j] = j;
      }
    }

  init_options (s);

  /* insert newly opened handle into list of open handles: */
  s->next = first_handle;
  first_handle = s;

  *handle = s;

  if (s->hw->flags & ARTEC_FLAG_CALIBRATE)
    {
      status = sanei_scsi_open (s->hw->sane.name, &s->fd, 0, 0);

      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "error opening scanner for initial calibration: %s\n",
             sane_strstatus (status));
        s->fd = -1;
        return status;
      }

      status = artec_calibrate_shading (s);

      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "initial shading calibration failed: %s\n",
             sane_strstatus (status));
        sanei_scsi_close (s->fd);
        s->fd = -1;
        return status;
      }

      sanei_scsi_close (s->fd);
    }

  return (SANE_STATUS_GOOD);
}

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

  DBG (7, "sane_close()\n");

  if ((DBG_LEVEL == 101) &&
      (debug_fd > -1))
    {
      close (debug_fd);
      DBG (101, "closed artec.data.raw output file\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, "close: invalid handle %p\n", handle);
      return;                 /* oops, not a handle we know about */
    }

  if (s->scanning)
    do_cancel (handle);


  if (prev)
    prev->next = s->next;
  else
    first_handle = s->next;

  free (handle);
}

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

  DBG (7, "sane_get_option_descriptor()\n");

  if (((unsigned) option >= NUM_OPTIONS) ||
      (option < 0 ))
    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)
{
  ARTEC_Scanner *s = handle;
  SANE_Status status;
  SANE_Word w, cap;

  DBG (7, "sane_control_option()\n");

  if (info)
    *info = 0;

  if (s->scanning)
    return SANE_STATUS_DEVICE_BUSY;

  if (s->this_pass)
    return SANE_STATUS_DEVICE_BUSY;

  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)
    {
      DBG (13, "sane_control_option %d, get value\n", option);

      switch (option)
      {
        /* word options: */
      case OPT_X_RESOLUTION:
      case OPT_Y_RESOLUTION:
      case OPT_PREVIEW:
      case OPT_GRAY_PREVIEW:
      case OPT_RESOLUTION_BIND:
      case OPT_NEGATIVE:
      case OPT_TRANSPARENCY:
      case OPT_ADF:
      case OPT_TL_X:
      case OPT_TL_Y:
      case OPT_BR_X:
      case OPT_BR_Y:
      case OPT_NUM_OPTS:
      case OPT_QUALITY_CAL:
      case OPT_SOFTWARE_CAL:
      case OPT_CONTRAST:
      case OPT_BRIGHTNESS:
      case OPT_THRESHOLD:
      case OPT_CUSTOM_GAMMA:
      case OPT_PIXEL_AVG:
      case OPT_EDGE_ENH:
        *(SANE_Word *) val = s->val[option].w;
        return (SANE_STATUS_GOOD);

        /* string options: */
      case OPT_MODE:
      case OPT_FILTER_TYPE:
      case OPT_HALFTONE_PATTERN:
        strcpy (val, s->val[option].s);
        return (SANE_STATUS_GOOD);

        /* word array options: */
      case OPT_GAMMA_VECTOR:
      case OPT_GAMMA_VECTOR_R:
      case OPT_GAMMA_VECTOR_G:
      case OPT_GAMMA_VECTOR_B:
        memcpy (val, s->val[option].wa, s->opt[option].size);
        return (SANE_STATUS_GOOD);
      }
    }
  else if (action == SANE_ACTION_SET_VALUE)
    {
      DBG (13, "sane_control_option %d, set value\n", option);

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

      switch (option)
      {
        /* (mostly) side-effect-free word options: */
      case OPT_X_RESOLUTION:
      case OPT_Y_RESOLUTION:
      case OPT_BR_X:
      case OPT_BR_Y:
      case OPT_TL_X:
      case OPT_TL_Y:
        if (info && s->val[option].w != *(SANE_Word *) val)
          *info |= SANE_INFO_RELOAD_PARAMS;

        /* fall through */
      case OPT_PREVIEW:
      case OPT_GRAY_PREVIEW:
      case OPT_QUALITY_CAL:
      case OPT_SOFTWARE_CAL:
      case OPT_NUM_OPTS:
      case OPT_NEGATIVE:
      case OPT_TRANSPARENCY:
      case OPT_ADF:
      case OPT_CONTRAST:
      case OPT_BRIGHTNESS:
      case OPT_THRESHOLD:
      case OPT_PIXEL_AVG:
      case OPT_EDGE_ENH:
        s->val[option].w = *(SANE_Word *) val;
        return (SANE_STATUS_GOOD);

      case OPT_MODE:
        {
          if (s->val[option].s)
            free (s->val[option].s);

          s->val[option].s = (SANE_Char *) strdup (val);

          if (info)
            *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;

          s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;

          /* options INvisible by default */
          s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_SOFTWARE_CAL].cap |= SANE_CAP_INACTIVE;
          s->opt[OPT_EDGE_ENH].cap |= SANE_CAP_INACTIVE;

          /* options VISIBLE by default */
          s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
          s->opt[OPT_FILTER_TYPE].cap &= ~SANE_CAP_INACTIVE;
            s->opt[OPT_NEGATIVE].cap &= ~SANE_CAP_INACTIVE;

          if (strcmp (val, "Lineart") == 0)
            {
              /* Lineart mode */
              s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; /* OFF */
              s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;

              if (s->hw->flags & ARTEC_FLAG_ENHANCE_LINE_EDGE)
              s->opt[OPT_EDGE_ENH].cap &= ~SANE_CAP_INACTIVE;
            }
          else if (strcmp (val, "Halftone") == 0)
            {
            /* Halftone mode */
            if (s->hw->flags & ARTEC_FLAG_HALFTONE_PATTERN)
              s->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
            }
          else if (strcmp (val, "Gray") == 0)
            {
            /* Grayscale mode */
                if (!(s->hw->flags & ARTEC_FLAG_MBPP_NEGATIVE))
                  {
                    s->opt[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE;
                  }
            }
          else if (strcmp (val, "Color") == 0)
            {
              /* Color mode */
              s->opt[OPT_FILTER_TYPE].cap |= SANE_CAP_INACTIVE;
            s->opt[OPT_SOFTWARE_CAL].cap &= ~SANE_CAP_INACTIVE;
                if (!(s->hw->flags & ARTEC_FLAG_MBPP_NEGATIVE))
                  {
                    s->opt[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE;
                  }
            }
        }
        return (SANE_STATUS_GOOD);

      case OPT_FILTER_TYPE:
      case OPT_HALFTONE_PATTERN:
        if (s->val[option].s)
          free (s->val[option].s);
        s->val[option].s = strdup (val);
        return (SANE_STATUS_GOOD);

      case OPT_RESOLUTION_BIND:
        if (s->val[option].w != *(SANE_Word *) val)
          {
            s->val[option].w = *(SANE_Word *) val;

            if (info)
            {
              *info |= SANE_INFO_RELOAD_OPTIONS;
            }

            if (s->val[option].w == SANE_FALSE)
            {           /* don't bind */
              s->opt[OPT_Y_RESOLUTION].cap &= ~SANE_CAP_INACTIVE;
              s->opt[OPT_X_RESOLUTION].title =
                SANE_TITLE_SCAN_X_RESOLUTION;
              s->opt[OPT_X_RESOLUTION].name =
                SANE_NAME_SCAN_X_RESOLUTION;
              s->opt[OPT_X_RESOLUTION].desc =
                SANE_DESC_SCAN_X_RESOLUTION;
            }
            else
            {           /* bind */
              s->opt[OPT_Y_RESOLUTION].cap |= SANE_CAP_INACTIVE;
              s->opt[OPT_X_RESOLUTION].title =
                SANE_TITLE_SCAN_RESOLUTION;
              s->opt[OPT_X_RESOLUTION].name =
                SANE_NAME_SCAN_RESOLUTION;
              s->opt[OPT_X_RESOLUTION].desc =
                SANE_DESC_SCAN_RESOLUTION;
            }
          }
        return (SANE_STATUS_GOOD);

        /* side-effect-free word-array options: */
      case OPT_GAMMA_VECTOR:
      case OPT_GAMMA_VECTOR_R:
      case OPT_GAMMA_VECTOR_G:
      case OPT_GAMMA_VECTOR_B:
        memcpy (s->val[option].wa, val, s->opt[option].size);
        return (SANE_STATUS_GOOD);

        /* options with side effects: */
      case OPT_CUSTOM_GAMMA:
        w = *(SANE_Word *) val;
        if (w == s->val[OPT_CUSTOM_GAMMA].w)
          return (SANE_STATUS_GOOD);

        s->val[OPT_CUSTOM_GAMMA].w = w;
        if (w)          /* use custom_gamma_table */
          {
            const char *mode = s->val[OPT_MODE].s;

            if ((strcmp (mode, "Lineart") == 0) ||
              (strcmp (mode, "Halftone") == 0) ||
              (strcmp (mode, "Gray") == 0))
            {
              s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
            }
            else if (strcmp (mode, "Color") == 0)
            {
              s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;

              if (!(s->hw->flags & ARTEC_FLAG_GAMMA_SINGLE))
                {
                  s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
                  s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
                  s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
                }
            }
          }
        else
          /* don't use custom_gamma_table */
          {
            s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
            s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
            s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
            s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
          }

        if (info)
          *info |= SANE_INFO_RELOAD_OPTIONS;

        return (SANE_STATUS_GOOD);
      }
    }

  return (SANE_STATUS_INVAL);
}

static void
set_pass_parameters (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;

  DBG (7, "set_pass_parameters()\n");

  if (s->threepasscolor)
    {
      s->this_pass += 1;
      DBG (9, "set_pass_parameters:  three-pass, on %d\n", s->this_pass);
      switch (s->this_pass)
      {
      case 1:
        s->params.format = SANE_FRAME_RED;
        s->params.last_frame = SANE_FALSE;
        break;
      case 2:
        s->params.format = SANE_FRAME_GREEN;
        s->params.last_frame = SANE_FALSE;
        break;
      case 3:
        s->params.format = SANE_FRAME_BLUE;
        s->params.last_frame = SANE_TRUE;
        break;
      default:
        DBG (9, "set_pass_parameters:  What?!? pass %d = filter?\n",
             s->this_pass);
        break;
      }
    }
  else
    s->this_pass = 0;
}

SANE_Status
sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
{
  ARTEC_Scanner *s = handle;

  DBG (7, "sane_get_parameters()\n");

  if (!s->scanning)
    {
      double width, height;

      memset (&s->params, 0, sizeof (s->params));

      s->x_resolution = s->val[OPT_X_RESOLUTION].w;
      s->y_resolution = s->val[OPT_Y_RESOLUTION].w;

      if ((s->val[OPT_RESOLUTION_BIND].w == SANE_TRUE) ||
        (s->val[OPT_PREVIEW].w == SANE_TRUE))
      {
        s->y_resolution = s->x_resolution;
      }

      s->tl_x = SANE_UNFIX (s->val[OPT_TL_X].w) / MM_PER_INCH
      * s->x_resolution;
      s->tl_y = SANE_UNFIX (s->val[OPT_TL_Y].w) / MM_PER_INCH
      * s->y_resolution;
      width = SANE_UNFIX (s->val[OPT_BR_X].w - s->val[OPT_TL_X].w);
      height = SANE_UNFIX (s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w);

      if ((s->x_resolution > 0.0) &&
        (s->y_resolution > 0.0) &&
        (width > 0.0) &&
        (height > 0.0))
      {
        s->params.pixels_per_line = width * s->x_resolution / MM_PER_INCH + 1;
        s->params.lines = height * s->y_resolution / MM_PER_INCH + 1;
      }

      s->onepasscolor = SANE_FALSE;
      s->threepasscolor = SANE_FALSE;
      s->params.last_frame = SANE_TRUE;

      if ((s->val[OPT_PREVIEW].w == SANE_TRUE) &&
        (s->val[OPT_GRAY_PREVIEW].w == SANE_TRUE))
      {
        s->mode = "Gray";
      }
      else
      {
        s->mode = s->val[OPT_MODE].s;
      }

      if ((strcmp (s->mode, "Lineart") == 0) ||
        (strcmp (s->mode, "Halftone") == 0))
      {
        s->params.format = SANE_FRAME_GRAY;
        s->params.bytes_per_line = (s->params.pixels_per_line + 7) / 8;
        s->params.depth = 1;
        s->line_offset = 0;

        /* round pixels_per_line up to the next full byte of pixels */
        /* this way we don't have to do bit buffering, pixels_per_line is */
        /* what is used in the set window command. */
        /* SANE expects the last byte in a line to be padded if it's not */
        /* full, so this should not affect scans in a negative way */
        s->params.pixels_per_line = s->params.bytes_per_line * 8;
      }
      else if (strcmp (s->mode, "Gray") == 0)
      {
        s->params.format = SANE_FRAME_GRAY;
        s->params.bytes_per_line = s->params.pixels_per_line;
        s->params.depth = 8;
        s->line_offset = 0;
      }
      else
      {
        s->params.bytes_per_line = s->params.pixels_per_line;
        s->params.depth = 8;

        if (s->hw->flags & ARTEC_FLAG_ONE_PASS_SCANNER)
          {
            s->onepasscolor = SANE_TRUE;
            s->params.format = SANE_FRAME_RGB;
            s->params.bytes_per_line *= 3;

            /*
             * line offsets from documentation.
             * (I don't yet see a common formula I can easily use)
             */
            /* FIXME: figure out a cleaner way to do this... */
            s->line_offset = 0;     /* default */
            if ((!strcmp (s->hw->sane.model, "AT3")) ||
              (!strcmp (s->hw->sane.model, "A6000C")) ||
              (!strcmp (s->hw->sane.model, "A6000C PLUS")) ||
              (!strcmp (s->hw->sane.model, "AT6")))
            {
              /* formula #1 */
              /* ranges from 1 at 50dpi to 16 at 600dpi */
              s->line_offset = 8 * (s->y_resolution / 300.0);
            }
            else if (!strcmp (s->hw->sane.model, "AT12"))
            {
              /* formula #2 */
              /* ranges from 0 at 25dpi to 16 at 1200dpi */
                  /***********************************************************/
              /* this should be handled in hardware for now, so leave it */
              /* sitting at zero for now.                                */
                  /***********************************************************/
              /*
                 s->line_offset = 16 * ( s->y_resolution / 1200.0 );
               */
            }
            else if (!strcmp (s->hw->sane.model, "AM12S"))
            {
              /* formula #3 */
              /* ranges from 0 at 50dpi to 8 at 1200dpi */
              s->line_offset = 8 * (s->y_resolution / 1200.0);
            }
          }
        else
          {
            s->params.last_frame = SANE_FALSE;
            s->threepasscolor = SANE_TRUE;
            s->line_offset = 0;
          }
      }
    }

  if (params)
    *params = s->params;

  return (SANE_STATUS_GOOD);
}


SANE_Status
sane_start (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;
  SANE_Status status;

  DBG (7, "sane_start()\n");

  if (debug_fd != -1)
    {
      close (debug_fd);
      debug_fd = -1;
    }

  if (DBG_LEVEL == 101)
    {
      debug_fd = open ("artec.data.raw",
                   O_WRONLY | O_CREAT | O_TRUNC, 0666);
      if (debug_fd > -1)
      DBG (101, "opened artec.data.raw output file\n");
    }

  /* First make sure we have a current parameter set.  Some of the */
  /* parameters will be overwritten below, but that's OK.  */
  status = sane_get_parameters (s, 0);
  if (status != SANE_STATUS_GOOD)
    return status;

  /* DAL: For 3 pass colour set the current pass parameters */
  if ((strcmp (s->mode, "Color") == 0) && s->threepasscolor)
    set_pass_parameters (s);

  /* DAL: For single pass scans and the first pass of a 3 pass scan */
  if ((strcmp (s->mode, "Color") != 0) ||
      (!s->threepasscolor) ||
      ((s->threepasscolor) &&
       (s->this_pass == 1)))
    {

      if (s->hw->flags & ARTEC_FLAG_SENSE_HANDLER)
      {
        status = sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler,
          (void *)s);
      }
      else
      {
        status = sanei_scsi_open (s->hw->sane.name, &s->fd, 0, 0);
      }

      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "open of %s failed: %s\n",
             s->hw->sane.name, sane_strstatus (status));
        return status;
      }

      /* DB added wait_ready */
      status = wait_ready (s->fd);
      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "wait for scanner ready failed: %s\n",
             sane_strstatus (status));
        return status;
      }
    }

  s->bytes_to_read = s->params.bytes_per_line * s->params.lines;

  DBG (9, "%d pixels per line, %d bytes, %d lines high, xdpi = %d, "
       "ydpi = %d, btr = %lu\n",
       s->params.pixels_per_line, s->params.bytes_per_line, s->params.lines,
       s->x_resolution, s->y_resolution, (u_long) s->bytes_to_read);

  /* DAL: For single pass scans and the first pass of a 3 pass scan */
  if ((strcmp (s->mode, "Color") != 0) || !s->threepasscolor ||
      (s->threepasscolor && s->this_pass == 1))
    {

      /* do a calibrate if scanner requires/recommends it */
      if ((s->hw->flags & ARTEC_FLAG_CALIBRATE) &&
        (s->val[OPT_QUALITY_CAL].w == SANE_TRUE))
      {
        status = artec_calibrate_shading (s);

        if (status != SANE_STATUS_GOOD)
          {
            DBG (1, "shading calibration failed: %s\n",
               sane_strstatus (status));
            return status;
          }
      }

      /* DB added wait_ready */
      status = wait_ready (s->fd);
      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "wait for scanner ready failed: %s\n",
             sane_strstatus (status));
        return status;
      }

      /* send the custom gamma table if we have one */
      if (s->hw->flags & ARTEC_FLAG_GAMMA)
      artec_send_gamma_table (s);

      /* now set our scan window */
      status = artec_set_scan_window (s);

      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "set scan window failed: %s\n",
             sane_strstatus (status));
        return status;
      }

      /* DB added wait_ready */
      status = wait_ready (s->fd);
      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "wait for scanner ready failed: %s\n",
             sane_strstatus (status));
        return status;
      }
    }

  /* now we can start the actual scan */
  /* DAL: For single pass scans and the first pass of a 3 pass scan */
  if ((strcmp (s->mode, "Color") != 0) ||
      (!s->threepasscolor) ||
      (s->this_pass == 1))
    {
      /* DAL - do mode select before each scan */
      /*       The mode is NOT turned off at the end of the scan */
      artec_mode_select (s);

      status = artec_start_scan (s);

      if (status != SANE_STATUS_GOOD)
      {
        DBG (1, "start scan: %s\n", sane_strstatus (status));
        return status;
      }
    }

  s->scanning = SANE_TRUE;

  return (SANE_STATUS_GOOD);
}


#if 0
static void
binout (SANE_Byte byte)
{
  SANE_Byte b = byte;
  int bit;

  for (bit = 0; bit < 8; bit++)
    {
      DBG (9, "%d", b & 128 ? 1 : 0);
      b = b << 1;
    }
}
#endif

static SANE_Status
artec_sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len)
{
  ARTEC_Scanner *s = handle;
  SANE_Status status;
  size_t nread;
  size_t lread;
  size_t bytes_read;
  size_t rows_read;
  size_t max_read_rows;
  size_t max_ret_rows;
  size_t remaining_rows;
  size_t rows_available;
  size_t line;
  SANE_Byte temp_buf[ARTEC_MAX_READ_SIZE];
  SANE_Byte line_buf[ARTEC_MAX_READ_SIZE];


  DBG (7, "artec_sane_read( %p, %p, %d, %d )\n", handle, buf, max_len, *len);

  *len = 0;

  if (s->bytes_to_read == 0)
    {
      if ((strcmp (s->mode, "Color") != 0) || !s->threepasscolor ||
        (s->threepasscolor && s->this_pass == 3))
      {
        do_cancel (s);
        /* without this a 4th pass is attempted, yet do_cancel does this */
        s->scanning = SANE_FALSE;
      }
      return (SANE_STATUS_EOF);
    }

  if (!s->scanning)
    return do_cancel (s);

  remaining_rows = (s->bytes_to_read + s->params.bytes_per_line - 1) / s->params.bytes_per_line;
  max_read_rows = s->hw->max_read_size / s->params.bytes_per_line;
  max_ret_rows = max_len / s->params.bytes_per_line;

  while (artec_get_status (s->fd) == 0)
    {
      DBG (120, "hokey loop till data available\n");
      usleep (50000);         /* sleep for .05 second */
    }

  rows_read = 0;
  bytes_read = 0;
  while ((rows_read < max_ret_rows) && (rows_read < remaining_rows))
    {
      DBG (50, "top of while loop, rr = %lu, mrr = %lu, rem = %lu\n",
         (u_long) rows_read, (u_long) max_ret_rows, (u_long) remaining_rows);

      if (s->bytes_to_read - bytes_read <= s->params.bytes_per_line * max_read_rows)
      {
        nread = s->bytes_to_read - bytes_read;
      }
      else
      {
        nread = s->params.bytes_per_line * max_read_rows;
      }
      lread = nread / s->params.bytes_per_line;

      if ((max_read_rows - rows_read) < lread)
      {
        lread = max_read_rows - rows_read;
        nread = lread * s->params.bytes_per_line;
      }

      if ((max_ret_rows - rows_read) < lread)
      {
        lread = max_ret_rows - rows_read;
        nread = lread * s->params.bytes_per_line;
      }

      while ((rows_available = artec_get_status (s->fd)) == 0)
      {
        DBG (120, "hokey loop till data available\n");
        usleep (50000); /* sleep for .05 second */
      }

      if (rows_available < lread)
      {
        lread = rows_available;
        nread = lread * s->params.bytes_per_line;
      }

      /* This should never happen, but just in case... */
      if (nread > (s->bytes_to_read - bytes_read))
      {
        nread = s->bytes_to_read - bytes_read;
        lread = 1;
      }

      DBG (50, "rows_available = %lu, params.lines = %d, bytes_per_line = %d\n",
         (u_long) rows_available, s->params.lines, s->params.bytes_per_line);
      DBG (50, "bytes_to_read = %lu, max_len = %d, max_rows = %lu\n",
         (u_long) s->bytes_to_read, max_len, (u_long) max_ret_rows);
      DBG (50, "nread = %lu, lread = %lu, bytes_read = %lu, rows_read = %lu\n",
         (u_long) nread, (u_long) lread, (u_long) bytes_read, (u_long) rows_read);

      status = read_data (s->fd, ARTEC_DATA_IMAGE, temp_buf, &nread);

      if (status != SANE_STATUS_GOOD)
      {
        end_scan (s);
        do_cancel (s);
        return (SANE_STATUS_IO_ERROR);
      }

      if ((DBG_LEVEL == 101) &&
        (debug_fd > -1))
      {
        write (debug_fd, temp_buf, nread);
      }

      if ((strcmp (s->mode, "Color") == 0) &&
        (s->hw->flags & ARTEC_FLAG_RGB_LINE_OFFSET))
      {
        for (line = 0; line < lread; line++)
          {
            memcpy (line_buf,
                  temp_buf + (line * s->params.bytes_per_line),
                  s->params.bytes_per_line);

            nread = s->params.bytes_per_line;

            artec_buffer_line_offset (s, s->line_offset, line_buf, &nread);

            if (nread > 0)
            {
              if (s->hw->flags & ARTEC_FLAG_RGB_CHAR_SHIFT)
                {
                  artec_line_rgb_to_byte_rgb (line_buf,
                                      s->params.pixels_per_line);
                }
              if (s->hw->flags & ARTEC_FLAG_IMAGE_REV_LR)
                {
                  artec_reverse_line (s, line_buf);
                }

              /* do software calibration if necessary */
              if (s->val[OPT_SOFTWARE_CAL].w)
                {
                  artec_software_rgb_calibrate (s, line_buf, 1);
                }

              memcpy (buf + bytes_read, line_buf,
                    s->params.bytes_per_line);
              bytes_read += nread;
              rows_read++;
            }
          }
      }
      else
      {
        if ((s->hw->flags & ARTEC_FLAG_IMAGE_REV_LR) ||
            ((strcmp (s->mode, "Color") == 0) &&
             (s->hw->flags & ARTEC_FLAG_RGB_CHAR_SHIFT)))
          {
            for (line = 0; line < lread; line++)
            {
              if ((strcmp (s->mode, "Color") == 0) &&
                  (s->hw->flags & ARTEC_FLAG_RGB_CHAR_SHIFT))
                {
                  artec_line_rgb_to_byte_rgb (temp_buf +
                                (line * s->params.bytes_per_line),
                                      s->params.pixels_per_line);
                }
              if (s->hw->flags & ARTEC_FLAG_IMAGE_REV_LR)
                {
                  artec_reverse_line (s, temp_buf +
                                (line * s->params.bytes_per_line));
                }
            }
          }

        /* do software calibration if necessary */
        if ((s->val[OPT_SOFTWARE_CAL].w) &&
            (strcmp (s->mode, "Color") == 0))
          {
            artec_software_rgb_calibrate (s, temp_buf, lread);
          }

        memcpy (buf + bytes_read, temp_buf, nread);
        bytes_read += nread;
        rows_read += lread;
      }
    }

  *len = bytes_read;
  s->bytes_to_read -= bytes_read;

  DBG (9, "artec_sane_read() returning, we read %lu bytes, %lu left\n",
       (u_long) * len, (u_long) s->bytes_to_read);

  if ((s->bytes_to_read == 0) &&
      (s->hw->flags & ARTEC_FLAG_RGB_LINE_OFFSET) &&
      (tmp_line_buf != NULL))
    {
      artec_buffer_line_offset_free ();
    }

  return (SANE_STATUS_GOOD);
}

SANE_Status
sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len)
{
  ARTEC_Scanner *s = handle;
  SANE_Status status;
  int bytes_to_copy;
  int loop;

  static SANE_Byte temp_buf[ARTEC_MAX_READ_SIZE];
  static int bytes_in_buf = 0;

  DBG (7, "sane_read( %p, %p, %d, %d )\n", handle, buf, max_len, *len);
  DBG (9, "sane_read: bib = %d, ml = %d\n", bytes_in_buf, max_len);

  if (bytes_in_buf != 0)
    {
      bytes_to_copy = max_len < bytes_in_buf ? max_len : bytes_in_buf;
    }
  else
    {
      status = artec_sane_read (s, temp_buf, s->hw->max_read_size, len);

      if (status != SANE_STATUS_GOOD)
      {
        return (status);
      }

      bytes_in_buf = *len;

      if (*len == 0)
      {
        return (SANE_STATUS_GOOD);
      }

      bytes_to_copy = max_len < s->hw->max_read_size ?
      max_len : s->hw->max_read_size;
      bytes_to_copy = *len < bytes_to_copy ? *len : bytes_to_copy;
    }

  memcpy (buf, temp_buf, bytes_to_copy);
  bytes_in_buf -= bytes_to_copy;
  *len = bytes_to_copy;

  DBG (9, "sane_read: btc = %d, bib now = %d\n",
       bytes_to_copy, bytes_in_buf);

  for (loop = 0; loop < bytes_in_buf; loop++)
    {
      temp_buf[loop] = temp_buf[loop + bytes_to_copy];
    }

  return (SANE_STATUS_GOOD);
}

void
sane_cancel (SANE_Handle handle)
{
  ARTEC_Scanner *s = handle;

  DBG (7, "sane_cancel()\n");

  if (s->scanning)
    {
      s->scanning = SANE_FALSE;

      abort_scan (s);

      do_cancel (s);
    }
}

SANE_Status
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
{
  DBG (7, "sane_set_io_mode( %p, %d )\n", handle, non_blocking);

  return (SANE_STATUS_UNSUPPORTED);
}

SANE_Status
sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
{
  DBG (7, "sane_get_select_fd( %p, %d )\n", handle, *fd );

  return (SANE_STATUS_UNSUPPORTED);
}

Generated by  Doxygen 1.6.0   Back to index