/* sane - Scanner Access Now Easy.

   Copyright (C) 2002 Sergey Vlasov <vsu@altlinux.ru>
   Copyright (C) 2002 - 2007 Henning Geinitz <sane@geinitz.org>
   Copyright (C) 2009 Stphane Voltz <stef.dev@free.fr> for sheetfed
                      calibration code.

   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. 
*/

/*
 * SANE backend for Grandtech GT-6801 and GT-6816 based scanners
 */

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

#define BUILD 84
#define MAX_DEBUG
#define WARMUP_TIME 60
#define CALIBRATION_HEIGHT 2.5
#define SHORT_TIMEOUT (1 * 1000)
#define LONG_TIMEOUT (30 * 1000)

/* Use a reader process if possible (usually faster) */
#if defined (HAVE_SYS_SHM_H) && (!defined (USE_PTHREAD)) && (!defined (HAVE_OS2_H))
#define USE_FORK
#define SHM_BUFFERS 10
#endif

#define TUNE_CALIBRATOR

/* Send coarse white or black calibration to stdout */
#if 0
#define SAVE_WHITE_CALIBRATION
#endif
#if 0
#define SAVE_BLACK_CALIBRATION
#endif

/* Debug calibration, print total brightness of the scanned image */
#if 0
#define DEBUG_BRIGHTNESS
#endif

/* Debug calibration, print black mark values */
#if 0
#define DEBUG_BLACK
#endif

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <math.h>
#include <dirent.h>

#include "../include/_stdint.h"

#include "../include/sane/sane.h"
#include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h"

#define BACKEND_NAME gt68xx

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

#ifndef SANE_I18N
#define SANE_I18N(text) text
#endif

#include "gt68xx.h"
#include "gt68xx_high.c"
#include "gt68xx_devices.c"

static SANE_Int num_devices = 0;
static GT68xx_Device *first_dev = 0;
static GT68xx_Scanner *first_handle = 0;
static const SANE_Device **devlist = 0;
/* Array of newly attached devices */
static GT68xx_Device **new_dev = 0;
/* Length of new_dev array */
static SANE_Int new_dev_len = 0;
/* Number of entries alloced for new_dev */
static SANE_Int new_dev_alloced = 0;
/* Is this computer little-endian ?*/
SANE_Bool little_endian;
SANE_Bool debug_options = SANE_FALSE;

static SANE_String_Const mode_list[] = {
  SANE_VALUE_SCAN_MODE_COLOR,
  SANE_VALUE_SCAN_MODE_GRAY,
  SANE_VALUE_SCAN_MODE_LINEART,
  0
};

static SANE_String_Const gray_mode_list[] = {
  GT68XX_COLOR_RED,
  GT68XX_COLOR_GREEN,
  GT68XX_COLOR_BLUE,
  0
};

static SANE_String_Const source_list[] = {
  SANE_I18N ("Flatbed"),
  SANE_I18N ("Transparency Adapter"),
  0
};

static SANE_Range x_range = {
  SANE_FIX (0.0),               /* minimum */
  SANE_FIX (216.0),             /* maximum */
  SANE_FIX (0.0)                /* quantization */
};

static SANE_Range y_range = {
  SANE_FIX (0.0),               /* minimum */
  SANE_FIX (299.0),             /* maximum */
  SANE_FIX (0.0)                /* quantization */
};


static const SANE_Range offset_range = {
  -63,                          /* minimum */
  63,                           /* maximum */
  1                             /* quantization */
};

static SANE_Range gamma_range = {
  SANE_FIX (0.01),              /* minimum */
  SANE_FIX (5.0),               /* maximum */
  SANE_FIX (0.01)               /* quantization */
};

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

/* Test if this machine is little endian (from coolscan.c) */
static SANE_Bool
calc_little_endian (void)
{
  SANE_Int testvalue = 255;
  uint8_t *firstbyte = (uint8_t *) & testvalue;

  if (*firstbyte == 255)
    return SANE_TRUE;
  return SANE_FALSE;
}

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

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

static SANE_Status
get_afe_values (SANE_String_Const cp, GT68xx_AFE_Parameters * afe)
{
  SANE_Char *word, *end;
  int i;

  for (i = 0; i < 6; i++)
    {
      cp = sanei_config_get_string (cp, &word);
      if (word && *word)
        {
          long int long_value;
          errno = 0;
          long_value = strtol (word, &end, 0);

          if (end == word)
            {
              DBG (5, "get_afe_values: can't parse %d. parameter `%s'\n",
                   i + 1, word);
              free (word);
              word = 0;
              return SANE_STATUS_INVAL;
            }
          else if (errno)
            {
              DBG (5, "get_afe_values: can't parse %d. parameter `%s' "
                   "(%s)\n", i + 1, word, strerror (errno));
              free (word);
              word = 0;
              return SANE_STATUS_INVAL;
            }
          else if (long_value < 0)
            {
              DBG (5, "get_afe_values: %d. parameter < 0 (%d)\n", i + 1,
                   (int) long_value);
              free (word);
              word = 0;
              return SANE_STATUS_INVAL;
            }
          else if (long_value > 0x3f)
            {
              DBG (5, "get_afe_values: %d. parameter > 0x3f (%d)\n", i + 1,
                   (int) long_value);
              free (word);
              word = 0;
              return SANE_STATUS_INVAL;
            }
          else
            {
              DBG (5, "get_afe_values: %d. parameter set to 0x%02x\n", i + 1,
                   (int) long_value);
              switch (i)
                {
                case 0:
                  afe->r_offset = (SANE_Byte) long_value;
                  break;
                case 1:
                  afe->r_pga = (SANE_Byte) long_value;
                  break;
                case 2:
                  afe->g_offset = (SANE_Byte) long_value;
                  break;
                case 3:
                  afe->g_pga = (SANE_Byte) long_value;
                  break;
                case 4:
                  afe->b_offset = (SANE_Byte) long_value;
                  break;
                case 5:
                  afe->b_pga = (SANE_Byte) long_value;
                  break;
                }
              free (word);
              word = 0;
            }
        }
      else
        {
          DBG (5, "get_afe_values: option `afe' needs 6  parameters\n");
          return SANE_STATUS_INVAL;
        }
    }
  return SANE_STATUS_GOOD;
}

static SANE_Status
setup_scan_request (GT68xx_Scanner * s, GT68xx_Scan_Request * scan_request)
{

  if (s->dev->model->flags & GT68XX_FLAG_MIRROR_X)
    scan_request->x0 =
      s->opt[OPT_TL_X].constraint.range->max - s->val[OPT_BR_X].w;
  else
    scan_request->x0 = s->val[OPT_TL_X].w;
  scan_request->y0 = s->val[OPT_TL_Y].w;
  scan_request->xs = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w;
  scan_request->ys = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w;

  if (s->val[OPT_FULL_SCAN].w == SANE_TRUE)
    {
      scan_request->x0 -= s->dev->model->x_offset;
      scan_request->y0 -= (s->dev->model->y_offset);
      scan_request->xs += s->dev->model->x_offset;
      scan_request->ys += s->dev->model->y_offset;
    }

  scan_request->xdpi = s->val[OPT_RESOLUTION].w;
  if (scan_request->xdpi > s->dev->model->optical_xdpi)
    scan_request->xdpi = s->dev->model->optical_xdpi;
  scan_request->ydpi = s->val[OPT_RESOLUTION].w;

  if (IS_ACTIVE (OPT_BIT_DEPTH) && !s->val[OPT_PREVIEW].w)
    scan_request->depth = s->val[OPT_BIT_DEPTH].w;
  else
    scan_request->depth = 8;

  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
    scan_request->color = SANE_TRUE;
  else
    scan_request->color = SANE_FALSE;

  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
    {
      SANE_Int xs =
        SANE_UNFIX (scan_request->xs) * scan_request->xdpi / MM_PER_INCH +
        0.5;

      if (xs % 8)
        {
          scan_request->xs =
            SANE_FIX ((xs - (xs % 8)) * MM_PER_INCH / scan_request->xdpi);
          DBG (5, "setup_scan_request: lineart mode, %d pixels %% 8 = %d\n",
               xs, xs % 8);
        }
    }

  scan_request->calculate = SANE_FALSE;
  scan_request->lamp = SANE_TRUE;
  scan_request->mbs = SANE_FALSE;

  if (strcmp (s->val[OPT_SOURCE].s, "Transparency Adapter") == 0)
    scan_request->use_ta = SANE_TRUE;
  else
    scan_request->use_ta = SANE_FALSE;

  return SANE_STATUS_GOOD;
}

static SANE_Status
calc_parameters (GT68xx_Scanner * s)
{
  SANE_String val;
  SANE_Status status = SANE_STATUS_GOOD;
  GT68xx_Scan_Request scan_request;
  GT68xx_Scan_Parameters scan_params;

  DBG (5, "calc_parameters: start\n");
  val = s->val[OPT_MODE].s;

  s->params.last_frame = SANE_TRUE;
  if (strcmp (val, SANE_VALUE_SCAN_MODE_GRAY) == 0
      || strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) == 0)
    s->params.format = SANE_FRAME_GRAY;
  else                          /* Color */
    s->params.format = SANE_FRAME_RGB;

  setup_scan_request (s, &scan_request);
  scan_request.calculate = SANE_TRUE;

  status = gt68xx_device_setup_scan (s->dev, &scan_request, SA_SCAN,
                                     &scan_params);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "calc_parameters: gt68xx_device_setup_scan returned: %s\n",
           sane_strstatus (status));
      return status;
    }

  if (strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) == 0)
    s->params.depth = 1;
  else
    s->params.depth = scan_params.depth;

  s->params.lines = scan_params.pixel_ys;
  s->params.pixels_per_line = scan_params.pixel_xs;
  /* Inflate X if necessary */
  if (s->val[OPT_RESOLUTION].w > s->dev->model->optical_xdpi)
    s->params.pixels_per_line *=
      (s->val[OPT_RESOLUTION].w / s->dev->model->optical_xdpi);
  s->params.bytes_per_line = s->params.pixels_per_line;
  if (s->params.depth > 8)
    {
      s->params.depth = 16;
      s->params.bytes_per_line *= 2;
    }
  else if (s->params.depth == 1)
    s->params.bytes_per_line /= 8;

  if (s->params.format == SANE_FRAME_RGB)
    s->params.bytes_per_line *= 3;

  DBG (5, "calc_parameters: exit\n");
  return status;
}

static SANE_Status
create_bpp_list (GT68xx_Scanner * s, SANE_Int * bpp)
{
  int count;

  for (count = 0; bpp[count] != 0; count++)
    ;
  s->bpp_list[0] = count;
  for (count = 0; bpp[count] != 0; count++)
    {
      s->bpp_list[s->bpp_list[0] - count] = bpp[count];
    }
  return SANE_STATUS_GOOD;
}

static SANE_Status
init_options (GT68xx_Scanner * s)
{
  SANE_Int option, count;
  SANE_Status status;
  SANE_Word *dpi_list;
  GT68xx_Model *model = s->dev->model;
  SANE_Bool has_ta = SANE_FALSE;

  DBG (5, "init_options: start\n");

  memset (s->opt, 0, sizeof (s->opt));
  memset (s->val, 0, sizeof (s->val));

  for (option = 0; option < NUM_OPTIONS; ++option)
    {
      s->opt[option].size = sizeof (SANE_Word);
      s->opt[option].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
    }
  s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
  s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
  s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
  s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
  s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
  s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;

  /* "Mode" group: */
  s->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
  s->opt[OPT_MODE_GROUP].desc = "";
  s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
  s->opt[OPT_MODE_GROUP].size = 0;
  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].constraint_type = SANE_CONSTRAINT_STRING_LIST;
  s->opt[OPT_MODE].size = max_string_size (mode_list);
  s->opt[OPT_MODE].constraint.string_list = mode_list;
  s->val[OPT_MODE].s = strdup (SANE_VALUE_SCAN_MODE_GRAY);

  /* scan mode */
  s->opt[OPT_GRAY_MODE_COLOR].name = "gray-mode-color";
  s->opt[OPT_GRAY_MODE_COLOR].title = SANE_I18N ("Gray mode color");
  s->opt[OPT_GRAY_MODE_COLOR].desc =
    SANE_I18N ("Selects which scan color is used "
               "gray mode (default: green).");
  s->opt[OPT_GRAY_MODE_COLOR].type = SANE_TYPE_STRING;
  s->opt[OPT_GRAY_MODE_COLOR].constraint_type = SANE_CONSTRAINT_STRING_LIST;
  s->opt[OPT_GRAY_MODE_COLOR].size = max_string_size (gray_mode_list);
  s->opt[OPT_GRAY_MODE_COLOR].constraint.string_list = gray_mode_list;
  s->val[OPT_GRAY_MODE_COLOR].s = strdup (GT68XX_COLOR_GREEN);

  /* scan source */
  s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
  s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
  s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
  s->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
  s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
  s->opt[OPT_SOURCE].size = max_string_size (source_list);
  s->opt[OPT_SOURCE].constraint.string_list = source_list;
  s->val[OPT_SOURCE].s = strdup ("Flatbed");
  status = gt68xx_device_get_ta_status (s->dev, &has_ta);
  if (status != SANE_STATUS_GOOD || !has_ta)
    DISABLE (OPT_SOURCE);

  /* preview */
  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].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_PREVIEW].w = SANE_FALSE;

  /* lamp on */
  s->opt[OPT_LAMP_OFF_AT_EXIT].name = SANE_NAME_LAMP_OFF_AT_EXIT;
  s->opt[OPT_LAMP_OFF_AT_EXIT].title = SANE_TITLE_LAMP_OFF_AT_EXIT;
  s->opt[OPT_LAMP_OFF_AT_EXIT].desc = SANE_DESC_LAMP_OFF_AT_EXIT;
  s->opt[OPT_LAMP_OFF_AT_EXIT].type = SANE_TYPE_BOOL;
  s->opt[OPT_LAMP_OFF_AT_EXIT].unit = SANE_UNIT_NONE;
  s->opt[OPT_LAMP_OFF_AT_EXIT].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_LAMP_OFF_AT_EXIT].w = SANE_TRUE;
  if (s->dev->model->is_cis && !(s->dev->model->flags & GT68XX_FLAG_CIS_LAMP))
    DISABLE (OPT_LAMP_OFF_AT_EXIT);

  /* bit depth */
  s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
  s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
  s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
  s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
  s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
  s->opt[OPT_BIT_DEPTH].size = sizeof (SANE_Word);
  s->opt[OPT_BIT_DEPTH].constraint.word_list = 0;
  s->opt[OPT_BIT_DEPTH].constraint.word_list = s->bpp_list;
  RIE (create_bpp_list (s, s->dev->model->bpp_gray_values));
  s->val[OPT_BIT_DEPTH].w = 8;
  if (s->opt[OPT_BIT_DEPTH].constraint.word_list[0] < 2)
    DISABLE (OPT_BIT_DEPTH);

  /* resolution */
  for (count = 0; model->ydpi_values[count] != 0; count++)
    ;
  dpi_list = malloc ((count + 1) * sizeof (SANE_Word));
  if (!dpi_list)
    return SANE_STATUS_NO_MEM;
  dpi_list[0] = count;
  for (count = 0; model->ydpi_values[count] != 0; count++)
    dpi_list[dpi_list[0] - count] = model->ydpi_values[count];
  s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
  s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
  s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
  s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
  s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
  s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
  s->opt[OPT_RESOLUTION].constraint.word_list = dpi_list;
  s->val[OPT_RESOLUTION].w = 300;

  /* backtrack */
  s->opt[OPT_BACKTRACK].name = SANE_NAME_BACKTRACK;
  s->opt[OPT_BACKTRACK].title = SANE_TITLE_BACKTRACK;
  s->opt[OPT_BACKTRACK].desc = SANE_DESC_BACKTRACK;
  s->opt[OPT_BACKTRACK].type = SANE_TYPE_BOOL;
  s->val[OPT_BACKTRACK].w = SANE_FALSE;

  /* "Debug" group: */
  s->opt[OPT_DEBUG_GROUP].title = SANE_I18N ("Debugging Options");
  s->opt[OPT_DEBUG_GROUP].desc = "";
  s->opt[OPT_DEBUG_GROUP].type = SANE_TYPE_GROUP;
  s->opt[OPT_DEBUG_GROUP].size = 0;
  s->opt[OPT_DEBUG_GROUP].cap = 0;
  s->opt[OPT_DEBUG_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
  if (!debug_options)
    DISABLE (OPT_DEBUG_GROUP);

  /* auto warmup */
  s->opt[OPT_AUTO_WARMUP].name = "auto-warmup";
  s->opt[OPT_AUTO_WARMUP].title = SANE_I18N ("Automatic warmup");
  s->opt[OPT_AUTO_WARMUP].desc =
    SANE_I18N ("Warm-up until the lamp's brightness is constant "
               "instead of insisting on 60 seconds warm-up time.");
  s->opt[OPT_AUTO_WARMUP].type = SANE_TYPE_BOOL;
  s->opt[OPT_AUTO_WARMUP].unit = SANE_UNIT_NONE;
  s->opt[OPT_AUTO_WARMUP].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_AUTO_WARMUP].w = SANE_TRUE;
  if ((s->dev->model->is_cis
       && !(s->dev->model->flags & GT68XX_FLAG_CIS_LAMP)) || !debug_options)
    DISABLE (OPT_AUTO_WARMUP);

  /* full scan */
  s->opt[OPT_FULL_SCAN].name = "full-scan";
  s->opt[OPT_FULL_SCAN].title = SANE_I18N ("Full scan");
  s->opt[OPT_FULL_SCAN].desc =
    SANE_I18N ("Scan the complete scanning area including calibration strip. "
               "Be careful. Don't select the full height. For testing only.");
  s->opt[OPT_FULL_SCAN].type = SANE_TYPE_BOOL;
  s->opt[OPT_FULL_SCAN].unit = SANE_UNIT_NONE;
  s->opt[OPT_FULL_SCAN].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_FULL_SCAN].w = SANE_FALSE;
  if (!debug_options)
    DISABLE (OPT_FULL_SCAN);

  /* coarse calibration */
  s->opt[OPT_COARSE_CAL].name = "coarse-calibration";
  s->opt[OPT_COARSE_CAL].title = SANE_I18N ("Coarse calibration");
  s->opt[OPT_COARSE_CAL].desc =
    SANE_I18N ("Setup gain and offset for scanning automatically. If this "
               "option is disabled, options for setting the analog frontend "
               "parameters manually are provided. This option is enabled "
               "by default. For testing only.");
  s->opt[OPT_COARSE_CAL].type = SANE_TYPE_BOOL;
  s->opt[OPT_COARSE_CAL].unit = SANE_UNIT_NONE;
  s->opt[OPT_COARSE_CAL].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_COARSE_CAL].w = SANE_TRUE;
  if (!debug_options)
    DISABLE (OPT_COARSE_CAL);
  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
    {
      s->val[OPT_COARSE_CAL].w = SANE_FALSE;
      DISABLE (OPT_COARSE_CAL);
    }

  /* coarse calibration only once */
  s->opt[OPT_COARSE_CAL_ONCE].name = "coarse-calibration-once";
  s->opt[OPT_COARSE_CAL_ONCE].title =
    SANE_I18N ("Coarse calibration for first scan only");
  s->opt[OPT_COARSE_CAL_ONCE].desc =
    SANE_I18N ("Coarse calibration is only done for the first scan. Works "
               "with most scanners and can save scanning time. If the image "
               "brightness is different with each scan, disable this option. "
               "For testing only.");
  s->opt[OPT_COARSE_CAL_ONCE].type = SANE_TYPE_BOOL;
  s->opt[OPT_COARSE_CAL_ONCE].unit = SANE_UNIT_NONE;
  s->opt[OPT_COARSE_CAL_ONCE].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_COARSE_CAL_ONCE].w = SANE_FALSE;
  if (!debug_options)
    DISABLE (OPT_COARSE_CAL_ONCE);
  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
    DISABLE (OPT_COARSE_CAL_ONCE);

  /* calibration */
  s->opt[OPT_QUALITY_CAL].name = SANE_NAME_QUALITY_CAL;
  s->opt[OPT_QUALITY_CAL].title = SANE_TITLE_QUALITY_CAL;
  s->opt[OPT_QUALITY_CAL].desc = SANE_TITLE_QUALITY_CAL;
  s->opt[OPT_QUALITY_CAL].type = SANE_TYPE_BOOL;
  s->opt[OPT_QUALITY_CAL].unit = SANE_UNIT_NONE;
  s->opt[OPT_QUALITY_CAL].constraint_type = SANE_CONSTRAINT_NONE;
  s->val[OPT_QUALITY_CAL].w = SANE_TRUE;
  if (!debug_options)
    DISABLE (OPT_QUALITY_CAL);
  /* we disable image correction for scanners that can't calibrate */
  if ((s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
    &&(!(s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)))
    {
      s->val[OPT_QUALITY_CAL].w = SANE_FALSE;
      DISABLE (OPT_QUALITY_CAL);
    }

  /* backtrack lines */
  s->opt[OPT_BACKTRACK_LINES].name = "backtrack-lines";
  s->opt[OPT_BACKTRACK_LINES].title = SANE_I18N ("Backtrack lines");
  s->opt[OPT_BACKTRACK_LINES].desc =
    SANE_I18N ("Number of lines the scan slider moves back when backtracking "
               "occurs. That happens when the scanner scans faster than the "
               "computer can receive the data. Low values cause faster scans "
               "but increase the risk of omitting lines.");
  s->opt[OPT_BACKTRACK_LINES].type = SANE_TYPE_INT;
  s->opt[OPT_BACKTRACK_LINES].unit = SANE_UNIT_NONE;
  s->opt[OPT_BACKTRACK_LINES].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_BACKTRACK_LINES].constraint.range = &u8_range;
  if (s->dev->model->is_cis && !(s->dev->model->flags & GT68XX_FLAG_SHEET_FED))
    s->val[OPT_BACKTRACK_LINES].w = 0x10;
  else
    s->val[OPT_BACKTRACK_LINES].w = 0x3f;
  if (!debug_options)
    DISABLE (OPT_BACKTRACK_LINES);

  /* "Enhancement" group: */
  s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
  s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
  s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
  s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
  s->opt[OPT_ENHANCEMENT_GROUP].size = 0;
  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;

  /* internal gamma value */
  s->opt[OPT_GAMMA_VALUE].name = "gamma-value";
  s->opt[OPT_GAMMA_VALUE].title = SANE_I18N ("Gamma value");
  s->opt[OPT_GAMMA_VALUE].desc =
    SANE_I18N ("Sets the gamma value of all channels.");
  s->opt[OPT_GAMMA_VALUE].type = SANE_TYPE_FIXED;
  s->opt[OPT_GAMMA_VALUE].unit = SANE_UNIT_NONE;
  s->opt[OPT_GAMMA_VALUE].constraint_type = SANE_CONSTRAINT_RANGE;
  s->opt[OPT_GAMMA_VALUE].constraint.range = &gamma_range;
  s->opt[OPT_GAMMA_VALUE].cap |= SANE_CAP_EMULATED;
  s->val[OPT_GAMMA_VALUE].w = s->dev->gamma_value;

  /* 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 = &u8_range;
  s->val[OPT_THRESHOLD].w = 128;
  DISABLE (OPT_THRESHOLD);

  /* "Geometry" group: */
  s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("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].size = 0;
  s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;

  x_range.max = model->x_size;
  y_range.max = model->y_size;

  /* 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 = &x_range;
  s->val[OPT_TL_X].w = 0;

  /* 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 = &y_range;
  s->val[OPT_TL_Y].w = 0;

  /* bottom-right x */
  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
  s->opt[OPT_BR_X].type = SANE_TYPE_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 = &x_range;
  s->val[OPT_BR_X].w = 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 = &y_range;
  s->val[OPT_BR_Y].w = y_range.max;

  /* sensor group */
  s->opt[OPT_SENSOR_GROUP].name = SANE_NAME_SENSORS;
  s->opt[OPT_SENSOR_GROUP].title = SANE_TITLE_SENSORS;
  s->opt[OPT_SENSOR_GROUP].desc = SANE_DESC_SENSORS;
  s->opt[OPT_SENSOR_GROUP].type = SANE_TYPE_GROUP;
  s->opt[OPT_SENSOR_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
  
  /* calibration needed */
  s->opt[OPT_NEED_CALIBRATION_SW].name = "need-calibration";
  s->opt[OPT_NEED_CALIBRATION_SW].title = SANE_I18N ("Need calibration");
  s->opt[OPT_NEED_CALIBRATION_SW].desc = SANE_I18N ("The scanner needs calibration for the current settings");
  s->opt[OPT_NEED_CALIBRATION_SW].type = SANE_TYPE_BOOL;
  s->opt[OPT_NEED_CALIBRATION_SW].unit = SANE_UNIT_NONE;
  if (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
    s->opt[OPT_NEED_CALIBRATION_SW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
  else
    s->opt[OPT_NEED_CALIBRATION_SW].cap = SANE_CAP_INACTIVE;
  s->val[OPT_NEED_CALIBRATION_SW].b = 0;

  /* document present sensor */
  s->opt[OPT_PAGE_LOADED_SW].name = SANE_NAME_PAGE_LOADED;
  s->opt[OPT_PAGE_LOADED_SW].title = SANE_TITLE_PAGE_LOADED;
  s->opt[OPT_PAGE_LOADED_SW].desc = SANE_DESC_PAGE_LOADED;
  s->opt[OPT_PAGE_LOADED_SW].type = SANE_TYPE_BOOL;
  s->opt[OPT_PAGE_LOADED_SW].unit = SANE_UNIT_NONE;
  if (s->dev->model->command_set->document_present)
    s->opt[OPT_PAGE_LOADED_SW].cap =
      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
  else
    s->opt[OPT_PAGE_LOADED_SW].cap = SANE_CAP_INACTIVE;
  s->val[OPT_PAGE_LOADED_SW].b = 0;

  /* button group */
  s->opt[OPT_BUTTON_GROUP].name = "Buttons";
  s->opt[OPT_BUTTON_GROUP].title = SANE_I18N ("Buttons");
  s->opt[OPT_BUTTON_GROUP].desc = SANE_I18N ("Buttons");
  s->opt[OPT_BUTTON_GROUP].type = SANE_TYPE_GROUP;
  s->opt[OPT_BUTTON_GROUP].constraint_type = SANE_CONSTRAINT_NONE;

  /* calibrate button */
  s->opt[OPT_CALIBRATE].name = "calibrate";
  s->opt[OPT_CALIBRATE].title = SANE_I18N ("Calibrate");
  s->opt[OPT_CALIBRATE].desc =
    SANE_I18N ("Start calibration using special sheet");
  s->opt[OPT_CALIBRATE].type = SANE_TYPE_BUTTON;
  s->opt[OPT_CALIBRATE].unit = SANE_UNIT_NONE;
  if (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
  s->opt[OPT_CALIBRATE].cap =
      SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED |
      SANE_CAP_AUTOMATIC;
  else
    s->opt[OPT_CALIBRATE].cap = SANE_CAP_INACTIVE;
  s->val[OPT_CALIBRATE].b = 0;

  /* clear calibration cache button */
  s->opt[OPT_CLEAR_CALIBRATION].name = "clear";
  s->opt[OPT_CLEAR_CALIBRATION].title = SANE_I18N ("Clear calibration");
  s->opt[OPT_CLEAR_CALIBRATION].desc = SANE_I18N ("Clear calibration cache");
  s->opt[OPT_CLEAR_CALIBRATION].type = SANE_TYPE_BUTTON;
  s->opt[OPT_CLEAR_CALIBRATION].unit = SANE_UNIT_NONE;
  if (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
  s->opt[OPT_CLEAR_CALIBRATION].cap =
    SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED |
    SANE_CAP_AUTOMATIC;
  else
    s->opt[OPT_CLEAR_CALIBRATION].cap = SANE_CAP_INACTIVE;
  s->val[OPT_CLEAR_CALIBRATION].b = 0;


  RIE (calc_parameters (s));

  DBG (5, "init_options: exit\n");
  return SANE_STATUS_GOOD;
}

static SANE_Status
attach (SANE_String_Const devname, GT68xx_Device ** devp, SANE_Bool may_wait)
{
  GT68xx_Device *dev;
  SANE_Status status;

  DBG (5, "attach: start: devp %s NULL, may_wait = %d\n", devp ? "!=" : "==",
       may_wait);
  if (!devname)
    {
      DBG (1, "attach: devname == NULL\n");
      return SANE_STATUS_INVAL;
    }

  for (dev = first_dev; dev; dev = dev->next)
    {
      if (strcmp (dev->file_name, devname) == 0)
        {
          if (devp)
            *devp = dev;
          dev->missing = SANE_FALSE;
          DBG (4, "attach: device `%s' was already in device list\n",
               devname);
          return SANE_STATUS_GOOD;
        }
    }

  DBG (4, "attach: trying to open device `%s'\n", devname);
  RIE (gt68xx_device_new (&dev));
  status = gt68xx_device_open (dev, devname);
  if (status == SANE_STATUS_GOOD)
    DBG (4, "attach: device `%s' successfully opened\n", devname);
  else
    {
      DBG (4, "attach: couldn't open device `%s': %s\n", devname,
           sane_strstatus (status));
      gt68xx_device_free (dev);
      if (devp)
        *devp = 0;
      return status;
    }

  if (!gt68xx_device_is_configured (dev))
    {
      GT68xx_Model *model = NULL;
      DBG (2, "attach: Warning: device `%s' is not listed in device table\n",
           devname);
      DBG (2,
           "attach: If you have manually added it, use override in gt68xx.conf\n");
      gt68xx_device_get_model ("unknown-scanner", &model);
      status = gt68xx_device_set_model (dev, model);
      if (status != SANE_STATUS_GOOD)
        {
          DBG (4, "attach: couldn't set model: %s\n",
               sane_strstatus (status));
          gt68xx_device_free (dev);
          if (devp)
            *devp = 0;
          return status;
        }
      dev->manual_selection = SANE_TRUE;
    }

  dev->file_name = strdup (devname);
  dev->missing = SANE_FALSE;
  if (!dev->file_name)
    return SANE_STATUS_NO_MEM;
  DBG (2, "attach: found %s flatbed scanner %s at %s\n", dev->model->vendor,
       dev->model->model, dev->file_name);
  ++num_devices;
  dev->next = first_dev;
  first_dev = dev;

  if (devp)
    *devp = dev;
  gt68xx_device_close (dev);
  DBG (5, "attach: exit\n");
  return SANE_STATUS_GOOD;
}

static SANE_Status
attach_one_device (SANE_String_Const devname)
{
  GT68xx_Device *dev;
  SANE_Status status;

  RIE (attach (devname, &dev, SANE_FALSE));

  if (dev)
    {
      /* Keep track of newly attached devices so we can set options as
         necessary.  */
      if (new_dev_len >= new_dev_alloced)
        {
          new_dev_alloced += 4;
          if (new_dev)
            new_dev =
              realloc (new_dev, new_dev_alloced * sizeof (new_dev[0]));
          else
            new_dev = malloc (new_dev_alloced * sizeof (new_dev[0]));
          if (!new_dev)
            {
              DBG (1, "attach_one_device: out of memory\n");
              return SANE_STATUS_NO_MEM;
            }
        }
      new_dev[new_dev_len++] = dev;
    }
  return SANE_STATUS_GOOD;
}

#if defined(_WIN32) || defined(HAVE_OS2_H)
# define PATH_SEP       "\\"
#else
# define PATH_SEP       "/"
#endif

static SANE_Status
download_firmware_file (GT68xx_Device * dev)
{
  SANE_Status status = SANE_STATUS_GOOD;
  SANE_Byte *buf = NULL;
  int size = -1;
  SANE_Char filename[PATH_MAX], dirname[PATH_MAX], basename[PATH_MAX];
  FILE *f;

  if (strncmp (dev->model->firmware_name, PATH_SEP, 1) != 0)
    {
      /* probably filename only */
      snprintf (filename, PATH_MAX, "%s%s%s%s%s%s%s",
                STRINGIFY (PATH_SANE_DATA_DIR),
                PATH_SEP, "sane", PATH_SEP, "gt68xx", PATH_SEP,
                dev->model->firmware_name);
      snprintf (dirname, PATH_MAX, "%s%s%s%s%s",
                STRINGIFY (PATH_SANE_DATA_DIR),
                PATH_SEP, "sane", PATH_SEP, "gt68xx");
      strncpy (basename, dev->model->firmware_name, PATH_MAX);
    }
  else
    {
      /* absolute path */
      char *pos;
      strncpy (filename, dev->model->firmware_name, PATH_MAX);
      strncpy (dirname, dev->model->firmware_name, PATH_MAX);
      pos = strrchr (dirname, PATH_SEP[0]);
      if (pos)
        pos[0] = '\0';
      strncpy (basename, pos + 1, PATH_MAX);
    }

  /* first, try to open with exact case */
  DBG (5, "download_firmware: trying %s\n", filename);
  f = fopen (filename, "rb");
  if (!f)
    {
      /* and now any case */
      DIR *dir;
      struct dirent *direntry;

      DBG (5,
           "download_firmware_file: Couldn't open firmware file `%s': %s\n",
           filename, strerror (errno));

      dir = opendir (dirname);
      if (!dir)
        {
          DBG (5, "download_firmware: couldn't open directory `%s': %s\n",
               dirname, strerror (errno));
          status = SANE_STATUS_INVAL;
        }
      if (status == SANE_STATUS_GOOD)
        {
          do
            {
              direntry = readdir (dir);
              if (direntry
                  && (strncasecmp (direntry->d_name, basename, PATH_MAX) ==
                      0))
                {
                  snprintf (filename, PATH_MAX, "%s%s%s",
                            dirname, PATH_SEP, direntry->d_name);
                  break;
                }
            }
          while (direntry != 0);
          if (direntry == 0)
            {
              DBG (5, "download_firmware: file `%s' not found\n", filename);
              status = SANE_STATUS_INVAL;
            }
          closedir (dir);
        }
      if (status == SANE_STATUS_GOOD)
        {
          DBG (5, "download_firmware: trying %s\n", filename);
          f = fopen (filename, "rb");
          if (!f)
            {
              DBG (5,
                   "download_firmware_file: Couldn't open firmware file `%s': %s\n",
                   filename, strerror (errno));
              status = SANE_STATUS_INVAL;
            }
        }

      if (status != SANE_STATUS_GOOD)
        {
          DBG (0, "Couldn't open firmware file (`%s'): %s\n",
               filename, strerror (errno));
        }
    }

  if (status == SANE_STATUS_GOOD)
    {
      fseek (f, 0, SEEK_END);
      size = ftell (f);
      fseek (f, 0, SEEK_SET);
      if (size == -1)
        {
          DBG (1, "download_firmware_file: error getting size of "
               "firmware file \"%s\": %s\n", filename, strerror (errno));
          status = SANE_STATUS_INVAL;
        }
    }

  if (status == SANE_STATUS_GOOD)
    {
      DBG (5, "firmware size: %d\n", size);
      buf = (SANE_Byte *) malloc (size);
      if (!buf)
        {
          DBG (1, "download_firmware_file: cannot allocate %d bytes "
               "for firmware\n", size);
          status = SANE_STATUS_NO_MEM;
        }
    }

  if (status == SANE_STATUS_GOOD)
    {
      int bytes_read = fread (buf, 1, size, f);
      if (bytes_read != size)
        {
          DBG (1, "download_firmware_file: problem reading firmware "
               "file \"%s\": %s\n", filename, strerror (errno));
          status = SANE_STATUS_INVAL;
        }
    }

  if (f)
    fclose (f);

  if (status == SANE_STATUS_GOOD)
    {
      status = gt68xx_device_download_firmware (dev, buf, size);
      if (status != SANE_STATUS_GOOD)
        {
          DBG (1, "download_firmware_file: firmware download failed: %s\n",
               sane_strstatus (status));
        }
    }

  if (buf)
    free (buf);

  return status;
}

/** probe for gt68xx devices
 * This function scan usb and try to attached to scanner
 * configured in gt68xx.conf .
 */
static SANE_Status probe_gt68xx_devices(void)
{
  SANE_Char line[PATH_MAX];
  SANE_Char *word;
  SANE_String_Const cp;
  SANE_Int linenumber;
  GT68xx_Device *dev;
  FILE *fp;

  /* set up for no new devices detected at first */
  new_dev = 0;
  new_dev_len = 0;
  new_dev_alloced = 0;

  /* mark already detected devices as missing, during device probe
   * detected devices will clear this flag */
  dev = first_dev;
  while(dev!=NULL)
    {
      dev->missing = SANE_TRUE;
      dev = dev->next;
    }

  fp = sanei_config_open (GT68XX_CONFIG_FILE);
  if (!fp)
    {
      /* default to /dev/usb/scanner instead of insisting on config file */
      DBG (3, "sane_init: couldn't open config file `%s': %s. Using "
           "/dev/usb/scanner directly\n", GT68XX_CONFIG_FILE,
           strerror (errno));
      attach ("/dev/usb/scanner", 0, SANE_FALSE);
      return SANE_STATUS_GOOD;
    }

  little_endian = calc_little_endian ();
  DBG (5, "sane_init: %s endian machine\n", little_endian ? "little" : "big");

  linenumber = 0;
  DBG (4, "sane_init: reading config file `%s'\n", GT68XX_CONFIG_FILE);
  while (sanei_config_read (line, sizeof (line), fp))
    {
      word = 0;
      linenumber++;

      cp = sanei_config_get_string (line, &word);
      if (!word || cp == line)
        {
          DBG (6, "sane_init: config file line %d: ignoring empty line\n",
               linenumber);
          if (word)
            free (word);
          continue;
        }
      if (word[0] == '#')
        {
          DBG (6, "sane_init: config file line %d: ignoring comment line\n",
               linenumber);
          free (word);
          continue;
        }

      if (strcmp (word, "firmware") == 0)
        {
          free (word);
          word = 0;
          cp = sanei_config_get_string (cp, &word);
          if (word)
            {
              int i;
              for (i = 0; i < new_dev_len; i++)
                {
                  new_dev[i]->model->firmware_name = word;
                  DBG (5, "sane_init: device %s: firmware will be loaded "
                       "from %s\n", new_dev[i]->model->name,
                       new_dev[i]->model->firmware_name);
                }
              if (i == 0)
                DBG (5, "sane_init: firmware %s can't be loaded, set device "
                     "first\n", word);
            }
          else
            {
              DBG (3, "sane_init: option `firmware' needs a parameter\n");
            }
        }
      else if (strcmp (word, "vendor") == 0)
        {
          free (word);
          word = 0;
          cp = sanei_config_get_string (cp, &word);
          if (word)
            {
              int i;

              for (i = 0; i < new_dev_len; i++)
                {
                  new_dev[i]->model->vendor = word;
                  DBG (5, "sane_init: device %s: vendor name set to %s\n",
                       new_dev[i]->model->name, new_dev[i]->model->vendor);
                }
              if (i == 0)
                DBG (5, "sane_init: can't set vendor name %s, set device "
                     "first\n", word);
            }
          else
            {
              DBG (3, "sane_init: option `vendor' needs a parameter\n");
            }
        }
      else if (strcmp (word, "model") == 0)
        {
          free (word);
          word = 0;
          cp = sanei_config_get_string (cp, &word);
          if (word)
            {
              int i;
              for (i = 0; i < new_dev_len; i++)
                {
                  new_dev[i]->model->model = word;
                  DBG (5, "sane_init: device %s: model name set to %s\n",
                       new_dev[i]->model->name, new_dev[i]->model->model);
                }
              if (i == 0)
                DBG (5, "sane_init: can't set model name %s, set device "
                     "first\n", word);
              free (word);
            }
          else
            {
              DBG (3, "sane_init: option `model' needs a parameter\n");
            }
        }
      else if (strcmp (word, "override") == 0)
        {
          free (word);
          word = 0;
          cp = sanei_config_get_string (cp, &word);
          if (word)
            {
              int i;
              for (i = 0; i < new_dev_len; i++)
                {
                  SANE_Status status;
                  GT68xx_Device *dev = new_dev[i];
                  GT68xx_Model *model;
                  if (gt68xx_device_get_model (word, &model) == SANE_TRUE)
                    {
                      status = gt68xx_device_set_model (dev, model);
                      if (status != SANE_STATUS_GOOD)
                        DBG (1, "sane_init: couldn't override model: %s\n",
                             sane_strstatus (status));
                      else
                        DBG (5, "sane_init: new model set to %s\n",
                             dev->model->name);
                    }
                  else
                    {
                      DBG (1, "sane_init: override: model %s not found\n",
                           word);
                    }
                }
              if (i == 0)
                DBG (5, "sane_init: can't override model to %s, set device "
                     "first\n", word);
              free (word);
            }
          else
            {
              DBG (3, "sane_init: option `override' needs a parameter\n");
            }
        }
      else if (strcmp (word, "afe") == 0)
        {
          GT68xx_AFE_Parameters afe = {0, 0, 0, 0, 0, 0};
          SANE_Status status;

          free (word);
          word = 0;

          status = get_afe_values (cp, &afe);
          if (status == SANE_STATUS_GOOD)
            {
              int i;
              for (i = 0; i < new_dev_len; i++)
                {
                  new_dev[i]->model->afe_params = afe;
                  DBG (5, "sane_init: device %s: setting new afe values\n",
                       new_dev[i]->model->name);
                }
              if (i == 0)
                DBG (5,
                     "sane_init: can't set afe values, set device first\n");
            }
          else
            DBG (3, "sane_init: can't set afe values\n");
        }
      else
        {
          new_dev_len = 0;
          DBG (4, "sane_init: config file line %d: trying to attach `%s'\n",
               linenumber, line);
          sanei_usb_attach_matching_devices (line, attach_one_device);
          if (word)
            free (word);
          word = 0;
        }
    }

  if (new_dev_alloced > 0)
    {
      new_dev_len = new_dev_alloced = 0;
      free (new_dev);
    }

  fclose (fp);
  return SANE_STATUS_GOOD;
}

/* -------------------------- SANE API functions ------------------------- */

SANE_Status
sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
{
  SANE_Status status;

  DBG_INIT ();
#ifdef DBG_LEVEL
  if (DBG_LEVEL > 0)
    {
      DBG (5, "sane_init: debug options are enabled, handle with care\n");
      debug_options = SANE_TRUE;
    }
#endif
  DBG (2, "SANE GT68xx backend version %d.%d build %d from %s\n", SANE_CURRENT_MAJOR,
       V_MINOR, BUILD, PACKAGE_STRING);

  if (version_code)
    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD);

  DBG (5, "sane_init: authorize %s null\n", authorize ? "!=" : "==");

  sanei_usb_init ();

  num_devices = 0;
  first_dev = 0;
  first_handle = 0;
  devlist = 0;
  new_dev = 0;
  new_dev_len = 0;
  new_dev_alloced = 0;

  status = probe_gt68xx_devices ();
  DBG (5, "sane_init: exit\n");

  return status;
}

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

  DBG (5, "sane_exit: start\n");
  sanei_usb_exit();
  for (dev = first_dev; dev; dev = next)
    {
      next = dev->next;
      gt68xx_device_free (dev);
    }
  first_dev = 0;
  first_handle = 0;
  if (devlist)
    free (devlist);
  devlist = 0;

  DBG (5, "sane_exit: exit\n");
}

SANE_Status
sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
{
  GT68xx_Device *dev;
  SANE_Int dev_num;

  DBG (5, "sane_get_devices: start: local_only = %s\n",
       local_only == SANE_TRUE ? "true" : "false");

  /* hot-plug case : detection of newly connected scanners */
  sanei_usb_scan_devices ();
  probe_gt68xx_devices ();

  if (devlist)
    free (devlist);

  devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
  if (!devlist)
    return SANE_STATUS_NO_MEM;

  dev_num = 0;
  dev = first_dev;
  while(dev!=NULL)
    {
      SANE_Device *sane_device;

      /* don't return devices that have been unplugged */
      if(dev->missing==SANE_FALSE)
        {
          sane_device = malloc (sizeof (*sane_device));
          if (!sane_device)
            return SANE_STATUS_NO_MEM;
          sane_device->name = dev->file_name;
          sane_device->vendor = dev->model->vendor;
          sane_device->model = dev->model->model;
          sane_device->type = strdup ("flatbed scanner");
          devlist[dev_num] = sane_device;
          dev_num++;
        }

      /* next device */
      dev = dev->next;
    }
  devlist[dev_num] = 0;

  *device_list = devlist;

  DBG (5, "sane_get_devices: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
sane_open (SANE_String_Const devicename, SANE_Handle * handle)
{
  GT68xx_Device *dev;
  SANE_Status status;
  GT68xx_Scanner *s;
  SANE_Bool power_ok;

  DBG (5, "sane_open: start (devicename = `%s')\n", devicename);

  if (devicename[0])
    {
      /* test for gt68xx short hand name */
      if(strcmp(devicename,"gt68xx")!=0)
        {
          for (dev = first_dev; dev; dev = dev->next)
            if (strcmp (dev->file_name, devicename) == 0)
              break;

          if (!dev)
            {
              DBG (5, "sane_open: couldn't find `%s' in devlist, trying attach\n",
                   devicename);
              RIE (attach (devicename, &dev, SANE_TRUE));
            }
          else
            DBG (5, "sane_open: found `%s' in devlist\n", dev->model->name);
        }
      else
        {
          dev = first_dev;
          if (dev)
            {
              devicename = dev->file_name;
              DBG (5, "sane_open: default empty devicename, using first device `%s'\n", devicename);
            }
        }
    }
  else
    {
      /* empty devicname -> use first device */
      dev = first_dev;
      if (dev)
        {
          devicename = dev->file_name;
          DBG (5, "sane_open: empty devicename, trying `%s'\n", devicename);
        }
    }

  if (!dev)
    return SANE_STATUS_INVAL;

  RIE (gt68xx_device_open (dev, devicename));
  RIE (gt68xx_device_activate (dev));

  if (dev->model->flags & GT68XX_FLAG_UNTESTED)
    {
      DBG (0, "WARNING: Your scanner is not fully supported or at least \n");
      DBG (0, "         had only limited testing. Please be careful and \n");
      DBG (0, "         report any failure/success to \n");
      DBG (0, "         sane-devel@lists.alioth.debian.org. Please provide as many\n");
      DBG (0, "         details as possible, e.g. the exact name of your\n");
      DBG (0, "         scanner and what does (not) work.\n");
    }

  if (dev->manual_selection)
    {
      DBG (0, "WARNING: You have manually added the ids of your scanner \n");
      DBG (0,
           "         to gt68xx.conf. Please use an appropriate override \n");
      DBG (0,
           "         for your scanner. Use extreme care and switch off \n");
      DBG (0,
           "         the scanner immediately if you hear unusual noise. \n");
      DBG (0, "         Please report any success to \n");
      DBG (0, "         sane-devel@lists.alioth.debian.org. Please provide as many\n");
      DBG (0, "         details as possible, e.g. the exact name of your\n");
      DBG (0, "         scanner, ids, settings etc.\n");

      if (strcmp (dev->model->name, "unknown-scanner") == 0)
        {
          GT68xx_USB_Device_Entry *entry;

          DBG (0,
               "ERROR: You haven't chosen an override in gt68xx.conf. Please use \n");
          DBG (0, "       one of the following: \n");

          for (entry = gt68xx_usb_device_list; entry->model; ++entry)
            {
              if (strcmp (entry->model->name, "unknown-scanner") != 0)
                DBG (0, "       %s\n", entry->model->name);
            }
          return SANE_STATUS_UNSUPPORTED;
        }
    }

  /* The firmware check is disabled by default because it may confuse
     some scanners: So the firmware is loaded everytime. */
#if 0
  RIE (gt68xx_device_check_firmware (dev, &firmware_loaded));
  firmware_loaded = SANE_FALSE;
  if (firmware_loaded)
    DBG (3, "sane_open: firmware already loaded, skipping load\n");
  else
    RIE (download_firmware_file (dev));
  /*  RIE (gt68xx_device_check_firmware (dev, &firmware_loaded)); */
  if (!firmware_loaded)
    {
      DBG (1, "sane_open: firmware still not loaded? Proceeding anyway\n");
      /* return SANE_STATUS_IO_ERROR; */
    }
#else
  RIE (download_firmware_file (dev));
#endif

  RIE (gt68xx_device_get_id (dev));

  if (!(dev->model->flags & GT68XX_FLAG_NO_STOP))
    RIE (gt68xx_device_stop_scan (dev));

  RIE (gt68xx_device_get_power_status (dev, &power_ok));
  if (power_ok)
    {
      DBG (5, "sane_open: power ok\n");
    }
  else
    {
      DBG (0, "sane_open: power control failure: check power plug!\n");
      return SANE_STATUS_IO_ERROR;
    }

  RIE (gt68xx_scanner_new (dev, &s));
  RIE (gt68xx_device_lamp_control (s->dev, SANE_TRUE, SANE_FALSE));
  gettimeofday (&s->lamp_on_time, 0);

  /* insert newly opened handle into list of open handles: */
  s->next = first_handle;
  first_handle = s;
  *handle = s;
  s->scanning = SANE_FALSE;
  s->first_scan = SANE_TRUE;
  s->gamma_table = 0;
  s->calibrated = SANE_FALSE;
  RIE (init_options (s));
  dev->gray_mode_color = 0x02;

  /* try to restore calibration from file */
  if((s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE))
    {
      /* error restoring calibration is non blocking */
      gt68xx_read_calibration(s);
    }

  DBG (5, "sane_open: exit\n");

  return SANE_STATUS_GOOD;
}

void
sane_close (SANE_Handle handle)
{
  GT68xx_Scanner *prev, *s;
  GT68xx_Device *dev;

  DBG (5, "sane_close: start\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 (5, "close: invalid handle %p\n", handle);
      return;                   /* oops, not a handle we know about */
    }

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

  if (s->val[OPT_LAMP_OFF_AT_EXIT].w == SANE_TRUE)
    gt68xx_device_lamp_control (s->dev, SANE_FALSE, SANE_FALSE);

  dev = s->dev;
  
  free (s->val[OPT_MODE].s);
  free (s->val[OPT_GRAY_MODE_COLOR].s);
  free (s->val[OPT_SOURCE].s);
  free (dev->file_name);
  free ((void *)(size_t)s->opt[OPT_RESOLUTION].constraint.word_list);

  gt68xx_scanner_free (s);
  
  gt68xx_device_fix_descriptor (dev);

  gt68xx_device_deactivate (dev);
  gt68xx_device_close (dev);

  DBG (5, "sane_close: exit\n");
}

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

  if ((unsigned) option >= NUM_OPTIONS)
    return 0;
  DBG (5, "sane_get_option_descriptor: option = %s (%d)\n",
       s->opt[option].name, option);
  return s->opt + option;
}

SANE_Status
sane_control_option (SANE_Handle handle, SANE_Int option,
                     SANE_Action action, void *val, SANE_Int * info)
{
  GT68xx_Scanner *s = handle;
  SANE_Status status = SANE_STATUS_GOOD;
  SANE_Word cap;
  SANE_Int myinfo = 0;

  DBG (5, "sane_control_option: start: action = %s, option = %s (%d)\n",
       (action == SANE_ACTION_GET_VALUE) ? "get" :
       (action == SANE_ACTION_SET_VALUE) ? "set" :
       (action == SANE_ACTION_SET_AUTO) ? "set_auto" : "unknown",
       s->opt[option].name, option);

  if (info)
    *info = 0;

  if (s->scanning)
    {
      DBG (1, "sane_control_option: don't call this function while "
           "scanning (option = %s (%d))\n", s->opt[option].name, option);

      return SANE_STATUS_DEVICE_BUSY;
    }
  if (option >= NUM_OPTIONS || option < 0)
    {
      DBG (1, "sane_control_option: option %d >= NUM_OPTIONS || option < 0\n",
           option);
      return SANE_STATUS_INVAL;
    }

  cap = s->opt[option].cap;

  if (!SANE_OPTION_IS_ACTIVE (cap))
    {
      DBG (2, "sane_control_option: option %d is inactive\n", option);
      return SANE_STATUS_INVAL;
    }

  if (action == SANE_ACTION_GET_VALUE)
    {
      switch (option)
        {
          /* word options: */
        case OPT_NUM_OPTS:
        case OPT_RESOLUTION:
        case OPT_BIT_DEPTH:
        case OPT_FULL_SCAN:
        case OPT_COARSE_CAL:
        case OPT_COARSE_CAL_ONCE:
        case OPT_QUALITY_CAL:
        case OPT_BACKTRACK:
        case OPT_BACKTRACK_LINES:
        case OPT_PREVIEW:
        case OPT_LAMP_OFF_AT_EXIT:
        case OPT_AUTO_WARMUP:
        case OPT_GAMMA_VALUE:
        case OPT_THRESHOLD:
        case OPT_TL_X:
        case OPT_TL_Y:
        case OPT_BR_X:
        case OPT_BR_Y:
          *(SANE_Word *) val = s->val[option].w;
          break;
          /* string options: */
        case OPT_MODE:
        case OPT_GRAY_MODE_COLOR:
        case OPT_SOURCE:
          strcpy (val, s->val[option].s);
          break;
        case OPT_NEED_CALIBRATION_SW:
          *(SANE_Bool *) val = !s->calibrated;
          break;
        case OPT_PAGE_LOADED_SW:
          s->dev->model->command_set->document_present (s->dev, val);
          break;
        default:
          DBG (2, "sane_control_option: can't get unknown option %d\n",
               option);
        }
    }
  else if (action == SANE_ACTION_SET_VALUE)
    {
      if (!SANE_OPTION_IS_SETTABLE (cap))
        {
          DBG (2, "sane_control_option: option %d is not settable\n", option);
          return SANE_STATUS_INVAL;
        }

      status = sanei_constrain_value (s->opt + option, val, &myinfo);

      if (status != SANE_STATUS_GOOD)
        {
          DBG (2, "sane_control_option: sanei_constrain_value returned %s\n",
               sane_strstatus (status));
          return status;
        }

      switch (option)
        {
        case OPT_RESOLUTION:
        case OPT_BIT_DEPTH:
        case OPT_FULL_SCAN:
        case OPT_PREVIEW:
        case OPT_TL_X:
        case OPT_TL_Y:
        case OPT_BR_X:
        case OPT_BR_Y:
          s->val[option].w = *(SANE_Word *) val;
          RIE (calc_parameters (s));
          myinfo |= SANE_INFO_RELOAD_PARAMS;
          break;
        case OPT_LAMP_OFF_AT_EXIT:
        case OPT_AUTO_WARMUP:
        case OPT_COARSE_CAL_ONCE:
        case OPT_BACKTRACK_LINES:
        case OPT_QUALITY_CAL:
        case OPT_GAMMA_VALUE:
        case OPT_THRESHOLD:
          s->val[option].w = *(SANE_Word *) val;
          break;
        case OPT_GRAY_MODE_COLOR:
          if (strcmp (s->val[option].s, val) != 0)
            {                   /* something changed */
              if (s->val[option].s)
                free (s->val[option].s);
              s->val[option].s = strdup (val);
            }
          break;
        case OPT_SOURCE:
          if (strcmp (s->val[option].s, val) != 0)
            {                   /* something changed */
              if (s->val[option].s)
                free (s->val[option].s);
              s->val[option].s = strdup (val);
              if (strcmp (s->val[option].s, "Transparency Adapter") == 0)
                {
                  RIE (gt68xx_device_lamp_control
                       (s->dev, SANE_FALSE, SANE_TRUE));
                  x_range.max = s->dev->model->x_size_ta;
                  y_range.max = s->dev->model->y_size_ta;
                }
              else
                {
                  RIE (gt68xx_device_lamp_control
                       (s->dev, SANE_TRUE, SANE_FALSE));
                  x_range.max = s->dev->model->x_size;
                  y_range.max = s->dev->model->y_size;
                }
              s->first_scan = SANE_TRUE;
              myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
              gettimeofday (&s->lamp_on_time, 0);
            }
          break;
        case OPT_MODE:
          if (s->val[option].s)
            free (s->val[option].s);
          s->val[option].s = strdup (val);
          if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
            {
              ENABLE (OPT_THRESHOLD);
              DISABLE (OPT_BIT_DEPTH);
              ENABLE (OPT_GRAY_MODE_COLOR);
            }
          else
            {
              DISABLE (OPT_THRESHOLD);
              if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_GRAY) == 0)
                {
                  RIE (create_bpp_list (s, s->dev->model->bpp_gray_values));
                  ENABLE (OPT_GRAY_MODE_COLOR);
                }
              else
                {
                  RIE (create_bpp_list (s, s->dev->model->bpp_color_values));
                  DISABLE (OPT_GRAY_MODE_COLOR);
                }
              if (s->bpp_list[0] < 2)
                DISABLE (OPT_BIT_DEPTH);
              else
                ENABLE (OPT_BIT_DEPTH);
            }
          RIE (calc_parameters (s));
          myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
          break;

        case OPT_COARSE_CAL:
          s->val[option].w = *(SANE_Word *) val;
          if (s->val[option].w == SANE_TRUE)
            {
              ENABLE (OPT_COARSE_CAL_ONCE);
              s->first_scan = SANE_TRUE;
            }
          else
            {
              DISABLE (OPT_COARSE_CAL_ONCE);
            }
          myinfo |= SANE_INFO_RELOAD_OPTIONS;
          break;

        case OPT_BACKTRACK:
          s->val[option].w = *(SANE_Word *) val;
          if (s->val[option].w == SANE_TRUE)
            ENABLE (OPT_BACKTRACK_LINES);
          else
            DISABLE (OPT_BACKTRACK_LINES);
          myinfo |= SANE_INFO_RELOAD_OPTIONS;
          break;

        case OPT_CALIBRATE:
          status = gt68xx_sheetfed_scanner_calibrate (s);
          myinfo |= SANE_INFO_RELOAD_OPTIONS;
          break;
    
        case OPT_CLEAR_CALIBRATION:
          gt68xx_clear_calibration (s);
          myinfo |= SANE_INFO_RELOAD_OPTIONS;
          break;

        default:
          DBG (2, "sane_control_option: can't set unknown option %d\n",
               option);
        }
    }
  else
    {
      DBG (2, "sane_control_option: unknown action %d for option %d\n",
           action, option);
      return SANE_STATUS_INVAL;
    }
  if (info)
    *info = myinfo;

  DBG (5, "sane_control_option: exit\n");
  return status;
}

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

  DBG (5, "sane_get_parameters: start\n");

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

  DBG (4, "sane_get_parameters: format=%d, last_frame=%d, lines=%d\n",
       s->params.format, s->params.last_frame, s->params.lines);
  DBG (4, "sane_get_parameters: pixels_per_line=%d, bytes per line=%d\n",
       s->params.pixels_per_line, s->params.bytes_per_line);
  DBG (3, "sane_get_parameters: pixels %dx%dx%d\n",
       s->params.pixels_per_line, s->params.lines, 1 << s->params.depth);

  DBG (5, "sane_get_parameters: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
sane_start (SANE_Handle handle)
{
  GT68xx_Scanner *s = handle;
  GT68xx_Scan_Request scan_request;
  GT68xx_Scan_Parameters scan_params;
  SANE_Status status;
  SANE_Int i, gamma_size;
  unsigned int *buffer_pointers[3];
  SANE_Bool document;

  DBG (5, "sane_start: start\n");

  /* First make sure we have a current parameter set.  Some of the
     parameters will be overwritten below, but that's OK.  */
  RIE (calc_parameters (s));

  if (s->val[OPT_TL_X].w >= s->val[OPT_BR_X].w)
    {
      DBG (0, "sane_start: top left x >= bottom right x --- exiting\n");
      return SANE_STATUS_INVAL;
    }
  if (s->val[OPT_TL_Y].w >= s->val[OPT_BR_Y].w)
    {
      DBG (0, "sane_start: top left y >= bottom right y --- exiting\n");
      return SANE_STATUS_INVAL;
    }

  if (strcmp (s->val[OPT_GRAY_MODE_COLOR].s, GT68XX_COLOR_BLUE) == 0)
    s->dev->gray_mode_color = 0x01;
  else if (strcmp (s->val[OPT_GRAY_MODE_COLOR].s, GT68XX_COLOR_GREEN) == 0)
    s->dev->gray_mode_color = 0x02;
  else
    s->dev->gray_mode_color = 0x03;

  setup_scan_request (s, &scan_request);
  if (!s->first_scan && s->val[OPT_COARSE_CAL_ONCE].w == SANE_TRUE)
    s->auto_afe = SANE_FALSE;
  else
    s->auto_afe = s->val[OPT_COARSE_CAL].w;

  s->dev->gamma_value = s->val[OPT_GAMMA_VALUE].w;
  gamma_size = s->params.depth == 16 ? 65536 : 256;
  s->gamma_table = malloc (sizeof (SANE_Int) * gamma_size);
  if (!s->gamma_table)
    {
      DBG (1, "sane_start: couldn't malloc %d bytes for gamma table\n",
           gamma_size);
      return SANE_STATUS_NO_MEM;
    }
  for (i = 0; i < gamma_size; i++)
    {
      s->gamma_table[i] =
        (gamma_size - 1) * pow (((double) i + 1) / (gamma_size),
                                1.0 / SANE_UNFIX (s->dev->gamma_value)) + 0.5;
      if (s->gamma_table[i] > (gamma_size - 1))
        s->gamma_table[i] = (gamma_size - 1);
      if (s->gamma_table[i] < 0)
        s->gamma_table[i] = 0;
#if 0
      printf ("%d %d\n", i, s->gamma_table[i]);
#endif
    }

  if(!(s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE))
    {
      s->calib = s->val[OPT_QUALITY_CAL].w;
    }

  if (!(s->dev->model->flags & GT68XX_FLAG_NO_STOP))
    RIE (gt68xx_device_stop_scan (s->dev));

  if (!(s->dev->model->flags & GT68XX_FLAG_SHEET_FED))
    RIE (gt68xx_device_carriage_home (s->dev));

  gt68xx_scanner_wait_for_positioning (s);
  gettimeofday (&s->start_time, 0);

  if (s->val[OPT_BACKTRACK].w == SANE_TRUE)
    scan_request.backtrack = SANE_TRUE;
  else
    {
      if (s->val[OPT_RESOLUTION].w >= s->dev->model->ydpi_no_backtrack)
        scan_request.backtrack = SANE_FALSE;
      else
        scan_request.backtrack = SANE_TRUE;
    }

  if (scan_request.backtrack)
    scan_request.backtrack_lines = s->val[OPT_BACKTRACK_LINES].w;
  else
    scan_request.backtrack_lines = 0;

  /* don't call calibration for scanners that use sheetfed_calibrate */
  if(!(s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE))
    {
      RIE (gt68xx_scanner_calibrate (s, &scan_request));
    }
  else
    {
      s->calib = s->calibrated;
    }

  /* is possible, wait for document to be inserted before scanning */
  /* wait for 5 secondes max */
  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED
   && s->dev->model->command_set->document_present)
    {
      i=0;
      do
        {
          RIE(s->dev->model->command_set->document_present(s->dev,&document));
          if(document==SANE_FALSE)
            {
              i++;
              sleep(1);
            }
        } while ((i<5) && (document==SANE_FALSE));
      if(document==SANE_FALSE)
        {
          DBG (4, "sane_start: no doucment detected after %d s\n",i);
          return SANE_STATUS_NO_DOCS;
        }
    }

  /* some sheetfed scanners need a special operation to move
   * paper before starting real scan */
  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
    {
      RIE (gt68xx_sheetfed_move_to_scan_area (s, &scan_request));
    }

  /* restore calibration */
  if(  (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
     &&(s->calibrated == SANE_TRUE))
    {
      /* compute scan parameters */
      scan_request.calculate = SANE_TRUE;
      gt68xx_device_setup_scan (s->dev, &scan_request, SA_SCAN, &scan_params); 

      /* restore settings from calibration stored */
      memcpy(s->dev->afe,&(s->afe_params), sizeof(GT68xx_AFE_Parameters));
      RIE (gt68xx_assign_calibration (s, scan_params));
      scan_request.calculate = SANE_FALSE;
    }
 
  /* send scan request to the scanner */
  RIE (gt68xx_scanner_start_scan (s, &scan_request, &scan_params));

  for (i = 0; i < scan_params.overscan_lines; ++i)
    RIE (gt68xx_scanner_read_line (s, buffer_pointers));
  DBG (4, "sane_start: wanted: dpi=%d, x=%.1f, y=%.1f, width=%.1f, "
       "height=%.1f, color=%s\n", scan_request.xdpi,
       SANE_UNFIX (scan_request.x0),
       SANE_UNFIX (scan_request.y0), SANE_UNFIX (scan_request.xs),
       SANE_UNFIX (scan_request.ys), scan_request.color ? "color" : "gray");

  s->line = 0;
  s->byte_count = s->reader->params.pixel_xs;
  s->total_bytes = 0;
  s->first_scan = SANE_FALSE;

#ifdef DEBUG_BRIGHTNESS
  s->average_white = 0;
  s->max_white = 0;
  s->min_black = 255;
#endif

  s->scanning = SANE_TRUE;

  DBG (5, "sane_start: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
           SANE_Int * len)
{
  GT68xx_Scanner *s = handle;
  SANE_Status status;
  static unsigned int *buffer_pointers[3];
  SANE_Int inflate_x;
  SANE_Bool lineart;
  SANE_Int i, color, colors;

  if (!s)
    {
      DBG (1, "sane_read: handle is null!\n");
      return SANE_STATUS_INVAL;
    }

  if (!buf)
    {
      DBG (1, "sane_read: buf is null!\n");
      return SANE_STATUS_INVAL;
    }

  if (!len)
    {
      DBG (1, "sane_read: len is null!\n");
      return SANE_STATUS_INVAL;
    }

  *len = 0;

  if (!s->scanning)
    {
      DBG (3, "sane_read: scan was cancelled, is over or has not been "
           "initiated yet\n");
      return SANE_STATUS_CANCELLED;
    }

  DBG (5, "sane_read: start (line %d of %d, byte_count %d of %d)\n",
       s->line, s->reader->params.pixel_ys, s->byte_count,
       s->reader->params.pixel_xs);

  if (s->line >= s->reader->params.pixel_ys
      && s->byte_count >= s->reader->params.pixel_xs)
    {
      DBG (4, "sane_read: nothing more to scan: EOF\n");
      return SANE_STATUS_EOF;
    }

  inflate_x = s->val[OPT_RESOLUTION].w / s->dev->model->optical_xdpi;
  if (inflate_x > 1)
    DBG (5, "sane_read: inflating x by factor %d\n", inflate_x);
  else
    inflate_x = 1;

  lineart = (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
    ? SANE_TRUE : SANE_FALSE;

  if (s->reader->params.color)
    colors = 3;
  else
    colors = 1;

  while ((*len) < max_len)
    {
      if (s->byte_count >= s->reader->params.pixel_xs)
        {
          if (s->line >= s->reader->params.pixel_ys)
            {
              DBG (4, "sane_read: scan complete: %d bytes, %d total\n",
                   *len, s->total_bytes);
              return SANE_STATUS_GOOD;
            }
          DBG (5, "sane_read: getting line %d of %d\n", s->line,
               s->reader->params.pixel_ys);
          RIE (gt68xx_scanner_read_line (s, buffer_pointers));
          s->line++;
          s->byte_count = 0;

          /* Apply gamma */
          for (color = 0; color < colors; color++)
            for (i = 0; i < s->reader->pixels_per_line; i++)
              {
                if (s->reader->params.depth > 8)
                  buffer_pointers[color][i] =
                    s->gamma_table[buffer_pointers[color][i]];
                else
                  buffer_pointers[color][i] =
                    (s->gamma_table[buffer_pointers[color][i] >> 8] << 8) +
                    (s->gamma_table[buffer_pointers[color][i] >> 8]);
              }
          /* mirror lines */
          if (s->dev->model->flags & GT68XX_FLAG_MIRROR_X)
            {
              unsigned int swap;

              for (color = 0; color < colors; color++)
                {
                  for (i = 0; i < s->reader->pixels_per_line / 2; i++)
                    {
                      swap = buffer_pointers[color][i];
                      buffer_pointers[color][i] =
                        buffer_pointers[color][s->reader->pixels_per_line -
                                               1 - i];
                      buffer_pointers[color][s->reader->pixels_per_line - 1 -
                                             i] = swap;
                    }
                }
            }
        }
      if (lineart)
        {
          SANE_Int bit;
          SANE_Byte threshold = s->val[OPT_THRESHOLD].w;

          buf[*len] = 0;
          for (bit = 7; bit >= 0; bit--)
            {
              SANE_Byte is_black =
                (((buffer_pointers[0][s->byte_count] >> 8) & 0xff) >
                 threshold) ? 0 : 1;
              buf[*len] |= (is_black << bit);
              if ((7 - bit) % inflate_x == (inflate_x - 1))
                s->byte_count++;
            }
        }
      else if (s->reader->params.color)
        {
          /* color */
          if (s->reader->params.depth > 8)
            {
              SANE_Int color = (s->total_bytes / 2) % 3;
              if ((s->total_bytes % 2) == 0)
                {
                  if (little_endian)
                    buf[*len] = buffer_pointers[color][s->byte_count] & 0xff;
                  else
                    buf[*len] =
                      (buffer_pointers[color][s->byte_count] >> 8) & 0xff;
                }
              else
                {
                  if (little_endian)
                    buf[*len] =
                      (buffer_pointers[color][s->byte_count] >> 8) & 0xff;
                  else
                    buf[*len] = buffer_pointers[color][s->byte_count] & 0xff;

                  if (s->total_bytes % (inflate_x * 6) == (inflate_x * 6 - 1))
                    s->byte_count++;
                }
            }
          else
            {
              SANE_Int color = s->total_bytes % 3;
              buf[*len] = (buffer_pointers[color][s->byte_count] >> 8) & 0xff;
              if (s->total_bytes % (inflate_x * 3) == (inflate_x * 3 - 1))
                s->byte_count++;
#ifdef DEBUG_BRIGHTNESS
              s->average_white += buf[*len];
              s->max_white =
                (buf[*len] > s->max_white) ? buf[*len] : s->max_white;
              s->min_black =
                (buf[*len] < s->min_black) ? buf[*len] : s->min_black;
#endif
            }
        }
      else
        {
          /* gray */
          if (s->reader->params.depth > 8)
            {
              if ((s->total_bytes % 2) == 0)
                {
                  if (little_endian)
                    buf[*len] = buffer_pointers[0][s->byte_count] & 0xff;
                  else
                    buf[*len] =
                      (buffer_pointers[0][s->byte_count] >> 8) & 0xff;
                }
              else
                {
                  if (little_endian)
                    buf[*len] =
                      (buffer_pointers[0][s->byte_count] >> 8) & 0xff;
                  else
                    buf[*len] = buffer_pointers[0][s->byte_count] & 0xff;
                  if (s->total_bytes % (2 * inflate_x) == (2 * inflate_x - 1))
                    s->byte_count++;
                }
            }
          else
            {
              buf[*len] = (buffer_pointers[0][s->byte_count] >> 8) & 0xff;
              if (s->total_bytes % inflate_x == (inflate_x - 1))
                s->byte_count++;
            }
        }
      (*len)++;
      s->total_bytes++;
    }

  DBG (4, "sane_read: exit (line %d of %d, byte_count %d of %d, %d bytes, "
       "%d total)\n",
       s->line, s->reader->params.pixel_ys, s->byte_count,
       s->reader->params.pixel_xs, *len, s->total_bytes);
  return SANE_STATUS_GOOD;
}

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

  DBG (5, "sane_cancel: start\n");

  if (s->scanning)
    {
      s->scanning = SANE_FALSE;
      if (s->total_bytes != (s->params.bytes_per_line * s->params.lines))
        DBG (1, "sane_cancel: warning: scanned %d bytes, expected %d "
             "bytes\n", s->total_bytes,
             s->params.bytes_per_line * s->params.lines);
      else
        {
          struct timeval now;
          int secs;

          gettimeofday (&now, 0);
          secs = now.tv_sec - s->start_time.tv_sec;

          DBG (3,
               "sane_cancel: scan finished, scanned %d bytes in %d seconds\n",
               s->total_bytes, secs);
#ifdef DEBUG_BRIGHTNESS
          DBG (1,
               "sane_cancel: average white: %d, max_white=%d, min_black=%d\n",
               s->average_white / s->total_bytes, s->max_white, s->min_black);
#endif

        }
      /* some scanners don't like this command when cancelling a scan */
      sanei_usb_set_timeout (SHORT_TIMEOUT);
      gt68xx_device_fix_descriptor (s->dev);
      gt68xx_scanner_stop_scan (s);
      sanei_usb_set_timeout (LONG_TIMEOUT);

      if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
        {
          gt68xx_device_paperfeed (s->dev);
        } 
      else
        {
          sanei_usb_set_timeout (SHORT_TIMEOUT);
          gt68xx_scanner_wait_for_positioning (s);
          sanei_usb_set_timeout (LONG_TIMEOUT);
          gt68xx_device_carriage_home (s->dev);
        }
      if (s->gamma_table)
        free (s->gamma_table);
      s->gamma_table = 0;
    }
  else
    {
      DBG (4, "sane_cancel: scan has not been initiated yet, "
           "or it is already aborted\n");
    }

  DBG (5, "sane_cancel: exit\n");
  return;
}

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

  DBG (5, "sane_set_io_mode: handle = %p, non_blocking = %s\n",
       handle, non_blocking == SANE_TRUE ? "true" : "false");

  if (!s->scanning)
    {
      DBG (1, "sane_set_io_mode: not scanning\n");
      return SANE_STATUS_INVAL;
    }
  if (non_blocking)
    return SANE_STATUS_UNSUPPORTED;
  return SANE_STATUS_GOOD;
}

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

  DBG (5, "sane_get_select_fd: handle = %p, fd = %p\n", handle, (void *) fd);

  if (!s->scanning)
    {
      DBG (1, "sane_get_select_fd: not scanning\n");
      return SANE_STATUS_INVAL;
    }
  return SANE_STATUS_UNSUPPORTED;
}

/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */