Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2696 insertions, 0 deletions

diff --git a/backend/mustek_usb2.c b/backend/mustek_usb2.c
new file mode 100644
index 0000000..25b8464
--- /dev/null
+++ b/backend/mustek_usb2.c
@@ -0,0 +1,2696 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2000-2005 Mustek.
+   Originally maintained by Mustek
+
+   Copyright (C) 2001-2005 by Henning Meier-Geinitz.
+
+   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 Mustek BearPaw 2448 TA Pro 
+   and similar USB2 scanners. */
+
+#define BUILD 10
+
+#include "../include/sane/config.h"
+
+#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 <math.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+
+#define BACKEND_NAME mustek_usb2
+
+#include "../include/sane/sanei_backend.h"
+#include "mustek_usb2_high.c"
+
+#include "mustek_usb2.h"
+
+static SANE_Int num_devices;
+static const SANE_Device **devlist = 0;
+
+static const SANE_Range u8_range = {
+  0,				/* minimum */
+  255,				/* maximum */
+  0				/* quantization */
+};
+static SANE_Range x_range = {
+  SANE_FIX (0.0),		/* minimum */
+  SANE_FIX (8.3 * MM_PER_INCH),	/* maximum */
+  SANE_FIX (0.0)		/* quantization */
+};
+
+static SANE_Range y_range = {
+  SANE_FIX (0.0),		/* minimum */
+  SANE_FIX (11.6 * MM_PER_INCH),	/* maximum */
+  SANE_FIX (0.0)		/* quantization */
+};
+
+static SANE_Range gamma_range = {
+  SANE_FIX (0.01),		/* minimum */
+  SANE_FIX (5.0),		/* maximum */
+  SANE_FIX (0.01)		/* quantization */
+};
+static SANE_String_Const mode_list[] = {
+  SANE_I18N ("Color48"),
+  SANE_I18N ("Color24"),
+  SANE_I18N ("Gray16"),
+  SANE_I18N ("Gray8"),
+  SANE_VALUE_SCAN_MODE_LINEART,
+  0
+};
+
+static SANE_String_Const negative_mode_list[] = {
+  SANE_I18N ("Color24"),
+  0
+};
+
+static SANE_String_Const source_list[] = {
+  SANE_I18N ("Reflective"),
+  SANE_I18N ("Positive"),
+  SANE_I18N ("Negative"),
+  0
+};
+static Scanner_Model mustek_A2nu2_model = {
+  "mustek-A2nu2",		/* Name */
+  "Mustek",			/* Device vendor string */
+
+  "BearPaw 2448TA Pro",		/* Device model name */
+  "",				/* Name of the firmware file */
+
+  {1200, 600, 300, 150, 75, 0},	/* possible resolutions */
+
+  SANE_FIX (0.0),		/* Start of scan area in mm  (x) */
+  SANE_FIX (0.0),		/* Start of scan area in mm (y) */
+  SANE_FIX (8.3 * MM_PER_INCH),	/* Size of scan area in mm (x) */
+  SANE_FIX (11.6 * MM_PER_INCH),	/* Size of scan area in mm (y) */
+
+  SANE_FIX (0.0),		/* Start of scan area in TA mode in mm (x) */
+  SANE_FIX (0.0),		/* Start of scan area in TA mode in mm (y) */
+  SANE_FIX (1.46 * MM_PER_INCH),	/* Size of scan area in TA mode in mm (x) */
+  SANE_FIX (6.45 * MM_PER_INCH),	/* Size of scan area in TA mode in mm (y) */
+
+  0,				/* Order of the CCD/CIS colors 0:RO_RGB 1:RO_BGR */
+  SANE_FIX (2.0),		/* Default gamma value */
+
+  SANE_FALSE,			/* Is this a CIS scanner? */
+  0				/* Which flags are needed for this scanner? */
+    /* Setup and tested */
+};
+
+
+/* Forward declarations */
+
+static SANE_Bool GetDeviceStatus (void);
+static SANE_Bool PowerControl (SANE_Bool isLampOn, SANE_Bool isTaLampOn);
+static SANE_Bool CarriageHome (void);
+static SANE_Bool SetParameters (LPSETPARAMETERS pSetParameters);
+static SANE_Bool GetParameters (LPGETPARAMETERS pGetParameters);
+static SANE_Bool StartScan (void);
+static SANE_Bool ReadScannedData (LPIMAGEROWS pImageRows);
+static SANE_Bool StopScan (void);
+static SANE_Bool IsTAConnected (void);
+static void AutoLevel (SANE_Byte *lpSource, SCANMODE scanMode, unsigned short ScanLines,
+		unsigned int BytesPerLine);
+static size_t max_string_size (const SANE_String_Const strings[]);
+static SANE_Status calc_parameters (Mustek_Scanner * s);
+#ifdef SANE_UNUSED
+static SANE_Bool GetGammaInfo (LPGAMMAINFO pGamaInfo);
+static SANE_Bool GetKeyStatus (SANE_Byte * pKey);
+static void QBetChange (SANE_Byte *lpSource, SCANMODE scanMode, unsigned short ScanLines,
+		 unsigned int BytesPerLine);
+static void QBETDetectAutoLevel (void *pDIB, unsigned int ImageWidth, unsigned int ImageHeight);
+#endif
+
+
+
+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
+calc_parameters (Mustek_Scanner * s)
+{
+  SANE_String val, val_source;
+  val = s->val[OPT_MODE].s;
+  val_source = s->val[OPT_SOURCE].s;
+
+  s->params.last_frame = SANE_TRUE;
+
+  if (strcmp (val, "Color48") == 0)	/* Color48 */
+    {
+      s->params.format = SANE_FRAME_RGB;
+      s->params.depth = 16;
+      s->setpara.smScanMode = SM_RGB48;
+      if (s->val[OPT_PREVIEW].w)
+	{
+	  DBG (DBG_DET, "calc_parameters : preview set ScanMode SM_RGB24\n");
+	  s->params.depth = 8;
+	  s->setpara.smScanMode = SM_RGB24;
+	}
+    }
+  else if (strcmp (val, "Color24") == 0)	/* Color24 */
+    {
+      s->params.format = SANE_FRAME_RGB;
+      s->params.depth = 8;
+      s->setpara.smScanMode = SM_RGB24;
+    }
+  else if (strcmp (val, "Gray16") == 0)
+    {
+      s->params.format = SANE_FRAME_GRAY;
+      s->params.depth = 16;
+      s->setpara.smScanMode = SM_GRAY16;
+      if (s->val[OPT_PREVIEW].w)
+	{
+	  s->params.depth = 8;
+	  DBG (DBG_DET, "calc_parameters : preview set ScanMode SM_GRAY\n");
+	  s->setpara.smScanMode = SM_GRAY;
+	}
+    }
+  else if (strcmp (val, "Gray8") == 0)
+    {
+      s->params.format = SANE_FRAME_GRAY;
+      s->params.depth = 8;
+      s->setpara.smScanMode = SM_GRAY;
+    }
+  else if (strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    {
+      s->params.format = SANE_FRAME_GRAY;
+      s->params.depth = 1;
+      s->setpara.smScanMode = SM_TEXT;
+    }
+
+  /*set Scan Source */
+  DBG (DBG_DET, "calc_parameters :scan Source = %s\n", val_source);
+  if (strcmp (val_source, "Reflective") == 0)
+    {
+      s->setpara.ssScanSource = SS_Reflective;
+    }
+  else if (strcmp (val_source, "Positive") == 0)
+    {
+      s->setpara.ssScanSource = SS_Positive;
+    }
+  else if (strcmp (val_source, "Negative") == 0)
+    {
+      s->setpara.ssScanSource = SS_Negative;
+    }
+
+
+  s->setpara.fmArea.x1 =
+    (unsigned short) ((SANE_UNFIX (s->val[OPT_TL_X].w) * 300.0) / MM_PER_INCH + 0.5);
+  s->setpara.fmArea.x2 =
+    (unsigned short) ((SANE_UNFIX (s->val[OPT_BR_X].w) * 300.0) / MM_PER_INCH + 0.5);
+  s->setpara.fmArea.y1 =
+    (unsigned short) ((SANE_UNFIX (s->val[OPT_TL_Y].w) * 300.0) / MM_PER_INCH + 0.5);
+  s->setpara.fmArea.y2 =
+    (unsigned short) ((SANE_UNFIX (s->val[OPT_BR_Y].w) * 300.0) / MM_PER_INCH + 0.5);
+
+  if (s->val[OPT_PREVIEW].w)
+    {
+      s->setpara.fmArea.y1 = s->setpara.fmArea.y1 + PER_ADD_START_LINES;
+      s->setpara.fmArea.x1 += PRE_ADD_START_X;
+    }				/*just for range bug. */
+
+  s->setpara.pfPixelFlavor = PF_BlackIs0;
+  s->setpara.wLinearThreshold = s->val[OPT_THRESHOLD].w;
+
+  s->setpara.wTargetDPI = s->val[OPT_RESOLUTION].w;
+  if (s->val[OPT_PREVIEW].w)
+    {
+      s->setpara.wTargetDPI = 75;
+    }
+
+  s->setpara.pGammaTable = NULL;
+
+  s->params.pixels_per_line =
+    (SANE_Int) ((s->setpara.fmArea.x2 -
+		 s->setpara.fmArea.x1) * s->setpara.wTargetDPI / 300.0 + 0.5);
+
+  switch (s->params.format)
+    {
+    case SANE_FRAME_RGB:
+      if (s->params.depth == 8)
+	s->params.bytes_per_line = s->params.pixels_per_line * 3;
+      if (s->params.depth == 16)
+	s->params.bytes_per_line = s->params.pixels_per_line * 6;
+      break;
+    case SANE_FRAME_GRAY:
+      if (s->params.depth == 1)
+	s->params.bytes_per_line = s->params.pixels_per_line / 8;
+      if (s->params.depth == 8)
+	s->params.bytes_per_line = s->params.pixels_per_line;
+      if (s->params.depth == 16)
+	s->params.bytes_per_line = s->params.pixels_per_line * 2;
+      break;
+    default:
+      DBG (DBG_DET, "sane_star:sane params .format = %d\n", s->params.format);
+    }
+
+  s->params.lines =
+    (SANE_Int) ((s->setpara.fmArea.y2 -
+		 s->setpara.fmArea.y1) * s->setpara.wTargetDPI / 300 + 0.5);
+
+  DBG (DBG_FUNC, "calc_parameters: end\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options (Mustek_Scanner * s)
+{
+  SANE_Int option, count;
+  SANE_Word *dpi_list;		/*Resolution Support */
+
+  DBG (DBG_FUNC, "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;
+    }
+  /*  Option num */
+  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 ("Color24");
+
+  /* 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 ("Reflective");
+
+  if (!IsTAConnected ())
+    {
+      DISABLE (OPT_SOURCE);
+    }
+
+
+  /* resolution */
+
+  for (count = 0; s->model.dpi_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; s->model.dpi_values[count] != 0; count++)
+    dpi_list[count + 1] = s->model.dpi_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; 
+
+  /* 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].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+  s->val[OPT_PREVIEW].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;
+
+  /* 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 40 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_FALSE;
+  if (s->model.is_cis)
+    DISABLE (OPT_AUTO_WARMUP);
+
+  /* "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].size = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* 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->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+  s->val[OPT_THRESHOLD].w = DEF_LINEARTTHRESHOLD;
+
+  /* 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->model.default_gamma_value;
+
+  DISABLE (OPT_GAMMA_VALUE);
+
+  /* "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 = s->model.x_size;
+  y_range.max = s->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;
+
+  calc_parameters (s);
+
+  DBG (DBG_FUNC, "init_options: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+/***************************** Code from spicall.c *****************************/
+
+static SANE_Byte * g_lpNegImageData = NULL;
+static SANE_Bool g_bIsFirstGetNegData = TRUE;
+static SANE_Bool g_bIsMallocNegData = FALSE;
+static unsigned int g_dwAlreadyGetNegLines = 0;
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	Check the device connect status
+Parameters:
+	none
+Return value: 
+	if the device is connected
+	return TRUE
+	else 
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+GetDeviceStatus ()
+{
+  DBG (DBG_FUNC, "GetDeviceStatus: start\n");
+  return MustScanner_GetScannerState ();
+}
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	Turn the lamp on or off
+Parameters:
+	isLampOn: turn the lamp on or off
+	isTALampOn: turn the TA lamp on or off
+Return value: 
+	if operation success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+PowerControl (SANE_Bool isLampOn, SANE_Bool isTALampOn)
+{
+  DBG (DBG_FUNC, "PowerControl: start\n");
+  return MustScanner_PowerControl (isLampOn, isTALampOn);
+}
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	Turn the carriage home
+Parameters:
+	none
+Return value: 
+	if the operation success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+CarriageHome ()
+{
+  DBG (DBG_FUNC, "CarriageHome: start\n");
+  return MustScanner_BackHome ();
+}
+
+#ifdef SANE_UNUSED
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	Get gamma input/output bit count
+Parameters:
+	pGammaInfo: the gamma information
+Return value: 
+	if the operation success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+GetGammaInfo (LPGAMMAINFO pGammaInfo)
+{
+  DBG (DBG_FUNC, "GetGammaInfo: start\n");
+
+  switch (pGammaInfo->smScanMode)
+    {
+    case SM_GRAY:
+      pGammaInfo->wInputGammaBits = 12;
+      pGammaInfo->wOutputGammaBits = 8;
+      break;
+    case SM_RGB24:
+      pGammaInfo->wInputGammaBits = 12;
+      pGammaInfo->wOutputGammaBits = 8;
+      break;
+    case SM_GRAY16:
+      pGammaInfo->wInputGammaBits = 16;
+      pGammaInfo->wOutputGammaBits = 16;
+      break;
+    case SM_RGB48:
+      pGammaInfo->wInputGammaBits = 16;
+      pGammaInfo->wOutputGammaBits = 16;
+      break;
+    default:
+      pGammaInfo->wInputGammaBits = 0;
+      pGammaInfo->wOutputGammaBits = 0;
+      return FALSE;
+    }
+
+  DBG (DBG_FUNC, "GetGammaInfo: exit\n");
+  return TRUE;
+}
+#endif
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	set scan parameters
+Parameters:
+	pSetParameters: the information of scaning
+Return value: 
+	if the operation success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+SetParameters (LPSETPARAMETERS pSetParameters)
+{
+  unsigned short X1inTargetDpi;
+  unsigned short Y1inTargetDpi;
+  unsigned short X2inTargetDpi;
+  unsigned short Y2inTargetDpi;
+
+  DBG (DBG_FUNC, "SetParameters: start\n");
+
+  /*0. Reset */
+  if (ST_Reflective == g_ScanType)
+    {
+      Reflective_Reset ();
+    }
+  else
+    {
+      Transparent_Reset ();
+    }
+
+  /*1. Scan mode */
+  switch (pSetParameters->smScanMode)
+    {
+    case SM_TEXT:
+      g_tiTarget.cmColorMode = CM_TEXT;
+      break;
+    case SM_GRAY:
+      g_tiTarget.cmColorMode = CM_GRAY8;
+      break;
+    case SM_GRAY16:
+      g_tiTarget.cmColorMode = CM_GRAY16;
+      break;
+    case SM_RGB24:
+      g_tiTarget.cmColorMode = CM_RGB24;
+      break;
+    case SM_RGB48:
+      g_tiTarget.cmColorMode = CM_RGB48;
+      break;
+    default:
+      return FALSE;
+    }
+
+  /*2. Scan source */
+  g_ssScanSource = pSetParameters->ssScanSource;
+  g_tiTarget.bScanSource = pSetParameters->ssScanSource;
+
+
+  if (SS_Reflective == pSetParameters->ssScanSource)
+    {
+      g_ScanType = ST_Reflective;
+    }
+  else if (SS_Positive == pSetParameters->ssScanSource
+	   || SS_Negative == pSetParameters->ssScanSource
+	   || SS_ADF == pSetParameters->ssScanSource)
+    {
+      g_ScanType = ST_Transparent;
+    }
+  else
+    {
+      DBG (DBG_ERR, "SetParameters: ScanSource error\n");
+      return FALSE;
+    }
+
+  /*3. pixel flavor */
+  if (PF_BlackIs0 == pSetParameters->pfPixelFlavor
+      || PF_WhiteIs0 == pSetParameters->pfPixelFlavor)
+    {
+      g_PixelFlavor = pSetParameters->pfPixelFlavor;
+    }
+  else
+    {
+      DBG (DBG_ERR, "SetParameters: PixelFlavor error\n");
+      return FALSE;
+    }
+
+  /*4. Scan area */
+  if (pSetParameters->fmArea.x1 >= pSetParameters->fmArea.x2)
+    {
+      DBG (DBG_ERR, "SetParameters: x1 > x2, error\n");
+      return FALSE;
+    }
+  if (pSetParameters->fmArea.y1 >= pSetParameters->fmArea.y2)
+    {
+      DBG (DBG_ERR, "SetParameters: y1 >= y2, error\n");
+      return FALSE;
+    }
+  if (pSetParameters->fmArea.x2 > MAX_SCANNING_WIDTH)	/* Just for A4 size */
+    {
+      DBG (DBG_ERR, "SetParameters: x2 > MAX_SCANNING_WIDTH, error\n");
+      return FALSE;
+    }
+  if (pSetParameters->fmArea.y2 > MAX_SCANNING_HEIGHT)	/* Just for A4 size */
+    {
+      DBG (DBG_ERR, "SetParameters: y2 > MAX_SCANNING_HEIGHT, error\n");
+      return FALSE;
+    }
+
+  X1inTargetDpi =
+    (unsigned short) ((unsigned int) (pSetParameters->fmArea.x1) *
+	    (unsigned int) (pSetParameters->wTargetDPI) / 300L);
+  Y1inTargetDpi =
+    (unsigned short) ((unsigned int) (pSetParameters->fmArea.y1) *
+	    (unsigned int) (pSetParameters->wTargetDPI) / 300L);
+  X2inTargetDpi =
+    (unsigned short) ((unsigned int) (pSetParameters->fmArea.x2) *
+	    (unsigned int) (pSetParameters->wTargetDPI) / 300L);
+  Y2inTargetDpi =
+    (unsigned short) ((unsigned int) (pSetParameters->fmArea.y2) *
+	    (unsigned int) (pSetParameters->wTargetDPI) / 300L);
+
+  g_tiTarget.isOptimalSpeed = TRUE;
+  g_tiTarget.wDpi = pSetParameters->wTargetDPI;
+  g_tiTarget.wX = X1inTargetDpi;
+  g_tiTarget.wY = Y1inTargetDpi;
+  g_tiTarget.wWidth = X2inTargetDpi - X1inTargetDpi;
+  g_tiTarget.wHeight = Y2inTargetDpi - Y1inTargetDpi;
+
+  DBG (DBG_INFO, "SetParameters: g_tiTarget.wDpi=%d\n", g_tiTarget.wDpi);
+  DBG (DBG_INFO, "SetParameters: g_tiTarget.wX=%d\n", g_tiTarget.wX);
+  DBG (DBG_INFO, "SetParameters: g_tiTarget.wY=%d\n", g_tiTarget.wY);
+  DBG (DBG_INFO, "SetParameters: g_tiTarget.wWidth=%d\n", g_tiTarget.wWidth);
+  DBG (DBG_INFO, "SetParameters: g_tiTarget.wHeight=%d\n",
+       g_tiTarget.wHeight);
+
+  /*5.Prepare */
+  if (FALSE == MustScanner_Prepare (g_tiTarget.bScanSource))
+    {
+      DBG (DBG_ERR, "SetParameters: MustScanner_Prepare fail\n");
+      return FALSE;
+    }
+
+  /*6. Linear threshold */
+  if (pSetParameters->wLinearThreshold > 256
+      && pSetParameters->smScanMode == SM_TEXT)
+    {
+      DBG (DBG_ERR, "SetParameters: LinearThreshold error\n");
+      return FALSE;
+    }
+  else
+    {
+      g_wLineartThreshold = pSetParameters->wLinearThreshold;
+    }
+
+  /*7. Gamma table */
+  if (NULL != pSetParameters->pGammaTable)
+    {
+      DBG (DBG_INFO, "SetParameters: IN gamma table not NULL\n");
+      g_pGammaTable = pSetParameters->pGammaTable;
+      g_isSelfGamma = FALSE;
+    }
+  else if (pSetParameters->smScanMode == SM_GRAY
+	   || pSetParameters->smScanMode == SM_RGB24)
+    {
+      unsigned short i;
+      SANE_Byte byGammaData;
+      double pow_d;
+      double pow_z = (double) 10 / 16.0;
+
+      g_pGammaTable = (unsigned short *) malloc (sizeof (unsigned short) * 4096 * 3);
+
+      DBG (DBG_INFO, "SetParameters: gamma table malloc %ld Bytes\n",
+	   (long int) sizeof (unsigned short) * 4096 * 3);
+      DBG (DBG_INFO, "SetParameters: address of g_pGammaTable=%p\n",
+	   (void *) g_pGammaTable);
+
+      if (NULL == g_pGammaTable)
+	{
+	  DBG (DBG_ERR, "SetParameters: gamma table malloc fail\n");
+	  return FALSE;
+	}
+      g_isSelfGamma = TRUE;
+
+      for (i = 0; i < 4096; i++)
+	{
+	  pow_d = (double) i / (double) 4096;
+
+	  byGammaData = (SANE_Byte) (pow (pow_d, pow_z) * 255);
+
+	  *(g_pGammaTable + i) = byGammaData;
+	  *(g_pGammaTable + i + 4096) = byGammaData;
+	  *(g_pGammaTable + i + 8192) = byGammaData;
+	}
+    }
+  else if (pSetParameters->smScanMode == SM_GRAY16
+	   || pSetParameters->smScanMode == SM_RGB48)
+    {
+      unsigned int i, wGammaData;
+      g_pGammaTable = (unsigned short *) malloc (sizeof (unsigned short) * 65536 * 3);
+
+      if (g_pGammaTable == NULL)
+	{
+	  DBG (DBG_ERR, "SetParameters: gamma table malloc fail\n");
+	  return FALSE;
+	}
+      g_isSelfGamma = TRUE;
+
+      for (i = 0; i < 65536; i++)
+	{
+	  wGammaData =
+	    (unsigned short) (pow ((((float) i) / 65536.0), (((float) 10) / 16.0)) *
+		    65535);
+
+	  *(g_pGammaTable + i) = wGammaData;
+	  *(g_pGammaTable + i + 65536) = wGammaData;
+	  *(g_pGammaTable + i + 65536 * 2) = wGammaData;
+	}
+    }
+  else
+    {
+      DBG (DBG_INFO, "SetParameters: set g_pGammaTable to NULL\n");
+      g_pGammaTable = NULL;
+    }
+
+  DBG (DBG_FUNC, "SetParameters: exit\n");
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	get the optical dpi and scan area
+Parameters:
+	pGetParameters: the information of scan
+Return value: 
+	if the operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+GetParameters (LPGETPARAMETERS pGetParameters)
+{
+  DBG (DBG_FUNC, "GetParameters: start\n");
+  if (ST_Reflective == g_ScanType)
+    {
+      if (FALSE == Reflective_ScanSuggest (&g_tiTarget, &g_ssSuggest))
+	{
+	  DBG (DBG_ERR, "GetParameters: Reflective_ScanSuggest error\n");
+	  return FALSE;
+	}
+    }
+  else
+    {
+      if (FALSE == Transparent_ScanSuggest (&g_tiTarget, &g_ssSuggest))
+	{
+	  DBG (DBG_ERR, "GetParameters: Transparent_ScanSuggest error\n");
+	  return FALSE;
+	}
+    }
+
+  pGetParameters->wSourceXDPI = g_ssSuggest.wXDpi;
+  pGetParameters->wSourceYDPI = g_ssSuggest.wYDpi;
+  pGetParameters->dwLength = (unsigned int) g_ssSuggest.wHeight;
+  pGetParameters->dwLineByteWidth = g_ssSuggest.dwBytesPerRow;
+
+  DBG (DBG_FUNC, "GetParameters: exit\n");
+
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+
+Routine Description: 
+	start scan image
+Parameters:
+	none
+Return value:
+	if operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+StartScan ()
+{
+  DBG (DBG_FUNC, "StartScan: start\n");
+  if (ST_Reflective == g_ScanType)
+    {
+      DBG (DBG_INFO, "StartScan: g_ScanType==ST_Reflective\n");
+
+      return Reflective_SetupScan (g_ssSuggest.cmScanMode,
+				   g_ssSuggest.wXDpi,
+				   g_ssSuggest.wYDpi,
+				   PF_BlackIs0,
+				   g_ssSuggest.wX,
+				   g_ssSuggest.wY,
+				   g_ssSuggest.wWidth, g_ssSuggest.wHeight);
+    }
+  else
+
+    {
+
+      DBG (DBG_INFO, "StartScan: g_ScanType==ST_Transparent\n");
+
+      return Transparent_SetupScan (g_ssSuggest.cmScanMode,
+				    g_ssSuggest.wXDpi,
+				    g_ssSuggest.wYDpi,
+				    PF_BlackIs0,
+				    g_ssSuggest.wX,
+				    g_ssSuggest.wY,
+				    g_ssSuggest.wWidth, g_ssSuggest.wHeight);
+    }
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Read the scanner data
+Parameters:
+
+	pImageRows: the information of the data
+Return value:	
+	if the operation is seccuss
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+ReadScannedData (LPIMAGEROWS pImageRows)
+{
+  SANE_Bool isRGBInvert;
+  unsigned short Rows = 0;
+  SANE_Byte *lpBlock = (SANE_Byte *) pImageRows->pBuffer;
+  SANE_Byte *lpReturnData = (SANE_Byte *) pImageRows->pBuffer;
+  int i = 0;
+
+  DBG (DBG_FUNC, "ReadScannedData: start\n");
+
+  if (pImageRows->roRgbOrder == RO_RGB)
+    isRGBInvert = FALSE;
+  else
+    isRGBInvert = TRUE;
+
+  Rows = pImageRows->wWantedLineNum;
+
+  DBG (DBG_INFO, "ReadScannedData: wanted Rows = %d\n", Rows);
+
+  if (ST_Reflective == g_ScanType)
+    {
+      if (FALSE == Reflective_GetRows (lpBlock, &Rows, isRGBInvert))
+	return FALSE;
+    }
+  else if (SS_Positive == g_ssScanSource)
+    {
+      if (FALSE == Transparent_GetRows (lpBlock, &Rows, isRGBInvert))
+	return FALSE;
+    }
+
+  pImageRows->wXferedLineNum = Rows;
+
+  if (g_PixelFlavor == PF_WhiteIs0 || g_ScanMode == CM_TEXT)
+    {
+      int TotalSize = Rows * g_ssSuggest.dwBytesPerRow;
+      for (i = 0; i < TotalSize; i++)
+	{
+	  *(lpBlock++) ^= 0xff;
+	}
+    }
+
+  if (SS_Negative == g_ssScanSource)
+    {
+      DBG (DBG_INFO, "ReadScannedData: deal with the Negative\n");
+
+      if (g_bIsFirstGetNegData)
+	{
+	  unsigned int TotalImgeSize = g_SWHeight * g_ssSuggest.dwBytesPerRow;
+	  g_lpNegImageData = (SANE_Byte *) malloc (TotalImgeSize);
+	  if (NULL != g_lpNegImageData)
+	    {
+	      SANE_Byte * lpTempData = g_lpNegImageData;
+	      DBG (DBG_INFO,
+		   "ReadScannedData: malloc the negative data is success!\n");
+	      g_bIsMallocNegData = TRUE;
+	      if (!Transparent_GetRows
+		  (g_lpNegImageData, &g_SWHeight, isRGBInvert))
+		{
+		  return FALSE;
+		}
+
+	      DBG (DBG_INFO, "ReadScannedData: get image data is over!\n");
+
+	      for (i = 0; i < (int) TotalImgeSize; i++)
+		{
+		  *(g_lpNegImageData++) ^= 0xff;
+		}
+	      g_lpNegImageData = lpTempData;
+	      AutoLevel (g_lpNegImageData, g_ScanMode, g_SWHeight,
+			 g_ssSuggest.dwBytesPerRow);
+	      DBG (DBG_INFO, "ReadScannedData: autolevel is ok\n");
+	    }
+	  g_bIsFirstGetNegData = FALSE;
+	}
+
+      if (g_bIsMallocNegData)
+	{
+	  memcpy (pImageRows->pBuffer,
+		  g_lpNegImageData +
+		  g_ssSuggest.dwBytesPerRow * g_dwAlreadyGetNegLines,
+		  g_ssSuggest.dwBytesPerRow * Rows);
+
+	  DBG (DBG_INFO, "ReadScannedData: copy the data over!\n");
+
+	  g_dwAlreadyGetNegLines += Rows;
+	  if (g_dwAlreadyGetNegLines >= g_SWHeight)
+	    {
+	      DBG (DBG_INFO, "ReadScannedData: free the image data!\n");
+	      free (g_lpNegImageData);
+	      g_lpNegImageData = NULL;
+	      g_bIsFirstGetNegData = TRUE;
+	      g_dwAlreadyGetNegLines = 0;
+	      g_bIsMallocNegData = FALSE;
+	    }
+	}
+      else
+	{
+	  int TotalSize = Rows * g_ssSuggest.dwBytesPerRow;
+	  DBG (DBG_INFO,
+	       "ReadScannedData: malloc the negative data is fail!\n");
+	  if (!Transparent_GetRows (lpReturnData, &Rows, isRGBInvert))
+	    {
+	      return FALSE;
+	    }
+
+	  for (i = 0; i < TotalSize; i++)
+	    {
+	      *(lpReturnData++) ^= 0xff;
+	    }
+	  pImageRows->wXferedLineNum = Rows;
+
+	  g_dwAlreadyGetNegLines += Rows;
+	  if (g_dwAlreadyGetNegLines >= g_SWHeight)
+	    {
+	      g_bIsFirstGetNegData = TRUE;
+	      g_dwAlreadyGetNegLines = 0;
+	      g_bIsMallocNegData = FALSE;
+	    }
+	}
+
+    }
+
+  DBG (DBG_FUNC, "ReadScannedData: leave ReadScannedData\n");
+
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Stop scan
+Parameters:
+	none
+Return value: 
+	if operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+StopScan ()
+{
+  SANE_Bool rt;
+  int i;
+
+  DBG (DBG_FUNC, "StopScan: start\n");
+
+  /*stop read data and kill thread */
+  if (ST_Reflective == g_ScanType)
+    {
+      rt = Reflective_StopScan ();
+    }
+  else
+    {
+      rt = Transparent_StopScan ();
+    }
+
+  /*free gamma table */
+  if (g_isSelfGamma && g_pGammaTable != NULL)
+    {
+      for (i = 0; i < 20; i++)
+	{
+	  if (!g_isScanning)
+	    {
+	      free (g_pGammaTable);
+	      g_pGammaTable = NULL;
+	      break;
+	    }
+	  else
+	    {
+	      sleep (1);	/*waiting ReadScannedData return. */
+	    }
+	}
+    }
+
+  /*free image buffer */
+  if (g_lpReadImageHead != NULL)
+
+    {
+      free (g_lpReadImageHead);
+      g_lpReadImageHead = NULL;
+    }
+
+  DBG (DBG_FUNC, "StopScan: exit\n");
+  return rt;
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Check the status of TA
+Parameters:
+	none
+Return value: 
+	if operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+IsTAConnected ()
+{
+  SANE_Bool hasTA;
+
+  DBG (DBG_FUNC, "StopScan: start\n");
+
+  if (Asic_Open (&g_chip, g_pDeviceFile) != STATUS_GOOD)
+    {
+      return FALSE;
+    }
+
+  if (Asic_IsTAConnected (&g_chip, &hasTA) != STATUS_GOOD)
+    {
+      Asic_Close (&g_chip);
+      return FALSE;
+    }
+
+  Asic_Close (&g_chip);
+
+  DBG (DBG_FUNC, "StopScan: exit\n");
+  return hasTA;
+}
+
+#ifdef SANE_UNUSED
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Get the status of the HK
+Parameters:
+	pKey: the status of key
+Return value: 
+	if the operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+GetKeyStatus (SANE_Byte * pKey)
+{
+  SANE_Byte pKeyTemp = 0x00;
+  STATUS status = Asic_CheckFunctionKey (&g_chip, &pKeyTemp);
+  DBG (DBG_FUNC, "GetKeyStatus: start\n");
+
+  if (STATUS_GOOD != Asic_Open (&g_chip, g_pDeviceFile))
+    {
+      DBG (DBG_ERR, "GetKeyStatus: Asic_Open is fail\n");
+      return FALSE;
+    }
+
+  if (STATUS_GOOD != status)
+    {
+      DBG (DBG_ERR, "GetKeyStatus: Asic_CheckFunctionKey is fail\n");
+      return FALSE;
+    }
+
+  if (0x01 == pKeyTemp)
+    {
+      *pKey = 0x01;		/*Scan key pressed */
+    }
+
+  if (0x02 == pKeyTemp)
+    {
+      *pKey = 0x02;		/*Copy key pressed */
+    }
+  if (0x04 == pKeyTemp)
+    {
+      *pKey = 0x03;		/*Fax key pressed */
+    }
+  if (0x08 == pKeyTemp)
+    {
+      *pKey = 0x04;		/*Email key pressed */
+    }
+  if (0x10 == pKeyTemp)
+    {
+      *pKey = 0x05;		/*Panel key pressed */
+    }
+
+  if (STATUS_GOOD != Asic_Close (&g_chip))
+    {
+      DBG (DBG_ERR, "GetKeyStatus: Asic_Close is fail\n");
+      return FALSE;
+    }
+
+  DBG (DBG_FUNC, "GetKeyStatus: exit\n");
+  return TRUE;
+}
+#endif
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Deal with the image with auto level	
+Parameters:
+	lpSource: the data of image
+	scanMode: the scan mode
+	ScanLines: the rows of image
+	BytesPerLine: the bytes of per line
+Return value: 
+	none
+***********************************************************************/
+static void
+AutoLevel (SANE_Byte *lpSource, SCANMODE scanMode, unsigned short ScanLines,
+	   unsigned int BytesPerLine)
+{
+  int ii;
+  unsigned int i, j;
+  unsigned int tLines, CountPixels, TotalImgSize;
+  unsigned short R, G, B, max_R, max_G, max_B, min_R, min_G, min_B;
+  float fmax_R, fmax_G, fmax_B;
+  unsigned int sum_R = 0, sum_G = 0, sum_B = 0;
+  float mean_R, mean_G, mean_B;
+  unsigned int hisgram_R[256], hisgram_G[256], hisgram_B[256];
+
+  unsigned int iWidth = BytesPerLine / 3;
+  unsigned int iHeight = ScanLines;
+  SANE_Byte *pbmpdata = (SANE_Byte *) lpSource;
+
+  unsigned int tmp = 0;
+  unsigned short imin_threshold[3];
+  unsigned short imax_threshold[3];
+
+  DBG (DBG_FUNC, "AutoLevel: start\n");
+
+  if (scanMode != CM_RGB24ext)
+    {
+      return;
+    }
+
+  i = j = 0;
+  tLines = CountPixels = TotalImgSize = 0;
+
+  TotalImgSize = iWidth * iHeight;
+
+
+
+  for (i = 0; i < 256; i++)
+    {
+
+      hisgram_R[i] = 0;
+      hisgram_G[i] = 0;
+      hisgram_B[i] = 0;
+    }
+
+
+  DBG (DBG_INFO, "AutoLevel: init data is over\n");
+
+  /* Find min , max, mean */
+  max_R = max_G = max_B = 0;
+  min_R = min_G = min_B = 255;
+  tLines = 0;
+  DBG (DBG_INFO, "AutoLevel: iHeight = %d, iWidth = %d\n", iHeight, iWidth);
+
+  for (j = 0; j < iHeight; j++)
+    {
+      tLines = j * iWidth * 3;
+
+
+      for (i = 0; i < iWidth; i++)
+	{
+	  R = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 2));
+	  G = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 1));
+	  B = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3));
+
+	  max_R = _MAX (R, max_R);
+	  max_G = _MAX (G, max_G);
+	  max_B = _MAX (B, max_B);
+
+	  min_R = _MIN (R, min_R);
+	  min_G = _MIN (G, min_G);
+	  min_B = _MIN (B, min_B);
+
+	  hisgram_R[(SANE_Byte) R]++;
+	  hisgram_G[(SANE_Byte) G]++;
+	  hisgram_B[(SANE_Byte) B]++;
+
+	  sum_R += R;
+	  sum_G += G;
+	  sum_B += B;
+
+	  *(pbmpdata + (tLines + i * 3 + 2)) = (SANE_Byte) R;
+	  *(pbmpdata + (tLines + i * 3 + 1)) = (SANE_Byte) G;
+	  *(pbmpdata + (tLines + i * 3)) = (SANE_Byte) B;
+
+	  CountPixels++;
+	}
+
+    }
+
+  DBG (DBG_INFO, "AutoLevel: Find min , max is over!\n");
+
+  mean_R = (float) (sum_R / TotalImgSize);
+  mean_G = (float) (sum_G / TotalImgSize);
+  mean_B = (float) (sum_B / TotalImgSize);
+
+
+  imin_threshold[0] = 0;
+  imin_threshold[1] = 0;
+  imin_threshold[2] = 0;
+  imax_threshold[0] = 0;
+  imax_threshold[1] = 0;
+  imax_threshold[2] = 0;
+
+  for (ii = 0; ii < 256; ii++)
+    {
+      if (hisgram_R[ii] > 0)
+	if (hisgram_R[ii] >= imin_threshold[0])
+	  {
+	    min_R = ii;
+	    break;
+	  }
+    }
+
+  tmp = 0;
+  for (ii = 255; ii >= 0; ii--)
+    {
+      if (hisgram_R[ii] > 0)
+	if (hisgram_R[ii] >= imax_threshold[0])
+	  {
+	    max_R = ii;
+	    break;
+	  }
+    }
+
+  tmp = 0;
+  for (ii = 0; ii < 256; ii++)
+    {
+      if (hisgram_G[ii] > 0)
+	if (hisgram_G[ii] >= imin_threshold[1])
+	  {
+	    min_G = ii;
+	    break;
+	  }
+    }
+
+  tmp = 0;
+  for (ii = 255; ii >= 0; ii--)
+    {
+      if (hisgram_G[ii] > 0)
+	if (hisgram_G[ii] >= imax_threshold[1])
+	  {
+	    max_G = ii;
+	    break;
+	  }
+    }
+
+  tmp = 0;
+  for (ii = 0; ii < 256; ii++)
+    {
+      if (hisgram_B[ii] > 0)
+	if (hisgram_B[ii] >= imin_threshold[2])
+	  {
+	    min_B = ii;
+	    break;
+	  }
+    }
+
+  tmp = 0;
+  for (ii = 255; ii >= 0; ii--)
+    {
+      if (hisgram_B[ii] > 0)
+	if (hisgram_B[ii] >= imax_threshold[2])
+	  {
+	    max_B = ii;
+	    break;
+	  }
+    }
+
+  DBG (DBG_INFO, "AutoLevel: Set min , max is over!\n");
+
+  /*Autolevel: */
+  sum_R = max_R - min_R;
+  sum_G = max_G - min_G;
+  sum_B = max_B - min_B;
+
+  for (j = 0; j < iHeight; j++)
+    {
+      tLines = j * iWidth * 3;
+      for (i = 0; i < iWidth; i++)
+	{
+	  R = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 2));
+	  G = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 1));
+	  B = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3));
+
+	   /*R*/ if (sum_R == 0)
+	    R = max_R;
+	  else if (R < min_R)
+	    R = 0;
+	  else if (R <= 255)
+	    {
+	      fmax_R = ((float) ((R - min_R) * 255) / (float) sum_R);
+	      R = (unsigned short) fmax_R;
+	      fmax_R = (fmax_R - R) * 10;
+
+	      if (fmax_R >= 5)
+		R++;
+	    }
+	  if (R > 255)
+	    R = 255;
+
+	   /*G*/ if (sum_G == 0)
+	    G = max_G;
+	  else if (G < min_G)
+	    G = 0;
+	  else if (G <= 255)
+	    {
+	      fmax_G = ((float) ((G - min_G) * 255) / (float) sum_G);
+	      G = (unsigned short) fmax_G;
+	      fmax_G = (fmax_G - G) * 10;
+	      if (fmax_G >= 5)
+		G++;
+
+	    }
+	  if (G > 255)
+	    G = 255;
+
+	   /*B*/ if (sum_B == 0)
+	    B = max_B;
+	  else if (B < min_B)
+	    B = 0;
+	  else if (B <= 255)
+	    {
+	      fmax_B = ((float) (B - min_B) * 255 / (float) sum_B);
+	      B = (unsigned short) fmax_B;
+	      fmax_B = (fmax_B - B) * 10;
+	      if (fmax_B >= 5)
+		B++;
+	    }
+	  if (B > 255)
+	    B = 255;
+
+	  hisgram_R[(SANE_Byte) R]++;
+	  hisgram_G[(SANE_Byte) G]++;
+	  hisgram_B[(SANE_Byte) B]++;
+
+	  *(pbmpdata + (tLines + i * 3 + 2)) = (SANE_Byte) R;
+	  *(pbmpdata + (tLines + i * 3 + 1)) = (SANE_Byte) G;
+	  *(pbmpdata + (tLines + i * 3)) = (SANE_Byte) B;
+
+	}
+    }
+
+  DBG (DBG_FUNC, "AutoLevel: exit\n");
+  return;
+}
+
+#ifdef SANE_UNUSED
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Deal with image with auto level
+Parameters:
+	pDIB: the data of image
+	ImageWidth: the width of image
+	ImageHeight: the height of image
+Return value: 
+	none
+***********************************************************************/
+static void
+QBETDetectAutoLevel (void *pDIB, unsigned int ImageWidth, unsigned int ImageHeight)
+{
+  unsigned short *pbmpdata;
+  float fRPercent = 0.0;
+  float fGPercent = 0.0;
+  float fBPercent = 0.0;
+  float fRSum, fGSum, fBSum;
+
+  int i, j;
+  unsigned int tLines, CountPixels, TotalImgSize;
+  unsigned short R, G, B, max_R, max_G, max_B, min_R, min_G, min_B;
+  unsigned short wIndexR, wIndexG, wIndexB;
+  float fmax_R, fmax_G, fmax_B;
+  unsigned int sum_R = 0, sum_G = 0, sum_B = 0;
+  unsigned int hisgram_R[1024], hisgram_G[1024], hisgram_B[1024];
+
+  if (!pDIB)
+    {
+      return;
+    }
+
+  pbmpdata = (unsigned short *) pDIB;
+
+  CountPixels = 0;
+  TotalImgSize = ImageWidth * ImageHeight;
+
+
+  for (i = 0; i < 1024; i++)
+    {
+
+      hisgram_R[i] = 0;
+      hisgram_G[i] = 0;
+      hisgram_B[i] = 0;
+    }
+
+
+  /*Find min , max, mean */
+  max_R = max_G = max_B = 0;
+  min_R = min_G = min_B = 1023;
+  tLines = 0;
+
+  for (j = 0; j < (int) ImageHeight; j++)
+    {
+      tLines = j * ImageWidth * 3;
+      for (i = 0; i < (int) ImageWidth; i++)
+	{
+	  R = *(pbmpdata + (tLines + i * 3 + 2));
+	  G = *(pbmpdata + (tLines + i * 3 + 1));
+	  B = *(pbmpdata + (tLines + i * 3));
+
+	  max_R = _MAX (R, max_R);
+	  max_G = _MAX (G, max_G);
+	  max_B = _MAX (B, max_B);
+
+	  min_R = _MIN (R, min_R);
+	  min_G = _MIN (G, min_G);
+	  min_B = _MIN (B, min_B);
+
+	  hisgram_R[R]++;
+	  hisgram_G[G]++;
+	  hisgram_B[B]++;
+
+	  sum_R += R;
+	  sum_G += G;
+	  sum_B += B;
+
+	  *(pbmpdata + (tLines + i * 3 + 2)) = R;
+	  *(pbmpdata + (tLines + i * 3 + 1)) = G;
+	  *(pbmpdata + (tLines + i * 3)) = B;
+
+	  CountPixels++;
+	}
+
+    }
+
+
+  fRSum = 0.0;
+  fGSum = 0.0;
+  fBSum = 0.0;
+
+  wIndexR = 511;
+  wIndexG = 511;
+  wIndexB = 511;
+
+  for (i = 0; i < 1024; i++)
+    {
+      fRSum += (float) hisgram_R[i];
+      fRPercent = (fRSum / CountPixels) * 100;
+      if (fRPercent > 50)
+	{
+	  wIndexR = i;
+	  break;
+	}
+
+    }
+
+  for (i = 0; i < 1024; i++)
+    {
+      fGSum += (float) hisgram_G[i];
+      fGPercent = (fGSum / CountPixels) * 100;
+      if (fGPercent > 50)
+	{
+	  wIndexG = i;
+	  break;
+	}
+    }
+
+  for (i = 0; i < 1024; i++)
+    {
+      fBSum += (float) hisgram_B[i];
+      fBPercent = (fBSum / CountPixels) * 100;
+      if (fBPercent > 50)
+	{
+	  wIndexB = i;
+	  break;
+	}
+
+    }
+
+
+  fRSum = 0.0;
+
+  for (i = wIndexR; i >= 0; i--)
+    {
+      fRSum += (float) hisgram_R[i];
+      fRPercent = (fRSum / CountPixels) * 100;
+      if (fRPercent >= 48)
+	{
+	  min_R = i;
+	  break;
+	}
+
+    }
+
+  fRSum = 0.0;
+  for (i = wIndexR; i < 1024; i++)
+    {
+      fRSum += (float) hisgram_R[i];
+      fRPercent = (fRSum / CountPixels) * 100;
+      if (fRPercent >= 47)
+	{
+	  max_R = i;
+	  break;
+	}
+
+    }
+
+
+  fGSum = 0.0;
+  for (i = wIndexG; i >= 0; i--)
+    {
+      fGSum += (float) hisgram_G[i];
+      fGPercent = (fGSum / CountPixels) * 100;
+      if (fGPercent >= 48)
+	{
+	  min_G = i;
+	  break;
+	}
+
+    }
+
+  fGSum = 0.0;
+  for (i = wIndexG; i < 1024; i++)
+    {
+      fGSum += (float) hisgram_G[i];
+      fGPercent = (fGSum / CountPixels) * 100;
+      if (fGPercent >= 47)
+	{
+	  max_G = i;
+	  break;
+	}
+
+    }
+
+  fBSum = 0.0;
+  for (i = wIndexB; i >= 0; i--)
+    {
+      fBSum += (float) hisgram_B[i];
+      fBPercent = (fBSum / CountPixels) * 100;
+      if (fBPercent >= 46)
+	{
+	  min_B = i;
+	  break;
+	}
+
+    }
+
+  fBSum = 0.0;
+  for (i = wIndexB; i < 1024; i++)
+    {
+      fBSum += (float) hisgram_B[i];
+      fBPercent = (fBSum / CountPixels) * 100;
+      if (fBPercent >= 47)
+	{
+	  max_B = i;
+	  break;
+	}
+
+    }
+
+
+  /*Autolevel: */
+  sum_R = max_R - min_R;
+  sum_G = max_G - min_G;
+  sum_B = max_B - min_B;
+
+  for (j = 0; j < (int) ImageHeight; j++)
+    {
+      tLines = j * ImageWidth * 3;
+      for (i = 0; i < (int) ImageWidth; i++)
+	{
+	  R = *(pbmpdata + (tLines + i * 3 + 2));
+	  G = *(pbmpdata + (tLines + i * 3 + 1));
+	  B = *(pbmpdata + (tLines + i * 3));
+
+
+	   /*R*/ if (sum_R == 0)
+	    R = max_R;
+	  else if (R < min_R)
+	    {
+
+	      R = 0;
+	    }
+	  else if ((R >= min_R) && (R <= 1023))
+	    {
+	      fmax_R = ((float) ((R - min_R) * 923) / (float) sum_R) + 100;
+	      R = (unsigned short) fmax_R;
+	      fmax_R = (fmax_R - R) * 10;
+	      if (fmax_R >= 5)
+		R++;
+	    }
+	  if (R > 1023)
+	    R = 1023;
+
+	   /*G*/ if (sum_G == 0)
+	    G = max_G;
+	  else if (G < min_G)
+	    {
+
+	      G = 0;
+	    }
+	  else if ((G >= min_G) && (G <= 1023))
+	    {
+	      fmax_G = ((float) ((G - min_G) * 923) / (float) sum_G) + 100;
+	      G = (unsigned short) fmax_G;
+	      fmax_G = (fmax_G - G) * 10;
+	      if (fmax_G >= 5)
+		G++;
+	    }
+	  if (G > 1023)
+	    G = 1023;
+
+	   /*B*/ if (sum_B == 0)
+	    B = max_B;
+	  else if (B < min_R)
+	    {
+
+	      B = 0;
+	    }
+	  else if ((B >= min_B) && (R <= 1023))
+	    {
+	      fmax_B = ((float) (B - min_B) * 923 / (float) sum_B) + 100;
+
+	      B = (unsigned short) fmax_B;
+	      fmax_B = (fmax_B - B) * 10;
+	      if (fmax_B >= 5)
+		B++;
+	    }
+	  if (B > 1023)
+	    B = 1023;
+
+	  *(pbmpdata + (tLines + i * 3 + 2)) = R;
+	  *(pbmpdata + (tLines + i * 3 + 1)) = G;
+	  *(pbmpdata + (tLines + i * 3)) = B;
+
+	}
+    }
+
+  return;
+}
+#endif
+
+#ifdef SANE_UNUSED
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Change the image data and deal with auto level	
+Parameters:
+	lpSource: the data of image
+	scanMode: the scan mode
+	ScanLines: the rows of image
+	BytesPerLine: the bytes of per line
+Return value: 
+	none
+***********************************************************************/
+static void
+QBetChange (SANE_Byte *lpSource, SCANMODE scanMode, unsigned short ScanLines,
+	    unsigned int BytesPerLine)
+{
+  unsigned short i, j;
+  unsigned int tLines, TotalImgSize;
+  unsigned short R1, G1, B1, R, G, B, R2, G2, B2, QBET_RGB = 0, PointF, PointB;
+  unsigned short *pwRGB;
+
+  int k;
+
+  unsigned int ImageWidth = BytesPerLine / 3;
+  unsigned int ImageHeight = ScanLines;
+  SANE_Byte *pbmpdata = (SANE_Byte *) lpSource;
+
+  if (scanMode != CM_RGB24ext)
+    {
+      return;
+    }
+
+
+  TotalImgSize = ImageWidth * ImageHeight * 3 * 2;
+  if ((pwRGB = (unsigned short *) malloc (TotalImgSize)) == NULL)
+    {
+      return;
+    }
+
+
+  for (j = 0; j < ImageHeight; j++)
+    {
+      tLines = j * ImageWidth * 3;
+      for (i = 0; i < ImageWidth; i++)
+	{
+	  if (i == 0)
+	    {
+	      R1 = R = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 2));
+	      G1 = G = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 1));
+	      B1 = B = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3));
+	      R2 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i + 1) * 3 + 2));
+	      G2 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i + 1) * 3 + 1));
+	      B2 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i + 1) * 3));
+	    }
+	  else if (i == (ImageWidth - 1))
+	    {
+	      R1 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i - 1) * 3 + 2));
+	      G1 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i - 1) * 3 + 1));
+	      B1 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i - 1) * 3));
+	      R2 = R = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 2));
+	      G2 = G = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 1));
+	      B2 = B = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3));
+	    }
+	  else
+	    {
+	      R1 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i - 1) * 3 + 2));
+	      G1 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i - 1) * 3 + 1));
+	      B1 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i - 1) * 3));
+
+	      R = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 2));
+	      G = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3 + 1));
+	      B = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + i * 3));
+
+	      R2 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i + 1) * 3 + 2));
+	      G2 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i + 1) * 3 + 1));
+	      B2 = (unsigned short) (SANE_Byte) * (pbmpdata + (tLines + (i + 1) * 3));
+	    }
+
+	  R1 = R1 & 0x0003;
+	  G1 = G1 & 0x0003;
+	  B1 = B1 & 0x0003;
+
+	  R2 = R2 & 0x0003;
+	  G2 = G2 & 0x0003;
+	  B2 = B2 & 0x0003;
+	  for (k = 0; k < 3; k++)
+	    {
+	      if (k == 0)
+		{
+		  PointF = R1;
+		  PointB = R2;
+		}
+	      else if (k == 1)
+		{
+		  PointF = G1;
+		  PointB = G2;
+		}
+	      else if (k == 2)
+		{
+		  PointF = B1;
+		  PointB = B2;
+		}
+
+	      switch (PointF)
+		{
+		case 0:
+		case 1:
+		  if (PointB == 0)
+		    QBET_RGB = 0xFFFC;
+		  else if (PointB == 1)
+		    QBET_RGB = 0xFFFC;
+		  else if (PointB == 2)
+		    QBET_RGB = 0xFFFD;
+		  else if (PointB == 3)
+		    QBET_RGB = 0xFFFE;
+		  break;
+		case 2:
+		  if (PointB == 0)
+		    QBET_RGB = 0xFFFD;
+		  else if (PointB == 1)
+		    QBET_RGB = 0xFFFD;
+		  else if (PointB == 2)
+		    QBET_RGB = 0xFFFF;
+		  else if (PointB == 3)
+		    QBET_RGB = 0xFFFF;
+		  break;
+		case 3:
+		  if (PointB == 0)
+		    QBET_RGB = 0xFFFE;
+		  else if (PointB == 1)
+		    QBET_RGB = 0xFFFE;
+		  else if (PointB == 2)
+		    QBET_RGB = 0xFFFF;
+		  else if (PointB == 3)
+		    QBET_RGB = 0xFFFF;
+		  break;
+		default:
+		  break;
+		}
+
+	      if (k == 0)
+		{
+		  R = R << 2;
+		  R = R + 0x0003;
+		  R = R & QBET_RGB;
+		}
+	      else if (k == 1)
+		{
+		  G = G << 2;
+		  G = G + 0x0003;
+		  G = G & QBET_RGB;
+		}
+	      else if (k == 2)
+		{
+		  B = B << 2;
+		  B = B + 0x0003;
+		  B = B & QBET_RGB;
+		}
+
+	    }
+
+	  *(pwRGB + (tLines + i * 3 + 2)) = R;
+	  *(pwRGB + (tLines + i * 3 + 1)) = G;
+	  *(pwRGB + (tLines + i * 3)) = B;
+
+	}
+
+    }
+
+
+  QBETDetectAutoLevel (pwRGB, ImageWidth, ImageHeight);
+
+
+  for (j = 0; j < ImageHeight; j++)
+    {
+      tLines = j * ImageWidth * 3;
+
+      for (i = 0; i < ImageWidth; i++)
+	{
+	  R = *(pwRGB + (tLines + i * 3 + 2));
+	  G = *(pwRGB + (tLines + i * 3 + 1));
+	  B = *(pwRGB + (tLines + i * 3));
+
+	  R = R >> 2;
+	  G = G >> 2;
+
+	  B = B >> 2;
+	  if (R > 255)
+	    R = 255;
+	  if (G > 255)
+	    G = 255;
+	  if (B > 255)
+	    B = 255;
+
+	  *(pbmpdata + (tLines + i * 3 + 2)) = (SANE_Byte) R;
+	  *(pbmpdata + (tLines + i * 3 + 1)) = (SANE_Byte) G;
+	  *(pbmpdata + (tLines + i * 3)) = (SANE_Byte) B;
+
+	}
+
+    }
+
+
+  if (pwRGB != NULL)
+    {
+      free (pwRGB);
+    }
+
+  return;
+}
+#endif
+
+/****************************** SANE API functions *****************************/
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  DBG_INIT ();
+  DBG (DBG_FUNC, "sane_init: start\n");
+  DBG (DBG_ERR, "SANE Mustek USB2 backend version %d.%d build %d from %s\n",
+       SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING);
+
+  num_devices = 1;		/* HOLD: only one device in this backend */
+
+  if (version_code != NULL)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+
+  DBG (DBG_INFO, "sane_init: authorize %s null\n", authorize ? "!=" : "==");
+
+  DBG (DBG_FUNC, "sane_init: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+  DBG (DBG_FUNC, "sane_exit: start\n");
+
+  if (devlist != NULL)
+    {
+      free (devlist);
+      devlist = NULL;
+    }
+
+  devlist = NULL;
+  DBG (DBG_FUNC, "sane_exit: exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  SANE_Int dev_num;
+  DBG (DBG_FUNC, "sane_get_devices: start: local_only = %s\n",
+       local_only == SANE_TRUE ? "true" : "false");
+
+  if (devlist != NULL)
+    {
+      free (devlist);
+      devlist = NULL;
+    }
+
+  devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+  if (devlist == NULL)
+    return SANE_STATUS_NO_MEM;
+
+  dev_num = 0;
+  /* HOLD: This is ugly (only one scanner!) and should go to sane_init */
+  if (GetDeviceStatus ())
+    {
+      SANE_Device *sane_device;
+
+      sane_device = malloc (sizeof (*sane_device));
+      if (sane_device == NULL)
+	return SANE_STATUS_NO_MEM;
+      sane_device->name = strdup (device_name);
+      sane_device->vendor = strdup ("Mustek");
+      sane_device->model = strdup ("BearPaw 2448 TA Pro");
+      sane_device->type = strdup ("flatbed scanner");
+      devlist[dev_num++] = sane_device;
+    }
+  devlist[dev_num] = 0;
+  *device_list = devlist;
+  DBG (DBG_FUNC, "sane_get_devices: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+  Mustek_Scanner *s;
+
+  DBG (DBG_FUNC, "sane_open: start :devicename = %s\n", devicename);
+
+  if (!MustScanner_Init ())
+    {
+      return SANE_STATUS_INVAL;
+    }
+  if (!PowerControl (SANE_FALSE, SANE_FALSE))
+    {
+      return SANE_STATUS_INVAL;
+    }
+  if (!CarriageHome ())
+    {
+      return SANE_STATUS_INVAL;
+    }
+
+  s = malloc (sizeof (*s));
+  if (s == NULL)
+    return SANE_STATUS_NO_MEM;
+  memset (s, 0, sizeof (*s));
+
+  s->gamma_table = NULL;
+  memcpy (&s->model, &mustek_A2nu2_model, sizeof (Scanner_Model));
+  s->next = NULL;
+  s->bIsScanning = SANE_FALSE;
+  s->bIsReading = SANE_FALSE;
+
+  init_options (s);
+  *handle = s;
+
+  s->read_rows = 0;
+  s->scan_buffer_len = 0;
+
+  DBG (DBG_FUNC, "sane_open: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+
+void
+sane_close (SANE_Handle handle)
+{
+  Mustek_Scanner *s = handle;
+  DBG (DBG_FUNC, "sane_close: start\n");
+
+  PowerControl (SANE_FALSE, SANE_FALSE);
+
+  CarriageHome ();
+
+  if (NULL != g_pDeviceFile)
+    {
+      free (g_pDeviceFile);
+      g_pDeviceFile = NULL;
+    }
+
+  if (s->Scan_data_buf != NULL)
+    free (s->Scan_data_buf);
+
+  s->Scan_data_buf = NULL;
+
+  free (handle);
+
+  DBG (DBG_FUNC, "sane_close: exit\n");
+}
+
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  Mustek_Scanner *s = handle;
+
+  if ((unsigned) option >= NUM_OPTIONS)
+    return 0;
+  DBG (DBG_FUNC, "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)
+{
+  Mustek_Scanner *s = handle;
+  SANE_Status status;
+  SANE_Word cap;
+  SANE_Int myinfo = 0;
+
+  DBG (DBG_FUNC,
+       "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->bIsScanning)
+    {
+      DBG (DBG_ERR, "sane_control_option: don't call this function while "
+	   "scanning\n");
+      return SANE_STATUS_DEVICE_BUSY;
+    }
+  if (option >= NUM_OPTIONS || option < 0)
+    {
+      DBG (DBG_ERR,
+	   "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 (DBG_ERR, "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_PREVIEW:
+	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:
+	  strcpy (val, s->val[option].s);
+	  break;
+
+	case OPT_SOURCE:
+	  strcpy (val, s->val[option].s);
+	  break;
+	default:
+	  DBG (DBG_ERR, "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 (DBG_ERR, "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)
+	{
+	  /* (mostly) side-effect-free word options: */
+	case OPT_RESOLUTION:
+	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_THRESHOLD:
+	case OPT_AUTO_WARMUP:
+	case OPT_GAMMA_VALUE:
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+	  /* side-effect-free word-array options: */
+	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);
+	    }
+	  else
+	    {
+	      DISABLE (OPT_THRESHOLD);
+	    }
+	  RIE (calc_parameters (s));
+	  myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+	  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, "Reflective") == 0)
+		{
+		  PowerControl (SANE_TRUE, SANE_FALSE);
+		  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 ("Color24");
+		  x_range.max = s->model.x_size;
+		  y_range.max = s->model.y_size;
+		}
+	      else if (0 == strcmp (s->val[option].s, "Negative"))
+		{
+		  PowerControl (SANE_FALSE, SANE_TRUE);
+		  s->opt[OPT_MODE].size =
+		    max_string_size (negative_mode_list);
+		  s->opt[OPT_MODE].constraint.string_list =
+		    negative_mode_list;
+		  s->val[OPT_MODE].s = strdup ("Color24");
+		  x_range.max = s->model.x_size_ta;
+		  y_range.max = s->model.y_size_ta;
+		}
+	      else if (0 == strcmp (s->val[option].s, "Positive"))
+		{
+		  PowerControl (SANE_FALSE, SANE_TRUE);
+		  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 ("Color24");
+		  x_range.max = s->model.x_size_ta;
+		  y_range.max = s->model.y_size_ta;
+		}
+	    }
+	  myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+	  break;
+	default:
+	  DBG (DBG_ERR, "sane_control_option: can't set unknown option %d\n",
+	       option);
+	}
+    }
+  else
+    {
+      DBG (DBG_ERR, "sane_control_option: unknown action %d for option %d\n",
+	   action, option);
+      return SANE_STATUS_INVAL;
+    }
+  if (info)
+    *info = myinfo;
+
+  DBG (DBG_FUNC, "sane_control_option: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  Mustek_Scanner *s = handle;
+
+  DBG (DBG_FUNC, "sane_get_parameters: start\n");
+
+  DBG (DBG_INFO, "sane_get_parameters :params.format = %d\n",
+       s->params.format);
+
+  DBG (DBG_INFO, "sane_get_parameters :params.depth = %d\n", s->params.depth);
+  DBG (DBG_INFO, "sane_get_parameters :params.pixels_per_line = %d\n",
+       s->params.pixels_per_line);
+  DBG (DBG_INFO, "sane_get_parameters :params.bytes_per_line = %d\n",
+       s->params.bytes_per_line);
+  DBG (DBG_INFO, "sane_get_parameters :params.lines = %d\n", s->params.lines);
+  if (params != NULL)
+    *params = s->params;
+
+  DBG (DBG_FUNC, "sane_get_parameters: exit\n");
+
+  return SANE_STATUS_GOOD;
+
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  int i;
+  Mustek_Scanner *s = handle;
+
+  DBG (DBG_FUNC, "sane_start: start\n");
+
+  s->scan_buffer_len = 0;
+
+  calc_parameters (s);
+
+  if (s->val[OPT_TL_X].w >= s->val[OPT_BR_X].w)
+    {
+      DBG (DBG_CRIT,
+	   "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 (DBG_CRIT,
+	   "sane_start: top left y >= bottom right y --- exiting\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  s->setpara.pGammaTable = NULL;
+
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.fmArea.x1=%d\n",
+       s->setpara.fmArea.x1);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.fmArea.x2=%d\n",
+       s->setpara.fmArea.x2);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.fmArea.y1=%d\n",
+       s->setpara.fmArea.y1);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.fmArea.y2=%d\n",
+       s->setpara.fmArea.y2);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.pfPixelFlavor=%d\n",
+       s->setpara.pfPixelFlavor);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.wLinearThreshold=%d\n",
+       s->setpara.wLinearThreshold);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.wTargetDPI=%d\n",
+       s->setpara.wTargetDPI);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.smScanMode=%d\n",
+       s->setpara.smScanMode);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.ssScanSource =%d\n",
+       s->setpara.ssScanSource);
+  DBG (DBG_INFO, "Sane_start:setpara ,setpara.pGammaTable =%p\n",
+       (void *) s->setpara.pGammaTable);
+
+  SetParameters (&s->setpara);
+
+  GetParameters (&s->getpara);
+
+  switch (s->params.format)
+    {
+    case SANE_FRAME_RGB:
+      if (s->params.depth == 8)
+
+	s->params.pixels_per_line = s->getpara.dwLineByteWidth / 3;
+      if (s->params.depth == 16)
+	s->params.pixels_per_line = s->getpara.dwLineByteWidth / 6;
+
+
+      break;
+    case SANE_FRAME_GRAY:
+      if (s->params.depth == 1)
+	s->params.pixels_per_line = s->getpara.dwLineByteWidth * 8;
+      if (s->params.depth == 8)
+	s->params.pixels_per_line = s->getpara.dwLineByteWidth;
+      if (s->params.depth == 16)
+	s->params.pixels_per_line = s->getpara.dwLineByteWidth / 2;
+      break;
+    default:
+      DBG (DBG_INFO, "sane_start: sane_params.format = %d\n",
+	   s->params.format);
+    }
+
+  s->params.bytes_per_line = s->getpara.dwLineByteWidth;
+  s->params.lines = s->getpara.dwLength;
+
+  s->params.last_frame = TRUE;
+
+
+  s->read_rows = s->getpara.dwLength;
+  DBG (DBG_INFO, "sane_start : read_rows = %d\n", s->read_rows);
+
+  /*warmming up */
+  if (s->val[OPT_AUTO_WARMUP].w)
+    {
+      for (i = 30; i > 0; i--)
+	{
+	  sleep (1);
+	  DBG (DBG_ERR, "warming up: %d\n", i);
+	}
+    }
+  DBG (DBG_INFO, "SCANNING ... \n");
+
+  s->bIsScanning = SANE_TRUE;
+  if (s->Scan_data_buf != NULL)
+    free (s->Scan_data_buf);
+  s->Scan_data_buf = NULL;
+
+  s->Scan_data_buf = malloc (SCAN_BUFFER_SIZE * sizeof (SANE_Byte));
+  if (s->Scan_data_buf == NULL)
+    return SANE_STATUS_NO_MEM;
+
+  StartScan ();
+
+  DBG (DBG_FUNC, "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)
+{
+
+  Mustek_Scanner *s = handle;
+  static SANE_Byte *tempbuf;
+  SANE_Int lines_to_read, lines_read;
+  IMAGEROWS image_row;
+
+  int maxbuffersize = max_len;
+
+  DBG (DBG_FUNC, "sane_read: start: max_len=%d\n", max_len);
+
+  if (s == NULL)
+    {
+      DBG (DBG_ERR, "sane_read: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (buf == NULL)
+    {
+      DBG (DBG_ERR, "sane_read: buf is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (len == NULL)
+    {
+      DBG (DBG_ERR, "sane_read: len is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+  *len = 0;
+  if (!s->bIsScanning)
+    {
+      DBG (DBG_WARN, "sane_read: scan was cancelled, is over or has not been "
+	   "initiated yet\n");
+      return SANE_STATUS_CANCELLED;
+    }
+  DBG (DBG_DBG, "sane_read: before read data read_row=%d\n", s->read_rows);
+  if (s->scan_buffer_len == 0)
+    {
+      if (s->read_rows > 0)
+	{
+	  lines_to_read = SCAN_BUFFER_SIZE / s->getpara.dwLineByteWidth;
+
+	  if (lines_to_read > s->read_rows)
+	    lines_to_read = s->read_rows;
+
+	  tempbuf =
+	    (SANE_Byte *) malloc (sizeof (SANE_Byte) * lines_to_read *
+			     s->getpara.dwLineByteWidth + 3 * 1024 + 1);
+	  memset (tempbuf, 0,
+		  sizeof (SANE_Byte) * lines_to_read * s->getpara.dwLineByteWidth +
+		  3 * 1024 + 1);
+
+	  DBG (DBG_INFO, "sane_read: buffer size is %ld\n",
+	       (long int) sizeof (SANE_Byte) * lines_to_read * s->getpara.dwLineByteWidth +
+	       3 * 1024 + 1);
+
+	  image_row.roRgbOrder = mustek_A2nu2_model.line_mode_color_order;
+	  image_row.wWantedLineNum = lines_to_read;
+	  image_row.pBuffer = (SANE_Byte *) tempbuf;
+	  s->bIsReading = SANE_TRUE;
+
+	  if (!ReadScannedData (&image_row))
+	    {
+	      DBG (DBG_ERR, "sane_read: ReadScannedData error\n");
+	      s->bIsReading = SANE_FALSE;
+	      return SANE_STATUS_INVAL;
+	    }
+
+	  DBG (DBG_DBG, "sane_read: Finish ReadScanedData\n");
+	  s->bIsReading = SANE_FALSE;
+	  memset (s->Scan_data_buf, 0, SCAN_BUFFER_SIZE);
+	  s->scan_buffer_len =
+	    image_row.wXferedLineNum * s->getpara.dwLineByteWidth;
+	  DBG (DBG_INFO, "sane_read : s->scan_buffer_len = %ld\n",
+	       (long int) s->scan_buffer_len);
+
+	  memcpy (s->Scan_data_buf, tempbuf, s->scan_buffer_len);
+
+	  DBG (DBG_DBG, "sane_read :after memcpy\n");
+	  free (tempbuf);
+	  s->Scan_data_buf_start = s->Scan_data_buf;
+	  s->read_rows -= image_row.wXferedLineNum;
+
+	}
+      else
+	{
+	  DBG (DBG_FUNC, "sane_read: scan finished -- exit\n");
+	  sane_cancel (handle);
+	  return SANE_STATUS_EOF;
+	}
+    }
+  if (s->scan_buffer_len == 0)
+    {
+      DBG (DBG_FUNC, "sane_read: scan finished -- exit\n");
+      sane_cancel (handle);
+      return SANE_STATUS_EOF;
+    }
+
+
+
+
+  lines_read =
+    (maxbuffersize <
+     (SANE_Int) s->scan_buffer_len) ? maxbuffersize : (SANE_Int) s->scan_buffer_len;
+  DBG (DBG_DBG, "sane_read: after %d\n", lines_read);
+
+  *len = (SANE_Int) lines_read;
+
+  DBG (DBG_INFO, "sane_read : get lines_read = %d\n", lines_read);
+  DBG (DBG_INFO, "sane_read : get *len = %d\n", *len);
+  memcpy (buf, s->Scan_data_buf_start, lines_read);
+
+  s->scan_buffer_len -= lines_read;
+  s->Scan_data_buf_start += lines_read;
+  DBG (DBG_FUNC, "sane_read: exit\n");
+  return SANE_STATUS_GOOD;
+
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  Mustek_Scanner *s = handle;
+  int i;
+  DBG (DBG_FUNC, "sane_cancel: start\n");
+  if (s->bIsScanning)
+    {
+      s->bIsScanning = SANE_FALSE;
+      if (s->read_rows > 0)
+	{
+	  DBG (DBG_INFO, "sane_cancel: warning: is scanning\n");
+
+	}
+      else
+	{
+	  DBG (DBG_INFO, "sane_cancel: Scan finished\n");
+	}
+
+      StopScan ();
+
+      CarriageHome ();
+      for (i = 0; i < 20; i++)
+	{
+	  if (s->bIsReading == SANE_FALSE)
+	    {
+	      if (s->gamma_table != NULL)
+		{
+		  free (s->gamma_table);
+		  s->gamma_table = NULL;
+		  break;
+		}
+	    }
+	  else
+	    sleep (1);
+	}
+      if (s->Scan_data_buf != NULL)
+	{
+	  free (s->Scan_data_buf);
+	  s->Scan_data_buf = NULL;
+	  s->Scan_data_buf_start = NULL;
+	}
+
+      s->read_rows = 0;
+      s->scan_buffer_len = 0;
+      memset (&s->setpara, 0, sizeof (s->setpara));
+      memset (&s->getpara, 0, sizeof (s->getpara));
+
+    }
+  else
+    {
+      DBG (DBG_INFO, "sane_cancel: do nothing\n");
+    }
+
+
+  DBG (DBG_FUNC, "sane_cancel: exit\n");
+
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  Mustek_Scanner *s = handle;
+  DBG (DBG_FUNC, "sane_set_io_mode: handle = %p, non_blocking = %s\n",
+       handle, non_blocking == SANE_TRUE ? "true" : "false");
+  if (!s->bIsScanning)
+    {
+      DBG (DBG_WARN, "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)
+{
+  Mustek_Scanner *s = handle;
+  DBG (DBG_FUNC, "sane_get_select_fd: handle = %p, fd = %p\n", handle,
+       (void *) fd);
+  if (!s->bIsScanning)
+    {
+      DBG (DBG_WARN, "%s", "sane_get_select_fd: not scanning\n");
+      return SANE_STATUS_INVAL;
+    }
+  return SANE_STATUS_UNSUPPORTED;
+}