Initial import of sane-backends version 1.0.24-1.2

1 files changed, 1943 insertions, 0 deletions

diff --git a/backend/mustek_usb2_reflective.c b/backend/mustek_usb2_reflective.c
new file mode 100644
index 0000000..7bf954c
--- /dev/null
+++ b/backend/mustek_usb2_reflective.c
@@ -0,0 +1,1943 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2005 Mustek.
+   Originally maintained by Mustek
+   Author:Jack Roy 2005.5.24
+
+   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. */
+
+/* forward declarations */
+
+static SANE_Bool Reflective_Reset (void);
+static SANE_Bool Reflective_ScanSuggest (PTARGETIMAGE pTarget, PSUGGESTSETTING pSuggest);
+static SANE_Bool Reflective_SetupScan (COLORMODE ColorMode, unsigned short XDpi, unsigned short YDpi,
+				  SANE_Bool isInvert, unsigned short X, unsigned short Y, unsigned short Width,
+				  unsigned short Height);
+static SANE_Bool Reflective_StopScan (void);
+static SANE_Bool Reflective_GetRows (SANE_Byte * lpBlock, unsigned short * Rows, SANE_Bool isOrderInvert);
+static SANE_Bool Reflective_AdjustAD (void);
+static SANE_Bool Reflective_FindTopLeft (unsigned short * lpwStartX, unsigned short * lpwStartY);
+static SANE_Bool Reflective_LineCalibration16Bits (void);
+static SANE_Bool Reflective_PrepareScan (void);
+
+/*function description*/
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	reset the scanner status
+Parameters:
+	none
+Return value: 
+	if operation is success
+	return TRUE
+	els
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_Reset ()
+{
+  DBG (DBG_FUNC, "Reflective_Reset: call in\n");
+
+  if (g_bOpened)
+    {
+      DBG (DBG_FUNC, "Reflective_Reset: scanner has been opened\n");
+      return FALSE;
+    }
+
+  if (STATUS_GOOD != Asic_Open (&g_chip, g_pDeviceFile))
+    {
+      DBG (DBG_FUNC, "Reflective_Reset: Asic_Open return error\n");
+      return FALSE;
+    }
+
+  if (STATUS_GOOD != Asic_Reset (&g_chip))
+    {
+      DBG (DBG_FUNC, "Reflective_Reset: Asic_Reset return error\n");
+      return FALSE;
+    }
+
+  if (STATUS_GOOD != Asic_SetSource (&g_chip, LS_REFLECTIVE))
+    {
+      DBG (DBG_FUNC, "Reflective_Reset: Asic_SetSource return error\n");
+      return FALSE;
+    }
+
+  if (STATUS_GOOD != Asic_TurnLamp (&g_chip, TRUE))
+    {
+      DBG (DBG_FUNC, "Reflective_Reset: Asic_TurnLamp return error\n");
+      return FALSE;
+    }
+
+  if (STATUS_GOOD != Asic_Close (&g_chip))
+    {
+      DBG (DBG_FUNC, "Reflective_Reset: Asic_Close return error\n");
+      return FALSE;
+    }
+
+  g_Y = 0;
+  g_X = 0;
+  g_Width = 0;
+  g_SWWidth = 0;
+  g_Height = 0;
+  g_SWHeight = 0;
+
+  g_wLineartThreshold = 128;
+  g_dwTotalTotalXferLines = 0;
+  g_bFirstReadImage = TRUE;
+
+  g_pGammaTable = NULL;
+
+  if (NULL != g_pDeviceFile)
+    {
+      free (g_pDeviceFile);
+      g_pDeviceFile = NULL;
+    }
+
+  DBG (DBG_FUNC, "Reflective_Reset: exit\n");
+
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	get the suggest parameter of scaning
+Parameters:
+	pTarget: the information of scaning
+	pSuggest: suggest parameter of scaning
+Return value: 
+	if the operation is success
+	return TRUE
+	els
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_ScanSuggest (PTARGETIMAGE pTarget, PSUGGESTSETTING pSuggest)
+{
+  int i;
+  unsigned short wMaxWidth, wMaxHeight;
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: call in\n");
+
+  if (NULL == pTarget || NULL == pSuggest)
+    {
+      DBG (DBG_FUNC, "Reflective_ScanSuggest: parameters error\n");
+      return FALSE;
+    }
+
+  /*1. Looking up Optical Y Resolution */
+  for (i = 0; s_wOpticalYDpi[i] != 0; i++)
+    {
+      if (s_wOpticalYDpi[i] <= pTarget->wDpi)
+	{
+	  pSuggest->wYDpi = s_wOpticalYDpi[i];
+	  break;
+	}
+    }
+  if (s_wOpticalYDpi[i] == 0)
+    {
+      i--;
+      pSuggest->wYDpi = s_wOpticalYDpi[i];
+    }
+
+  /*2. Looking up Optical X Resolution */
+  for (i = 0; s_wOpticalXDpi[i] != 0; i++)
+    {
+      if (s_wOpticalXDpi[i] <= pTarget->wDpi)
+	{
+	  pSuggest->wXDpi = s_wOpticalXDpi[i];
+	  break;
+	}
+    }
+  if (s_wOpticalXDpi[i] == 0)
+    {
+      i--;
+      pSuggest->wXDpi = s_wOpticalXDpi[i];
+    }
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pTarget->wDpi = %d\n",
+       pTarget->wDpi);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->wXDpi = %d\n",
+       pSuggest->wXDpi);
+
+
+
+
+
+
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->wYDpi = %d\n",
+       pSuggest->wYDpi);
+
+  /*3. suggest scan area */
+  pSuggest->wX =
+    (unsigned short) (((unsigned int) (pTarget->wX) * (unsigned int) (pSuggest->wXDpi)) /
+	    (unsigned int) (pTarget->wDpi));
+  pSuggest->wY =
+    (unsigned short) (((unsigned int) (pTarget->wY) * (unsigned int) (pSuggest->wYDpi)) /
+	    (unsigned int) (pTarget->wDpi));
+  pSuggest->wWidth =
+    (unsigned short) (((unsigned int) (pTarget->wWidth) * (unsigned int) (pSuggest->wXDpi)) /
+	    (unsigned int) (pTarget->wDpi));
+  pSuggest->wHeight =
+    (unsigned short) (((unsigned int) (pTarget->wHeight) * (unsigned int) (pSuggest->wYDpi)) /
+	    (unsigned int) (pTarget->wDpi));
+
+  pSuggest->wWidth = (pSuggest->wWidth / 2) * 2;
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pTarget->wX = %d\n", pTarget->wX);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pTarget->wY = %d\n", pTarget->wY);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pTarget->wWidth = %d\n",
+       pTarget->wWidth);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pTarget->wHeight = %d\n",
+       pTarget->wHeight);
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->wX = %d\n", pSuggest->wX);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->wY = %d\n", pSuggest->wY);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->wWidth = %d\n",
+       pSuggest->wWidth);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->wHeight = %d\n",
+       pSuggest->wHeight);
+
+  if (pTarget->cmColorMode == CM_TEXT)
+    {
+      pSuggest->wWidth = ((pSuggest->wWidth + 7) >> 3) << 3;
+      if (pSuggest->wWidth < 8)
+	pSuggest->wWidth = 8;
+    }
+
+  /*4. check width and height */
+  wMaxWidth = (MAX_SCANNING_WIDTH * pSuggest->wXDpi) / 300;
+  wMaxHeight = (3480 * pSuggest->wYDpi) / 300;	/* 3480 for bumping */
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: wMaxWidth = %d\n", wMaxWidth);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: wMaxHeight = %d\n", wMaxHeight);
+
+  if (CM_TEXT == pTarget->cmColorMode)
+    {
+      wMaxWidth = (wMaxWidth >> 3) << 3;
+    }
+  if (pSuggest->wWidth > wMaxWidth)
+    {
+      pSuggest->wWidth = wMaxWidth;
+    }
+
+
+  if (pSuggest->wHeight > wMaxHeight)
+    {
+      pSuggest->wHeight = wMaxHeight;
+    }
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: g_Width=%d\n", g_Width);
+
+  g_Width = ((pSuggest->wWidth + 15) >> 4) << 4;	/*Real Scan Width */
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: again, g_Width=%d\n", g_Width);
+
+  g_Height = pSuggest->wHeight;
+
+  if (pTarget->isOptimalSpeed)
+    {
+      switch (pTarget->cmColorMode)
+	{
+	case CM_RGB48:
+	  pSuggest->cmScanMode = CM_RGB48;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 6);
+	  break;
+	case CM_RGB24:
+	  pSuggest->cmScanMode = CM_RGB24ext;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 3);
+	  break;
+	case CM_GRAY16:
+	  pSuggest->cmScanMode = CM_GRAY16ext;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 2);
+	  break;
+	case CM_GRAY8:
+	  pSuggest->cmScanMode = CM_GRAY8ext;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth));
+	  break;
+	case CM_TEXT:
+	  pSuggest->cmScanMode = CM_TEXT;
+	  pSuggest->dwBytesPerRow = (unsigned int) (pSuggest->wWidth) / 8;
+	  break;
+	default:
+	  break;
+	}
+    }
+  else
+    {
+      switch (pTarget->cmColorMode)
+	{
+	case CM_RGB48:
+	  pSuggest->cmScanMode = CM_RGB48;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 6);
+	  break;
+	case CM_RGB24:
+	  pSuggest->cmScanMode = CM_RGB24ext;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 3);
+	  break;
+	case CM_GRAY16:
+	  pSuggest->cmScanMode = CM_GRAY16ext;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 2);
+	  break;
+	case CM_GRAY8:
+	  pSuggest->cmScanMode = CM_GRAY8ext;
+	  pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth));
+	  break;
+	case CM_TEXT:
+	  pSuggest->cmScanMode = CM_TEXT;
+	  pSuggest->dwBytesPerRow = (unsigned int) (pSuggest->wWidth) / 8;
+	  break;
+	default:
+	  break;
+	}
+    }
+
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: pSuggest->dwBytesPerRow = %d\n",
+       pSuggest->dwBytesPerRow);
+  DBG (DBG_FUNC, "Reflective_ScanSuggest: leave Reflective_ScanSuggest\n");
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack            Date: 2005/05/13
+Routine Description: 
+	setup scanning process
+Parameters:
+	ColorMode: ScanMode of Scanning, CM_RGB48, CM_GRAY and so on
+	XDpi: X Resolution
+	YDpi: Y Resolution
+	isInvert: the RGB order
+	X: X start coordinate
+	Y: Y start coordinate
+	Width: Width of Scan Image
+	Height: Height of Scan Image
+Return value: 
+	if the operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_SetupScan (COLORMODE ColorMode,
+		      unsigned short XDpi,
+		      unsigned short YDpi,
+		      SANE_Bool isInvert, unsigned short X, unsigned short Y, unsigned short Width, unsigned short Height)
+{
+  isInvert = isInvert;
+  DBG (DBG_FUNC, "Reflective_SetupScan: Call in\n");
+  if (g_bOpened)
+    {
+      DBG (DBG_FUNC, "Reflective_SetupScan: scanner has been opened\n");
+      return FALSE;
+    }
+  if (!g_bPrepared)
+    {
+      DBG (DBG_FUNC, "Reflective_SetupScan: scanner not prepared\n");
+      return FALSE;
+    }
+
+  g_ScanMode = ColorMode;
+  g_XDpi = XDpi;
+  g_YDpi = YDpi;
+  g_SWWidth = Width;
+  g_SWHeight = Height;
+
+  switch (g_YDpi)
+    {
+    case 1200:
+      g_wPixelDistance = 4;	/*even & odd sensor problem */
+      g_wLineDistance = 24;
+      g_Height += g_wPixelDistance;
+      break;
+    case 600:
+      g_wPixelDistance = 0;	/*no even & odd problem */
+      g_wLineDistance = 12;
+      break;
+    case 300:
+      g_wPixelDistance = 0;
+      g_wLineDistance = 6;
+      break;
+    case 150:
+      g_wPixelDistance = 0;
+      g_wLineDistance = 3;
+      break;
+
+    case 75:
+    case 50:
+      g_wPixelDistance = 0;
+      g_wLineDistance = 1;
+      break;
+    default:
+      g_wLineDistance = 0;
+    }
+
+  switch (g_ScanMode)
+    {
+    case CM_RGB48:
+      g_BytesPerRow = 6 * g_Width;
+      g_SWBytesPerRow = 6 * g_SWWidth;
+      g_bScanBits = 48;
+      g_Height += g_wLineDistance * 2;	/*add height to do line distance */
+      break;
+    case CM_RGB24ext:
+      g_BytesPerRow = 3 * g_Width;
+      g_SWBytesPerRow = 3 * g_SWWidth;
+      g_bScanBits = 24;
+      g_Height += g_wLineDistance * 2;	/*add height to do line distance */
+      break;
+    case CM_GRAY16ext:
+      g_BytesPerRow = 2 * g_Width;
+      g_SWBytesPerRow = 2 * g_SWWidth;
+      g_bScanBits = 16;
+      break;
+    case CM_GRAY8ext:
+    case CM_TEXT:
+      g_BytesPerRow = g_Width;
+      g_SWBytesPerRow = g_SWWidth;
+      g_bScanBits = 8;
+      break;
+    default:
+      break;
+    }
+
+  if (Asic_Open (&g_chip, g_pDeviceFile) != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC, "Reflective_SetupScan: Asic_Open return error\n");
+      return FALSE;
+    }
+
+  DBG (DBG_FUNC, "Reflective_SetupScan: Asic_Open successfully\n");
+
+  g_bOpened = TRUE;
+
+  Asic_TurnLamp (&g_chip, FALSE);
+  Asic_TurnTA (&g_chip, FALSE);
+  Asic_TurnLamp (&g_chip, TRUE);
+
+  if (1200 == g_XDpi)
+    {
+      g_XDpi = 600;
+
+      if (Reflective_AdjustAD () == FALSE)
+	{
+
+	  DBG (DBG_FUNC,
+	       "Reflective_SetupScan: Reflective_AdjustAD return error\n");
+	  return FALSE;
+	}
+      DBG (DBG_FUNC,
+	   "Reflective_SetupScan: Reflective_AdjustAD successfully\n");
+
+      if (Reflective_FindTopLeft (&g_X, &g_Y) == FALSE)
+	{
+	  g_X = 187;
+	  g_Y = 43;
+	}
+
+      g_XDpi = 1200;
+
+      if (Reflective_AdjustAD () == FALSE)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_SetupScan: Reflective_AdjustAD return error\n");
+	  return FALSE;
+	}
+      DBG (DBG_FUNC,
+	   "Reflective_SetupScan: Reflective_AdjustAD successfully\n");
+    }
+  else
+    {
+      if (Reflective_AdjustAD () == FALSE)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_SetupScan: Reflective_AdjustAD return error\n");
+	  return FALSE;
+	}
+      DBG (DBG_FUNC,
+	   "Reflective_SetupScan: Reflective_AdjustAD successfully\n");
+      if (Reflective_FindTopLeft (&g_X, &g_Y) == FALSE)
+	{
+	  g_X = 187;
+	  g_Y = 43;
+	}
+    }
+
+
+  DBG (DBG_FUNC, "after find top left,g_X=%d,g_Y=%d\n", g_X, g_Y);
+
+  if (1200 == g_XDpi)
+    {
+      g_X =
+	g_X * 1200 / FIND_LEFT_TOP_CALIBRATE_RESOLUTION + X * 1200 / g_XDpi +
+	47;
+
+    }
+  else
+    {
+      if (75 == g_XDpi)
+	{
+	  g_X = g_X + X * 600 / g_XDpi;
+	}
+      else
+	{
+	  g_X = g_X + X * 600 / g_XDpi + 23;
+	}
+    }
+
+  g_Y =
+    g_Y * 1200 / FIND_LEFT_TOP_CALIBRATE_RESOLUTION + Y * 1200 / g_YDpi + 47;
+
+
+  DBG (DBG_FUNC, "before line calibration,g_X=%d,g_Y=%d\n", g_X, g_Y);
+
+  if (Reflective_LineCalibration16Bits () == FALSE)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_SetupScan: Reflective_LineCalibration16Bits return error\n");
+      return FALSE;
+    }
+
+  DBG (DBG_FUNC,
+       "Reflective_SetupScan: after Reflective_LineCalibration16Bits,g_X=%d,g_Y=%d\n",
+       g_X, g_Y);
+
+  DBG (DBG_FUNC, "Reflective_SetupScan: before Asic_SetWindow\n");
+
+  DBG (DBG_FUNC,
+       "Reflective_SetupScan: g_bScanBits=%d, g_XDpi=%d, g_YDpi=%d, g_X=%d, g_Y=%d, g_Width=%d, g_Height=%d\n",
+       g_bScanBits, g_XDpi, g_YDpi, g_X, g_Y, g_Width, g_Height);
+
+  if (g_Y > 300)
+    {
+      Asic_MotorMove (&g_chip, TRUE, g_Y - 300);
+    }
+  else
+    {
+      Asic_MotorMove (&g_chip, FALSE, 300 - g_Y);
+    }
+  g_Y = 300;
+
+  Asic_SetWindow (&g_chip, g_bScanBits, g_XDpi, g_YDpi, g_X, g_Y, g_Width,
+		  g_Height);
+
+  DBG (DBG_FUNC, "Reflective_SetupScan: leave Reflective_SetupScan\n");
+  return Reflective_PrepareScan ();
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/13
+Routine Description: 
+	To adjust the value of offset gain of R/G/B
+Parameters:
+	none
+Return value: 
+	if operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_AdjustAD ()
+{
+  SANE_Byte * lpCalData;
+  unsigned short wCalWidth;
+  int nTimesOfCal;
+  unsigned short wMaxValueR, wMinValueR, wMaxValueG, wMinValueG, wMaxValueB, wMinValueB;
+#if 0
+  SANE_Byte bDarkMaxLevel;
+  SANE_Byte bDarkMinLevel;
+  SANE_Byte bLastMinR, bLastROffset, bROffsetUpperBound = 255, bROffsetLowerBound =
+    0;
+  SANE_Byte bLastMinG, bLastGOffset, bGOffsetUpperBound = 255, bGOffsetLowerBound =
+    0;
+  SANE_Byte bLastMinB, bLastBOffset, bBOffsetUpperBound = 255, bBOffsetLowerBound =
+    0;
+  float fRFactor = 1.0;
+  float fGFactor = 1.0;
+  float fBFactor = 1.0;
+#endif
+  unsigned short wAdjustADResolution;
+
+  DBG (DBG_FUNC, "Reflective_AdjustAD: call in\n");
+  if (!g_bOpened)
+    {
+      DBG (DBG_FUNC, "Reflective_AdjustAD: scanner has been opened\n");
+      return FALSE;
+    }
+  if (!g_bPrepared)
+    {
+      DBG (DBG_FUNC, "Reflective_AdjustAD: scanner not prepared\n");
+      return FALSE;
+    }
+
+
+  g_chip.AD.DirectionR = R_DIRECTION;
+  g_chip.AD.DirectionG = G_DIRECTION;
+  g_chip.AD.DirectionB = B_DIRECTION;
+  g_chip.AD.GainR = R_GAIN;
+  g_chip.AD.GainG = G_GAIN;
+  g_chip.AD.GainB = B_GAIN;
+  g_chip.AD.OffsetR = 152;
+  g_chip.AD.OffsetG = 56;
+  g_chip.AD.OffsetB = 8;
+
+  if (g_XDpi <= 600)
+    {
+      wAdjustADResolution = 600;
+    }
+  else
+    {
+      wAdjustADResolution = 1200;
+    }
+  wCalWidth = 10240;
+
+  lpCalData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * wCalWidth * 3);
+  if (lpCalData == NULL)
+    {
+      DBG (DBG_FUNC, "Reflective_AdjustAD: lpCalData malloc error\n");
+      return FALSE;
+    }
+
+  Asic_SetMotorType (&g_chip, FALSE, TRUE);
+
+  Asic_SetCalibrate (&g_chip, 24, wAdjustADResolution, wAdjustADResolution, 0,
+		     0, wCalWidth, 1, FALSE);
+  MustScanner_PrepareCalculateMaxMin (wAdjustADResolution);
+  nTimesOfCal = 0;
+
+#ifdef DEBUG_SAVE_IMAGE
+  Asic_SetAFEGainOffset (&g_chip);
+  Asic_ScanStart (&g_chip);
+  Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24);
+  Asic_ScanStop (&g_chip);
+
+  FILE *stream = NULL;
+  SANE_Byte * lpBuf = (SANE_Byte *) malloc (50);
+  if (NULL == lpBuf)
+    {
+      return FALSE;
+    }
+  memset (lpBuf, 0, 50);
+
+  stream = fopen ("/root/AD(Ref).pnm\n", "wb+\n");
+  sprintf (lpBuf, "P6\n%d %d\n255\n\n", wCalWidth, 1);
+  fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream);
+  fwrite (lpCalData, sizeof (SANE_Byte), wCalWidth * 3, stream);
+  fclose (stream);
+  free (lpBuf);
+#endif
+
+  do
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_AdjustAD: run in first adjust offset do-while\n");
+      Asic_SetAFEGainOffset (&g_chip);
+      Asic_ScanStart (&g_chip);
+      Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24);
+      Asic_ScanStop (&g_chip);
+
+      MustScanner_CalculateMaxMin (lpCalData, &wMaxValueR, &wMinValueR,
+				   wAdjustADResolution);
+      MustScanner_CalculateMaxMin (lpCalData + wCalWidth, &wMaxValueG,
+				   &wMinValueG, wAdjustADResolution);
+      MustScanner_CalculateMaxMin (lpCalData + wCalWidth * 2, &wMaxValueB,
+				   &wMinValueB, wAdjustADResolution);
+
+      if (g_chip.AD.DirectionR == 0)
+	{
+	  if (wMinValueR > 15)
+	    {
+	      if (g_chip.AD.OffsetR < 8)
+		g_chip.AD.DirectionR = 1;
+	      else
+		g_chip.AD.OffsetR -= 8;
+	    }
+	  else if (wMinValueR < 5)
+	    g_chip.AD.OffsetR += 8;
+	}
+      else
+	{
+	  if (wMinValueR > 15)
+	    g_chip.AD.OffsetR += 8;
+	  else if (wMinValueR < 5)
+	    g_chip.AD.OffsetR -= 8;
+	}
+
+      if (g_chip.AD.DirectionG == 0)
+	{
+	  if (wMinValueG > 15)
+	    {
+	      if (g_chip.AD.OffsetG < 8)
+		g_chip.AD.DirectionG = 1;
+	      else
+		g_chip.AD.OffsetG -= 8;
+	    }
+	  else if (wMinValueG < 5)
+	    g_chip.AD.OffsetG += 8;
+	}
+      else
+	{
+	  if (wMinValueG > 15)
+	    g_chip.AD.OffsetG += 8;
+	  else if (wMinValueG < 5)
+	    g_chip.AD.OffsetG -= 8;
+	}
+
+      if (g_chip.AD.DirectionB == 0)
+	{
+	  if (wMinValueB > 15)
+	    {
+	      if (g_chip.AD.OffsetB < 8)
+		g_chip.AD.DirectionB = 1;
+	      else
+		g_chip.AD.OffsetB -= 8;
+	    }
+
+	  else if (wMinValueB < 5)
+	    g_chip.AD.OffsetB += 8;
+	}
+      else
+	{
+	  if (wMinValueB > 15)
+	    g_chip.AD.OffsetB += 8;
+	  else if (wMinValueB < 5)
+	    g_chip.AD.OffsetB -= 8;
+	}
+
+      nTimesOfCal++;
+      if (nTimesOfCal > 10)
+	break;
+    }
+  while (wMinValueR > 15 || wMinValueR < 5
+	 || wMinValueG > 15 || wMinValueG < 5
+	 || wMinValueB > 15 || wMinValueB < 5);
+
+  DBG (DBG_FUNC,
+       "Reflective_AdjustAD: run out first adjust offset do-while\n");
+
+  DBG (DBG_FUNC, "Reflective_AdjustAD: \
+					   g_chip.AD.OffsetR=%d,\
+					   g_chip.AD.OffsetG=%d,\
+					   g_chip.AD.OffsetB=%d\n", g_chip.AD.OffsetR, g_chip.AD.OffsetG, g_chip.AD.OffsetB);
+
+  g_chip.AD.GainR = 1 - (double) (wMaxValueR - wMinValueR) / 210 > 0 ?
+    (SANE_Byte) (((1 -
+	      (double) (wMaxValueR - wMinValueR) / 210)) * 63 * 6 / 5) : 0;
+  g_chip.AD.GainG =
+    1 - (double) (wMaxValueG - wMinValueG) / 210 >
+    0 ? (SANE_Byte) (((1 - (double) (wMaxValueG - wMinValueG) / 210)) * 63 * 6 /
+		5) : 0;
+  g_chip.AD.GainB =
+    1 - (double) (wMaxValueB - wMinValueB) / 210 >
+    0 ? (SANE_Byte) (((1 - (double) (wMaxValueB - wMinValueB) / 210)) * 63 * 6 /
+		5) : 0;
+
+  if (g_chip.AD.GainR > 63)
+    g_chip.AD.GainR = 63;
+  if (g_chip.AD.GainG > 63)
+    g_chip.AD.GainG = 63;
+  if (g_chip.AD.GainB > 63)
+    g_chip.AD.GainB = 63;
+
+  DBG (DBG_FUNC, "Reflective_AdjustAD: "
+       "g_chip.AD.GainR = %d,"
+       "g_chip.AD.GainG = %d,"
+       "g_chip.AD.GainB = %d\n",
+       g_chip.AD.GainR, g_chip.AD.GainG, g_chip.AD.GainB);
+
+  nTimesOfCal = 0;
+  do
+    {
+      Asic_SetAFEGainOffset (&g_chip);
+      Asic_ScanStart (&g_chip);
+      Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24);
+      Asic_ScanStop (&g_chip);
+
+      MustScanner_CalculateMaxMin (lpCalData, &wMaxValueR, &wMinValueR,
+				   wAdjustADResolution);
+      MustScanner_CalculateMaxMin (lpCalData + wCalWidth, &wMaxValueG,
+				   &wMinValueG, wAdjustADResolution);
+      MustScanner_CalculateMaxMin (lpCalData + wCalWidth * 2, &wMaxValueB,
+				   &wMinValueB, wAdjustADResolution);
+
+      DBG (DBG_FUNC, "Reflective_AdjustAD: "
+	   "RGain=%d, ROffset=%d, RDir=%d  GGain=%d, GOffset=%d, GDir=%d  BGain=%d, BOffset=%d, BDir=%d\n",
+	   g_chip.AD.GainR, g_chip.AD.OffsetR, g_chip.AD.DirectionR,
+	   g_chip.AD.GainG, g_chip.AD.OffsetG, g_chip.AD.DirectionG,
+	   g_chip.AD.GainB, g_chip.AD.OffsetB, g_chip.AD.DirectionB);
+
+      DBG (DBG_FUNC, "Reflective_AdjustAD: "
+	   "MaxR=%d, MinR=%d  MaxG=%d, MinG=%d  MaxB=%d, MinB=%d\n",
+	   wMaxValueR, wMinValueR, wMaxValueG, wMinValueG, wMaxValueB,
+	   wMinValueB);
+
+      /*R Channel */
+      if ((wMaxValueR - wMinValueR) > REFL_MAX_LEVEL_RANGE)
+	{
+	  if (g_chip.AD.GainR > 0)
+	    g_chip.AD.GainR--;
+	}
+      else
+	{
+	  if ((wMaxValueR - wMinValueR) < REFL_MIN_LEVEL_RANGE)
+	    {
+	      if (wMaxValueR < REFL_WHITE_MIN_LEVEL)
+		{
+		  g_chip.AD.GainR++;
+		  if (g_chip.AD.GainR > 63)
+		    g_chip.AD.GainR = 63;
+		}
+	      else
+		{
+		  if (wMaxValueR > REFL_WHITE_MAX_LEVEL)
+		    {
+		      if (g_chip.AD.GainR < 1)
+			g_chip.AD.GainR = 0;
+		      else
+			g_chip.AD.GainR--;
+		    }
+		  else
+		    {
+		      if (g_chip.AD.GainR > 63)
+			g_chip.AD.GainR = 63;
+		      else
+			g_chip.AD.GainR++;
+		    }
+		}
+	    }
+	  else
+	    {
+	      if (wMaxValueR > REFL_WHITE_MAX_LEVEL)
+		{
+		  if (g_chip.AD.GainR < 1)
+		    g_chip.AD.GainR = 0;
+		  else
+		    g_chip.AD.GainR--;
+		}
+
+	      if (wMaxValueR < REFL_WHITE_MIN_LEVEL)
+		{
+		  if (g_chip.AD.GainR > 63)
+		    g_chip.AD.GainR = 63;
+		  else
+		    g_chip.AD.GainR++;
+		}
+	    }
+	}
+
+      /*G Channel */
+      if ((wMaxValueG - wMinValueG) > REFL_MAX_LEVEL_RANGE)
+	{
+	  if (g_chip.AD.GainG > 0)
+	    g_chip.AD.GainG--;
+	}
+      else
+	{
+	  if ((wMaxValueG - wMinValueG) < REFL_MIN_LEVEL_RANGE)
+	    {
+	      if (wMaxValueG < REFL_WHITE_MIN_LEVEL)
+		{
+		  g_chip.AD.GainG++;
+		  if (g_chip.AD.GainG > 63)
+		    g_chip.AD.GainG = 63;
+		}
+	      else
+		{
+		  if (wMaxValueG > REFL_WHITE_MAX_LEVEL)
+		    {
+		      if (g_chip.AD.GainG < 1)
+			g_chip.AD.GainG = 0;
+		      else
+			g_chip.AD.GainG--;
+		    }
+		  else
+		    {
+		      if (g_chip.AD.GainG > 63)
+			g_chip.AD.GainG = 63;
+		      else
+			g_chip.AD.GainG++;
+		    }
+		}
+	    }
+	  else
+	    {
+	      if (wMaxValueG > REFL_WHITE_MAX_LEVEL)
+		{
+		  if (g_chip.AD.GainG < 1)
+		    g_chip.AD.GainG = 0;
+		  else
+		    g_chip.AD.GainG--;
+		}
+
+	      if (wMaxValueG < REFL_WHITE_MIN_LEVEL)
+		{
+		  if (g_chip.AD.GainG > 63)
+		    g_chip.AD.GainG = 63;
+		  else
+		    g_chip.AD.GainG++;
+		}
+	    }
+	}
+
+      /* B Channel */
+      if ((wMaxValueB - wMinValueB) > REFL_MAX_LEVEL_RANGE)
+	{
+	  if (g_chip.AD.GainB > 0)
+	    g_chip.AD.GainB--;
+	}
+      else
+	{
+	  if ((wMaxValueB - wMinValueB) < REFL_MIN_LEVEL_RANGE)
+	    {
+	      if (wMaxValueB < REFL_WHITE_MIN_LEVEL)
+		{
+		  g_chip.AD.GainB++;
+		  if (g_chip.AD.GainB > 63)
+		    g_chip.AD.GainB = 63;
+		}
+	      else
+		{
+		  if (wMaxValueB > REFL_WHITE_MAX_LEVEL)
+		    {
+		      if (g_chip.AD.GainB < 1)
+			g_chip.AD.GainB = 0;
+		      else
+			g_chip.AD.GainB--;
+		    }
+		  else
+		    {
+		      if (g_chip.AD.GainB > 63)
+			g_chip.AD.GainB = 63;
+		      else
+			g_chip.AD.GainB++;
+		    }
+		}
+	    }
+	  else
+	    {
+	      if (wMaxValueB > REFL_WHITE_MAX_LEVEL)
+
+		{
+		  if (g_chip.AD.GainB < 1)
+		    g_chip.AD.GainB = 0;
+		  else
+		    g_chip.AD.GainB--;
+		}
+
+	      if (wMaxValueB < REFL_WHITE_MIN_LEVEL)
+		{
+		  if (g_chip.AD.GainB > 63)
+		    g_chip.AD.GainB = 63;
+		  else
+		    g_chip.AD.GainB++;
+		}
+	    }
+	}
+      nTimesOfCal++;
+      if (nTimesOfCal > 10)
+	break;
+    }
+  while ((wMaxValueR - wMinValueR) > REFL_MAX_LEVEL_RANGE
+	 || (wMaxValueR - wMinValueR) < REFL_MIN_LEVEL_RANGE
+	 || (wMaxValueG - wMinValueG) > REFL_MAX_LEVEL_RANGE
+	 || (wMaxValueG - wMinValueG) < REFL_MIN_LEVEL_RANGE
+	 || (wMaxValueB - wMinValueB) > REFL_MAX_LEVEL_RANGE
+	 || (wMaxValueB - wMinValueB) < REFL_MIN_LEVEL_RANGE);
+
+  /* Adjust Offset 2nd */
+  nTimesOfCal = 0;
+  do
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_AdjustAD: run in second adjust offset do-while\n");
+      Asic_SetAFEGainOffset (&g_chip);
+      Asic_ScanStart (&g_chip);
+      Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24);
+      Asic_ScanStop (&g_chip);
+
+      MustScanner_CalculateMaxMin (lpCalData, &wMaxValueR, &wMinValueR,
+				   wAdjustADResolution);
+      MustScanner_CalculateMaxMin (lpCalData + wCalWidth, &wMaxValueG,
+				   &wMinValueG, wAdjustADResolution);
+      MustScanner_CalculateMaxMin (lpCalData + wCalWidth * 2, &wMaxValueB,
+				   &wMinValueB, wAdjustADResolution);
+
+      DBG (DBG_FUNC, "Reflective_AdjustAD: "
+	   "RGain=%d, ROffset=%d, RDir=%d  GGain=%d, GOffset=%d, GDir=%d  BGain=%d, BOffset=%d, BDir=%d\n",
+	   g_chip.AD.GainR, g_chip.AD.OffsetR, g_chip.AD.DirectionR,
+	   g_chip.AD.GainG, g_chip.AD.OffsetG, g_chip.AD.DirectionG,
+	   g_chip.AD.GainB, g_chip.AD.OffsetB, g_chip.AD.DirectionB);
+
+      DBG (DBG_FUNC, "Reflective_AdjustAD: "
+	   "MaxR=%d, MinR=%d  MaxG=%d, MinG=%d  MaxB=%d, MinB=%d\n",
+	   wMaxValueR, wMinValueR, wMaxValueG, wMinValueG, wMaxValueB,
+	   wMinValueB);
+
+      if (g_chip.AD.DirectionR == 0)
+	{
+	  if (wMinValueR > 20)
+	    {
+	      if (g_chip.AD.OffsetR < 8)
+		g_chip.AD.DirectionR = 1;
+	      else
+		g_chip.AD.OffsetR -= 8;
+	    }
+
+	  else if (wMinValueR < 10)
+	    g_chip.AD.OffsetR += 8;
+	}
+      else
+	{
+	  if (wMinValueR > 20)
+	    g_chip.AD.OffsetR += 8;
+	  else if (wMinValueR < 10)
+	    g_chip.AD.OffsetR -= 8;
+	}
+
+      if (g_chip.AD.DirectionG == 0)
+	{
+	  if (wMinValueG > 20)
+	    {
+	      if (g_chip.AD.OffsetG < 8)
+		g_chip.AD.DirectionG = 1;
+	      else
+		g_chip.AD.OffsetG -= 8;
+	    }
+	  else if (wMinValueG < 10)
+	    g_chip.AD.OffsetG += 8;
+	}
+      else
+	{
+	  if (wMinValueG > 20)
+	    g_chip.AD.OffsetG += 8;
+	  else if (wMinValueG < 10)
+	    g_chip.AD.OffsetG -= 8;
+	}
+
+      if (g_chip.AD.DirectionB == 0)
+	{
+	  if (wMinValueB > 20)
+	    {
+	      if (g_chip.AD.OffsetB < 8)
+		g_chip.AD.DirectionB = 1;
+	      else
+		g_chip.AD.OffsetB -= 8;
+	    }
+	  else if (wMinValueB < 10)
+	    g_chip.AD.OffsetB += 8;
+	}
+      else
+	{
+	  if (wMinValueB > 20)
+	    g_chip.AD.OffsetB += 8;
+	  else if (wMinValueB < 10)
+	    g_chip.AD.OffsetB -= 8;
+	}
+
+      nTimesOfCal++;
+      if (nTimesOfCal > 8)
+	break;
+
+    }
+  while (wMinValueR > 20 || wMinValueR < 10
+	 || wMinValueG > 20 || wMinValueG < 10
+	 || wMinValueB > 20 || wMinValueB < 10);
+
+  DBG (DBG_FUNC,
+       "Reflective_AdjustAD: run in second adjust offset do-while\n");
+
+  DBG (DBG_FUNC, "Reflective_AdjustAD:after ad gain\n");
+  DBG (DBG_FUNC, "Reflective_AdjustAD: "
+       "g_chip.AD.GainR = %d,"
+       "g_chip.AD.GainG = %d,"
+       "g_chip.AD.GainB = %d\n",
+       g_chip.AD.GainR, g_chip.AD.GainG, g_chip.AD.GainB);
+
+  free (lpCalData);
+
+  DBG (DBG_FUNC, "Reflective_AdjustAD: leave Reflective_AdjustAD\n");
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Find top and left side
+Parameters:
+	lpwStartX: the left side
+	lpwStartY: the top side
+Return value:
+	if operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_FindTopLeft (unsigned short * lpwStartX, unsigned short * lpwStartY)
+{
+  unsigned short wCalWidth = FIND_LEFT_TOP_WIDTH_IN_DIP;
+  unsigned short wCalHeight = FIND_LEFT_TOP_HEIGHT_IN_DIP;
+
+  int i, j;
+  unsigned short wLeftSide;
+  unsigned short wTopSide;
+  int nScanBlock;
+  SANE_Byte * lpCalData;
+  unsigned int dwTotalSize;
+  unsigned short wXResolution, wYResolution;
+
+  DBG (DBG_FUNC, "Reflective_FindTopLeft: call in\n");
+  if (!g_bOpened)
+    {
+      DBG (DBG_FUNC, "Reflective_FindTopLeft: scanner has been opened\n");
+      return FALSE;
+    }
+  if (!g_bPrepared)
+    {
+      DBG (DBG_FUNC, "Reflective_FindTopLeft: scanner not prepared\n");
+      return FALSE;
+    }
+
+  wXResolution = wYResolution = FIND_LEFT_TOP_CALIBRATE_RESOLUTION;
+
+  lpCalData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * wCalWidth * wCalHeight);
+  if (lpCalData == NULL)
+    {
+      DBG (DBG_FUNC, "Reflective_FindTopLeft: lpCalData malloc error\n");
+      return FALSE;
+    }
+
+  dwTotalSize = wCalWidth * wCalHeight;
+  nScanBlock = (int) (dwTotalSize / g_dwCalibrationSize);
+
+  Asic_SetMotorType (&g_chip, TRUE, TRUE);
+  Asic_SetCalibrate (&g_chip, 8, wXResolution, wYResolution, 0, 0, wCalWidth,
+		     wCalHeight, FALSE);
+  Asic_SetAFEGainOffset (&g_chip);
+  if (Asic_ScanStart (&g_chip) != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC, "Reflective_FindTopLeft: Asic_ScanStart return error\n");
+      free (lpCalData);
+      return FALSE;
+    }
+
+  for (i = 0; i < nScanBlock; i++)
+    {
+      if (STATUS_GOOD !=
+	  Asic_ReadCalibrationData (&g_chip,
+				    lpCalData + i * g_dwCalibrationSize,
+				    g_dwCalibrationSize, 8))
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_FindTopLeft: Asic_ReadCalibrationData return error\n");
+	  free (lpCalData);
+	  return FALSE;
+	}
+    }
+
+  if (STATUS_GOOD !=
+      Asic_ReadCalibrationData (&g_chip,
+				lpCalData +
+				(nScanBlock) * g_dwCalibrationSize,
+				(dwTotalSize -
+				 g_dwCalibrationSize * nScanBlock), 8))
+    {
+
+      DBG (DBG_FUNC,
+	   "Reflective_FindTopLeft: Asic_ReadCalibrationData return error\n");
+      free (lpCalData);
+      return FALSE;
+    }
+
+  Asic_ScanStop (&g_chip);
+
+#ifdef DEBUG_SAVE_IMAGE
+  FILE *stream = NULL;
+  stream = fopen ("/root/bound(Ref).pnm", "wb+\n");
+  SANE_Byte * lpBuf = (SANE_Byte *) malloc (50);
+  if (NULL == lpBuf)
+    {
+      return FALSE;
+    }
+  memset (lpBuf, 0, 50);
+  sprintf (lpBuf, "P5\n%d %d\n255\n", wCalWidth, wCalHeight);
+  fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream);
+  fwrite (lpCalData, sizeof (SANE_Byte), wCalWidth * wCalHeight, stream);
+
+  fclose (stream);
+  free (lpBuf);
+#endif
+
+  wLeftSide = 0;
+  wTopSide = 0;
+
+  /* Find Left Side */
+  for (i = wCalWidth - 1; i > 0; i--)
+    {
+      wLeftSide = *(lpCalData + i);
+      wLeftSide += *(lpCalData + wCalWidth * 2 + i);
+      wLeftSide += *(lpCalData + wCalWidth * 4 + i);
+      wLeftSide += *(lpCalData + wCalWidth * 6 + i);
+      wLeftSide += *(lpCalData + wCalWidth * 8 + i);
+      wLeftSide /= 5;
+      if (wLeftSide < 60)
+	{
+	  if (i == wCalWidth - 1)
+	    {
+	      break;
+	    }
+	  *lpwStartX = i;
+	  {
+	    break;
+	  }
+	}
+    }
+
+  /*Find Top Side i=left side */
+  for (j = 0; j < wCalHeight; j++)
+    {
+      wTopSide = *(lpCalData + wCalWidth * j + i - 2);
+      wTopSide += *(lpCalData + wCalWidth * j + i - 4);
+      wTopSide += *(lpCalData + wCalWidth * j + i - 6);
+      wTopSide += *(lpCalData + wCalWidth * j + i - 8);
+      wTopSide += *(lpCalData + wCalWidth * j + i - 10);
+
+      wTopSide /= 5;
+      if (wTopSide > 60)
+	{
+	  if (j == 0)
+	    {
+	      break;
+	    }
+	  *lpwStartY = j;
+	  {
+	    break;
+	  }
+	}
+    }
+
+  if ((*lpwStartX < 100) || (*lpwStartX > 250))
+    {
+      *lpwStartX = 187;
+    }
+
+  if ((*lpwStartY < 10) || (*lpwStartY > 100))
+    {
+      *lpwStartY = 43;
+    }
+
+  DBG (DBG_FUNC,
+       "Reflective_FindTopLeft: *lpwStartY = %d, *lpwStartX = %d\n",
+       *lpwStartY, *lpwStartX);
+  Asic_MotorMove (&g_chip, FALSE,
+		  (wCalHeight - *lpwStartY +
+		   BEFORE_SCANNING_MOTOR_FORWARD_PIXEL) * 1200 /
+		  wYResolution);
+
+  free (lpCalData);
+
+  DBG (DBG_FUNC, "Reflective_FindTopLeft: leave Reflective_FindTopLeft\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
+Reflective_StopScan ()
+{
+  DBG (DBG_FUNC, "Reflective_StopScan: call in\n");
+  if (!g_bOpened)
+    {
+      DBG (DBG_FUNC, "Reflective_StopScan: scanner not opened\n");
+
+      return FALSE;
+    }
+  if (!g_bPrepared)
+    {
+      DBG (DBG_FUNC, "Reflective_StopScan: scanner not prepared\n");
+
+      return FALSE;
+    }
+
+  g_isCanceled = TRUE;		/*tell parent process stop read image */
+
+  pthread_cancel (g_threadid_readimage);
+  pthread_join (g_threadid_readimage, NULL);
+
+  DBG (DBG_FUNC, "Reflective_StopScan: thread exit\n");
+
+  Asic_ScanStop (&g_chip);
+  Asic_Close (&g_chip);
+
+  g_bOpened = FALSE;
+
+  DBG (DBG_FUNC, "Reflective_StopScan: leave Reflective_StopScan\n");
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/15
+Routine Description: 
+	Get the calibration data
+Parameters:
+	none
+Return value: 
+	if the operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_LineCalibration16Bits ()
+{
+  STATUS status;
+  SANE_Byte * lpWhiteData;
+  SANE_Byte * lpDarkData;
+  unsigned int dwWhiteTotalSize;
+  unsigned int dwDarkTotalSize;
+  unsigned short wCalHeight = LINE_CALIBRATION__16BITS_HEIGHT;
+  unsigned short wCalWidth;
+
+  unsigned short *lpWhiteShading;
+  unsigned short *lpDarkShading;
+  double wRWhiteLevel = 0;
+  double wGWhiteLevel = 0;
+  double wBWhiteLevel = 0;
+  unsigned int dwRDarkLevel = 0;
+  unsigned int dwGDarkLevel = 0;
+  unsigned int dwBDarkLevel = 0;
+  unsigned int dwREvenDarkLevel = 0;
+  unsigned int dwGEvenDarkLevel = 0;
+  unsigned int dwBEvenDarkLevel = 0;
+  unsigned short * lpRWhiteSort;
+  unsigned short * lpGWhiteSort;
+  unsigned short * lpBWhiteSort;
+  unsigned short * lpRDarkSort;
+  unsigned short * lpGDarkSort;
+  unsigned short * lpBDarkSort;
+  int i, j;
+
+  DBG (DBG_FUNC, "Reflective_LineCalibration16Bits: call in\n");
+  if (!g_bOpened)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: scanner not opened\n");
+
+      return FALSE;
+    }
+  if (!g_bPrepared)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: scanner not prepared\n");
+
+      return FALSE;
+    }
+
+  wCalWidth = g_Width;
+
+  dwWhiteTotalSize = wCalWidth * wCalHeight * 3 * 2;
+  dwDarkTotalSize = wCalWidth * wCalHeight * 3 * 2;
+  lpWhiteData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * dwWhiteTotalSize);
+  lpDarkData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * dwDarkTotalSize);
+
+  if (lpWhiteData == NULL || lpDarkData == NULL)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: lpWhiteData or lpDarkData malloc error \n");
+
+      return FALSE;
+    }
+
+  Asic_SetMotorType (&g_chip, TRUE, TRUE);
+  Asic_SetAFEGainOffset (&g_chip);
+  status =
+    Asic_SetCalibrate (&g_chip, 48, g_XDpi, g_YDpi, g_X, 0, wCalWidth,
+		       wCalHeight, TRUE);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_SetCalibrate return error \n");
+
+      free (lpWhiteData);
+
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  status = Asic_ScanStart (&g_chip);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_ScanStart return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  status =
+    Asic_ReadCalibrationData (&g_chip, lpWhiteData, dwWhiteTotalSize, 8);
+  if (status != STATUS_GOOD)
+    {
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  Asic_ScanStop (&g_chip);
+
+  /*Read dark level data */
+  status = Asic_SetMotorType (&g_chip, FALSE, TRUE);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_SetMotorType return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  status =
+    Asic_SetCalibrate (&g_chip, 48, g_XDpi, g_YDpi, g_X, 0, wCalWidth,
+		       wCalHeight, TRUE);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_SetCalibrate return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  status = Asic_TurnLamp (&g_chip, FALSE);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_TurnLamp return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  usleep (500000);
+
+  status = Asic_ScanStart (&g_chip);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_ScanStart return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  status = Asic_ReadCalibrationData (&g_chip, lpDarkData, dwDarkTotalSize, 8);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_ReadCalibrationData return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  Asic_ScanStop (&g_chip);
+
+  /* Turn on lamp */
+  status = Asic_TurnLamp (&g_chip, TRUE);
+  if (status != STATUS_GOOD)
+    {
+      DBG (DBG_FUNC,
+	   "Reflective_LineCalibration16Bits: Asic_TurnLamp return error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+#ifdef DEBUG_SAVE_IMAGE
+  FILE *stream = NULL;
+  SANE_Byte * lpBuf = (SANE_Byte *) malloc (50);
+  if (NULL == lpBuf)
+    {
+      return FALSE;
+
+    }
+  memset (lpBuf, 0, 50);
+  stream = fopen ("/root/whiteshading(Ref).pnm", "wb+\n");
+  sprintf (lpBuf, "P6\n%d %d\n65535\n", wCalWidth, wCalHeight);
+  fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream);
+  fwrite (lpWhiteData, sizeof (SANE_Byte), wCalWidth * wCalHeight * 3 * 2, stream);
+  fclose (stream);
+
+  memset (lpBuf, 0, 50);
+  stream = fopen ("/root/darkshading(Ref).pnm", "wb+\n");
+  sprintf (lpBuf, "P6\n%d %d\n65535\n", wCalWidth, wCalHeight);
+  fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream);
+  fwrite (lpDarkData, sizeof (SANE_Byte), wCalWidth * wCalHeight * 3 * 2, stream);
+  fclose (stream);
+  free (lpBuf);
+#endif
+
+  sleep (1);
+
+  lpWhiteShading = (unsigned short *) malloc (sizeof (unsigned short) * wCalWidth * 3);
+  lpDarkShading = (unsigned short *) malloc (sizeof (unsigned short) * wCalWidth * 3);
+
+  lpRWhiteSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight);
+  lpGWhiteSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight);
+  lpBWhiteSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight);
+  lpRDarkSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight);
+  lpGDarkSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight);
+  lpBDarkSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight);
+
+  if (lpWhiteShading == NULL || lpDarkShading == NULL
+      || lpRWhiteSort == NULL || lpGWhiteSort == NULL || lpBWhiteSort == NULL
+      || lpRDarkSort == NULL || lpGDarkSort == NULL || lpBDarkSort == NULL)
+    {
+      DBG (DBG_FUNC, "Reflective_LineCalibration16Bits: malloc error \n");
+
+      free (lpWhiteData);
+      free (lpDarkData);
+      return FALSE;
+    }
+
+  /* create dark level shading */
+  dwRDarkLevel = 0;
+  dwGDarkLevel = 0;
+  dwBDarkLevel = 0;
+  dwREvenDarkLevel = 0;
+  dwGEvenDarkLevel = 0;
+  dwBEvenDarkLevel = 0;
+
+  DBG (DBG_FUNC,
+       "Reflective_LineCalibration16Bits: wCalWidth = %d, wCalHeight = %d\n",
+       wCalWidth, wCalHeight);
+
+  for (i = 0; i < wCalWidth; i++)
+    {
+      for (j = 0; j < wCalHeight; j++)
+	{
+	  lpRDarkSort[j] =
+	    (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 0));
+	  lpRDarkSort[j] +=
+	    (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 1) << 8);
+
+	  lpGDarkSort[j] =
+	    (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 2));
+	  lpGDarkSort[j] +=
+	    (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 3) << 8);
+
+	  lpBDarkSort[j] =
+	    (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 4));
+	  lpBDarkSort[j] +=
+	    (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 5) << 8);
+	}
+
+      if (g_XDpi == 1200)
+	{
+
+	  /*do dark shading table with mean */
+	  if (i % 2)
+	    {
+	      dwRDarkLevel +=
+		(unsigned int) MustScanner_FiltLower (lpRDarkSort, wCalHeight, 20,
+					       30);
+	      dwGDarkLevel +=
+		(unsigned int) MustScanner_FiltLower (lpGDarkSort, wCalHeight, 20,
+					       30);
+	      dwBDarkLevel +=
+		(unsigned int) MustScanner_FiltLower (lpBDarkSort, wCalHeight, 20,
+					       30);
+	    }
+	  else
+	    {
+	      dwREvenDarkLevel +=
+		(unsigned int) MustScanner_FiltLower (lpRDarkSort, wCalHeight, 20,
+					       30);
+
+	      dwGEvenDarkLevel +=
+		(unsigned int) MustScanner_FiltLower (lpGDarkSort, wCalHeight, 20,
+					       30);
+	      dwBEvenDarkLevel +=
+		(unsigned int) MustScanner_FiltLower (lpBDarkSort, wCalHeight, 20,
+					       30);
+	    }
+	}
+      else
+	{
+
+	  dwRDarkLevel +=
+	    (unsigned int) MustScanner_FiltLower (lpRDarkSort, wCalHeight, 20, 30);
+	  dwGDarkLevel +=
+	    (unsigned int) MustScanner_FiltLower (lpGDarkSort, wCalHeight, 20, 30);
+	  dwBDarkLevel +=
+	    (unsigned int) MustScanner_FiltLower (lpBDarkSort, wCalHeight, 20, 30);
+	}
+    }
+
+  if (g_XDpi == 1200)
+    {
+      dwRDarkLevel = (unsigned int) (dwRDarkLevel / (wCalWidth / 2));
+      dwGDarkLevel = (unsigned int) (dwGDarkLevel / (wCalWidth / 2));
+      dwBDarkLevel = (unsigned int) (dwBDarkLevel / (wCalWidth / 2));
+      dwREvenDarkLevel = (unsigned int) (dwREvenDarkLevel / (wCalWidth / 2));
+      dwGEvenDarkLevel = (unsigned int) (dwGEvenDarkLevel / (wCalWidth / 2));
+      dwBEvenDarkLevel = (unsigned int) (dwBEvenDarkLevel / (wCalWidth / 2));
+    }
+  else
+    {
+      dwRDarkLevel = (unsigned int) (dwRDarkLevel / wCalWidth);
+      dwGDarkLevel = (unsigned int) (dwGDarkLevel / wCalWidth);
+      dwBDarkLevel = (unsigned int) (dwBDarkLevel / wCalWidth);
+    }
+
+  /*Create white shading */
+  for (i = 0; i < wCalWidth; i++)
+    {
+      wRWhiteLevel = 0;
+      wGWhiteLevel = 0;
+      wBWhiteLevel = 0;
+
+      for (j = 0; j < wCalHeight; j++)
+	{
+	  lpRWhiteSort[j] =
+	    (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 0));
+	  lpRWhiteSort[j] +=
+	    (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 1) << 8);
+
+	  lpGWhiteSort[j] =
+	    (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 2));
+	  lpGWhiteSort[j] +=
+	    (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 3) << 8);
+
+	  lpBWhiteSort[j] =
+	    (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 4));
+	  lpBWhiteSort[j] +=
+	    (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 5) << 8);
+	}
+
+      if (g_XDpi == 1200)
+	{
+	  if (i % 2)
+	    {
+	      *(lpDarkShading + i * 3 + 0) = (unsigned short) dwRDarkLevel;
+	      *(lpDarkShading + i * 3 + 1) = (unsigned short) dwGDarkLevel;
+	      *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBDarkLevel;
+	    }
+	  else
+	    {
+	      *(lpDarkShading + i * 3 + 0) = (unsigned short) dwREvenDarkLevel;
+	      *(lpDarkShading + i * 3 + 1) = (unsigned short) dwGEvenDarkLevel;
+	      *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBEvenDarkLevel;
+	    }
+	}
+      else
+	{
+	  *(lpDarkShading + i * 3 + 0) = (unsigned short) dwRDarkLevel;
+	  *(lpDarkShading + i * 3 + 1) = (unsigned short) dwGDarkLevel;
+	  *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBDarkLevel;
+	}
+
+
+      /*Create white shading */
+      wRWhiteLevel =
+	(double) (MustScanner_FiltLower (lpRWhiteSort, wCalHeight, 20, 30) -
+		  *(lpDarkShading + i * 3 + 0));
+      wGWhiteLevel =
+	(double) (MustScanner_FiltLower (lpGWhiteSort, wCalHeight, 20, 30) -
+		  *(lpDarkShading + i * 3 + 1));
+      wBWhiteLevel =
+	(double) (MustScanner_FiltLower (lpBWhiteSort, wCalHeight, 20, 30) -
+		  *(lpDarkShading + i * 3 + 2));
+
+      if (wRWhiteLevel > 0)
+	*(lpWhiteShading + i * 3 + 0) =
+	  (unsigned short) (((float) 65535 / wRWhiteLevel * 0x2000));
+      else
+	*(lpWhiteShading + i * 3 + 0) = 0x2000;
+
+      if (wGWhiteLevel > 0)
+	*(lpWhiteShading + i * 3 + 1) =
+	  (unsigned short) (((float) 65535 / wGWhiteLevel * 0x2000));
+      else
+	*(lpWhiteShading + i * 3 + 1) = 0x2000;
+
+      if (wBWhiteLevel > 0)
+	*(lpWhiteShading + i * 3 + 2) =
+	  (unsigned short) (((float) 65535 / wBWhiteLevel * 0x2000));
+      else
+	*(lpWhiteShading + i * 3 + 2) = 0x2000;
+    }
+
+  free (lpWhiteData);
+  free (lpDarkData);
+  free (lpRWhiteSort);
+  free (lpGWhiteSort);
+  free (lpBWhiteSort);
+  free (lpRDarkSort);
+  free (lpGDarkSort);
+  free (lpBDarkSort);
+
+  Asic_SetShadingTable (&g_chip, lpWhiteShading, lpDarkShading, g_XDpi,
+			wCalWidth, 0);
+
+  free (lpWhiteShading);
+  free (lpDarkShading);
+
+  DBG (DBG_FUNC,
+       "Reflective_LineCalibration16Bits: leave Reflective_LineCalibration16Bits\n");
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/14
+Routine Description: 
+	Prepare scan image
+Parameters:
+	none
+Return value: 
+	if operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_PrepareScan ()
+{
+  g_wScanLinesPerBlock = g_dwBufferSize / g_BytesPerRow;
+  g_wMaxScanLines = g_dwImageBufferSize / g_BytesPerRow;
+  g_wMaxScanLines =
+    (g_wMaxScanLines / g_wScanLinesPerBlock) * g_wScanLinesPerBlock;
+
+  g_isCanceled = FALSE;
+
+  g_dwScannedTotalLines = 0;
+  g_wReadedLines = 0;
+  g_wtheReadyLines = 0;
+  g_wReadImageLines = 0;
+
+  g_wReadyShadingLine = 0;
+  g_wStartShadingLinePos = 0;
+
+  switch (g_ScanMode)
+    {
+    case CM_RGB48:
+      g_wtheReadyLines = g_wLineDistance * 2 + g_wPixelDistance;
+      DBG (DBG_FUNC, "Reflective_PrepareScan:g_wtheReadyLines=%d\n",
+	   g_wtheReadyLines);
+
+      DBG (DBG_FUNC,
+	   "Reflective_PrepareScan:g_lpReadImageHead malloc %d Bytes\n",
+	   g_dwImageBufferSize);
+      g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize);
+      if (g_lpReadImageHead == NULL)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_PrepareScan: g_lpReadImageHead malloc error \n");
+	  return FALSE;
+	}
+      break;
+
+    case CM_RGB24ext:
+      g_wtheReadyLines = g_wLineDistance * 2 + g_wPixelDistance;
+      DBG (DBG_FUNC, "Reflective_PrepareScan:g_wtheReadyLines=%d\n",
+	   g_wtheReadyLines);
+
+      DBG (DBG_FUNC,
+	   "Reflective_PrepareScan:g_lpReadImageHead malloc %d Bytes\n",
+	   g_dwImageBufferSize);
+      g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize);
+      if (g_lpReadImageHead == NULL)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_PrepareScan: g_lpReadImageHead malloc error \n");
+	  return FALSE;
+	}
+      break;
+    case CM_GRAY16ext:
+      g_wtheReadyLines = g_wPixelDistance;
+      DBG (DBG_FUNC, "Reflective_PrepareScan:g_wtheReadyLines=%d\n",
+	   g_wtheReadyLines);
+
+      DBG (DBG_FUNC,
+	   "Reflective_PrepareScan:g_lpReadImageHead malloc %d Bytes\n",
+	   g_dwImageBufferSize);
+      g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize);
+      if (g_lpReadImageHead == NULL)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_PrepareScan: g_lpReadImageHead malloc error \n");
+	  return FALSE;
+	}
+      break;
+    case CM_GRAY8ext:
+      g_wtheReadyLines = g_wPixelDistance;
+      DBG (DBG_FUNC, "Reflective_PrepareScan:g_wtheReadyLines=%d\n",
+	   g_wtheReadyLines);
+
+      DBG (DBG_FUNC,
+	   "Reflective_PrepareScan:g_lpReadImageHead malloc %d Bytes\n",
+	   g_dwImageBufferSize);
+      g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize);
+      if (g_lpReadImageHead == NULL)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_PrepareScan: g_lpReadImageHead malloc error \n");
+	  return FALSE;
+	}
+      break;
+    case CM_TEXT:
+      g_wtheReadyLines = g_wPixelDistance;
+      DBG (DBG_FUNC, "Reflective_PrepareScan:g_wtheReadyLines=%d\n",
+	   g_wtheReadyLines);
+
+      DBG (DBG_FUNC,
+	   "Reflective_PrepareScan:g_lpReadImageHead malloc %d Bytes\n",
+	   g_dwImageBufferSize);
+      g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize);
+      if (g_lpReadImageHead == NULL)
+	{
+	  DBG (DBG_FUNC,
+	       "Reflective_PrepareScan: g_lpReadImageHead malloc error \n");
+	  return FALSE;
+	}
+      break;
+    default:
+      break;
+    }
+
+  Asic_ScanStart (&g_chip);
+  return TRUE;
+}
+
+/**********************************************************************
+Author: Jack             Date: 2005/05/15
+Routine Description: 
+	Get the data of image
+Parameters:
+	lpBlock: the data of image
+	Rows: the rows of image
+
+	isOrderInvert: the RGB order
+Return value:
+	if the operation is success
+	return TRUE
+	else
+	return FALSE
+***********************************************************************/
+static SANE_Bool
+Reflective_GetRows (SANE_Byte * lpBlock, unsigned short * Rows, SANE_Bool isOrderInvert)
+{
+  DBG (DBG_FUNC, "Reflective_GetRows: call in \n");
+  if (!g_bOpened)
+    {
+      DBG (DBG_FUNC, "Reflective_GetRows: scanner not opened \n");
+      return FALSE;
+    }
+  if (!g_bPrepared)
+    {
+      DBG (DBG_FUNC, "Reflective_GetRows: scanner not prepared \n");
+      return FALSE;
+    }
+
+  switch (g_ScanMode)
+    {
+    case CM_RGB48:
+      if (g_XDpi == 1200)
+	return MustScanner_GetRgb48BitLine1200DPI (lpBlock, isOrderInvert,
+						   Rows);
+      else
+	return MustScanner_GetRgb48BitLine (lpBlock, isOrderInvert, Rows);
+
+    case CM_RGB24ext:
+      if (g_XDpi == 1200)
+	return MustScanner_GetRgb24BitLine1200DPI (lpBlock, isOrderInvert,
+						   Rows);
+      else
+	return MustScanner_GetRgb24BitLine (lpBlock, isOrderInvert, Rows);
+
+    case CM_GRAY16ext:
+      if (g_XDpi == 1200)
+	return MustScanner_GetMono16BitLine1200DPI (lpBlock, isOrderInvert,
+						    Rows);
+      else
+	return MustScanner_GetMono16BitLine (lpBlock, isOrderInvert, Rows);
+
+    case CM_GRAY8ext:
+      if (g_XDpi == 1200)
+	return MustScanner_GetMono8BitLine1200DPI (lpBlock, isOrderInvert,
+						   Rows);
+      else
+	return MustScanner_GetMono8BitLine (lpBlock, isOrderInvert, Rows);
+
+    case CM_TEXT:
+      if (g_XDpi == 1200)
+	return MustScanner_GetMono1BitLine1200DPI (lpBlock, isOrderInvert,
+						   Rows);
+      else
+	return MustScanner_GetMono1BitLine (lpBlock, isOrderInvert, Rows);
+    default:
+      return FALSE;
+    }
+
+  DBG (DBG_FUNC, "Reflective_GetRows: leave Reflective_GetRows \n");
+  return FALSE;
+}				/* end of the file ScannerReflective.c */