diff options
Diffstat (limited to 'backend/mustek_usb2.c')
| -rw-r--r-- | backend/mustek_usb2.c | 2696 |
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; +} |