diff options
Diffstat (limited to 'backend/hp3900_sane.c')
| -rw-r--r-- | backend/hp3900_sane.c | 2734 |
1 files changed, 2734 insertions, 0 deletions
diff --git a/backend/hp3900_sane.c b/backend/hp3900_sane.c new file mode 100644 index 0000000..a1c381c --- /dev/null +++ b/backend/hp3900_sane.c @@ -0,0 +1,2734 @@ +/* HP Scanjet 3900 series - SANE Backend controller + Copyright (C) 2005-2009 Jonathan Bravo Lopez <jkdsoft@gmail.com> + + 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. +*/ + +/* Backend Code for SANE*/ +#define HP3900_CONFIG_FILE "hp3900.conf" +#define GAMMA_DEFAULT 1.0 + +#include "../include/sane/config.h" +#include "../include/sane/sane.h" +#include "../include/sane/sanei.h" +#include "../include/sane/sanei_backend.h" +#include "../include/sane/sanei_config.h" +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei_usb.h" +#include "../include/sane/sanei_debug.h" + +#include "hp3900_rts8822.c" + +struct st_convert +{ + SANE_Int colormode; + SANE_Int depth; + SANE_Int threshold; + SANE_Int negative; + SANE_Int real_depth; +}; + +/* options enumerator */ +typedef enum +{ + opt_begin = 0, + + grp_geometry, + opt_tlx, opt_tly, opt_brx, opt_bry, + opt_resolution, + + /* gamma tables */ + opt_gamma_red, + opt_gamma_green, + opt_gamma_blue, + + opt_scantype, + opt_colormode, + opt_depth, + opt_threshold, + + /* debugging options */ + grp_debug, + opt_model, + opt_negative, + opt_nogamma, + opt_nowshading, + opt_realdepth, + opt_emulategray, + opt_nowarmup, + opt_dbgimages, + opt_reset, + + /* device information */ + grp_info, + opt_chipname, + opt_chipid, + opt_scancount, + opt_infoupdate, + + /* supported buttons. RTS8822 supports up to 6 buttons */ + grp_sensors, + opt_button_0, + opt_button_1, + opt_button_2, + opt_button_3, + opt_button_4, + opt_button_5, + + opt_count +} EOptionIndex; + +/* linked list of SANE_Device structures */ +typedef struct TDevListEntry +{ + struct TDevListEntry *pNext; + SANE_Device dev; + char *devname; +} TDevListEntry; + +typedef struct +{ + char *pszVendor; + char *pszName; +} TScannerModel; + +typedef union +{ + SANE_Word w; + SANE_Word *wa; /* word array */ + SANE_String s; +} TOptionValue; + +typedef struct +{ + SANE_Int model; + SANE_Option_Descriptor aOptions[opt_count]; + TOptionValue aValues[opt_count]; + struct params ScanParams; + + /* lists */ + SANE_String_Const *list_colormodes; + SANE_Int *list_depths; + SANE_String_Const *list_models; + SANE_Int *list_resolutions; + SANE_String_Const *list_sources; + + SANE_Word *aGammaTable[3]; /* a 16-to-16 bit color lookup table */ + SANE_Range rng_gamma; + + /* reading image */ + SANE_Byte *image; + SANE_Byte *rest; + SANE_Int rest_amount; + SANE_Int mylin; + + /* convertion settings */ + struct st_convert cnv; + + /* ranges */ + SANE_Range rng_threshold; + SANE_Range rng_horizontal; + SANE_Range rng_vertical; + + SANE_Int scan_count; + SANE_Int fScanning; /* TRUE if actively scanning */ +} TScanner; + +/* functions to manage backend's options */ +static void options_init (TScanner * scanner); +static void options_free (TScanner * scanner); + +/* devices listing */ +static SANE_Int _ReportDevice (TScannerModel * pModel, + const char *pszDeviceName); +static SANE_Status attach_one_device (SANE_String_Const devname); + +/* capabilities */ +static SANE_Status bknd_colormodes (TScanner * scanner, SANE_Int model); +static void bknd_constrains (TScanner * scanner, SANE_Int source, + SANE_Int type); +static SANE_Status bknd_depths (TScanner * scanner, SANE_Int model); +static SANE_Status bknd_info (TScanner * scanner); +static SANE_Status bknd_models (TScanner * scanner); +static SANE_Status bknd_resolutions (TScanner * scanner, SANE_Int model); +static SANE_Status bknd_sources (TScanner * scanner, SANE_Int model); + +/* convertions */ +static void Color_Negative (SANE_Byte * buffer, SANE_Int size, + SANE_Int depth); +static void Color_to_Gray (SANE_Byte * buffer, SANE_Int size, SANE_Int depth); +static void Gray_to_Lineart (SANE_Byte * buffer, SANE_Int size, + SANE_Int threshold); +static void Depth_16_to_8 (SANE_Byte * from_buffer, SANE_Int size, + SANE_Byte * to_buffer); + +/* gamma functions */ +static void gamma_apply (TScanner * s, SANE_Byte * buffer, SANE_Int size, + SANE_Int depth); +static SANE_Int gamma_create (TScanner * s, double gamma); +static void gamma_free (TScanner * s); + +static SANE_Int Get_Colormode (SANE_String colormode); +static SANE_Int Get_Model (SANE_String model); +static SANE_Int Get_Source (SANE_String source); +static SANE_Int GetUSB_device_model (SANE_String_Const name); +static size_t max_string_size (const SANE_String_Const strings[]); + +static SANE_Status get_button_status (TScanner * s); + +/* reading buffers */ +static SANE_Status img_buffers_alloc (TScanner * scanner, SANE_Int size); +static SANE_Status img_buffers_free (TScanner * scanner); + +static SANE_Status option_get (TScanner * scanner, SANE_Int optid, + void *result); +static SANE_Status option_set (TScanner * scanner, SANE_Int optid, + void *value, SANE_Int * pInfo); + +static void Set_Coordinates (SANE_Int scantype, SANE_Int resolution, + struct st_coords *coords); +static SANE_Int set_ScannerModel (SANE_Int proposed, SANE_Int product, + SANE_Int vendor); +static void Silent_Compile (void); +static SANE_Status Translate_coords (struct st_coords *coords); + +/* SANE functions */ +void sane_cancel (SANE_Handle h); +void sane_close (SANE_Handle h); +SANE_Status sane_control_option (SANE_Handle h, SANE_Int n, + SANE_Action Action, void *pVal, + SANE_Int * pInfo); +void sane_exit (void); +SANE_Status sane_get_devices (const SANE_Device *** device_list, + SANE_Bool local_only); +const SANE_Option_Descriptor *sane_get_option_descriptor (SANE_Handle h, + SANE_Int n); +SANE_Status sane_get_parameters (SANE_Handle h, SANE_Parameters * p); +SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd); +SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize); +SANE_Status sane_open (SANE_String_Const name, SANE_Handle * h); +SANE_Status sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, + SANE_Int * len); +SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking); +SANE_Status sane_start (SANE_Handle h); + +/* variables */ +static struct st_device *device = NULL; +static TDevListEntry *_pFirstSaneDev = 0; +static SANE_Int iNumSaneDev = 0; +static const SANE_Device **_pSaneDevList = 0; + +/* Own functions */ + +static SANE_Status +bknd_resolutions (TScanner * scanner, SANE_Int model) +{ + SANE_Status rst = SANE_STATUS_INVAL; + + DBG (DBG_FNC, "> bknd_resolutions(*scanner, model=%i)\n", model); + + if (scanner != NULL) + { + SANE_Int *res = NULL; + + switch (model) + { + case BQ5550: + case UA4900: + { + SANE_Int myres[] = { 8, 50, 75, 100, 150, 200, 300, 600, 1200 }; + + res = (SANE_Int *) malloc (sizeof (myres)); + if (res != NULL) + memcpy (res, &myres, sizeof (myres)); + } + break; + + case HPG2710: + case HP3800: + { + /* 1200 and 2400 dpi are disabled until problems are solved */ + SANE_Int myres[] = { 7, 50, 75, 100, 150, 200, 300, 600 }; + + res = (SANE_Int *) malloc (sizeof (myres)); + if (res != NULL) + memcpy (res, &myres, sizeof (myres)); + } + break; + + case HP4370: + case HPG3010: + case HPG3110: + { + SANE_Int myres[] = + { 10, 50, 75, 100, 150, 200, 300, 600, 1200, 2400, 4800 }; + + res = (SANE_Int *) malloc (sizeof (myres)); + if (res != NULL) + memcpy (res, &myres, sizeof (myres)); + } + break; + + default: /* HP3970 & HP4070 & UA4900 */ + { + SANE_Int myres[] = + { 9, 50, 75, 100, 150, 200, 300, 600, 1200, 2400 }; + + res = (SANE_Int *) malloc (sizeof (myres)); + if (res != NULL) + memcpy (res, &myres, sizeof (myres)); + } + break; + } + + if (res != NULL) + { + if (scanner->list_resolutions != NULL) + free (scanner->list_resolutions); + + scanner->list_resolutions = res; + rst = SANE_STATUS_GOOD; + } + } + + return rst; +} + +static SANE_Status +bknd_models (TScanner * scanner) +{ + SANE_Status rst = SANE_STATUS_INVAL; + + DBG (DBG_FNC, "> bknd_models:\n"); + + if (scanner != NULL) + { + SANE_String_Const *model = NULL; + + /* at this moment all devices use the same list */ + SANE_String_Const mymodel[] = + { "HP3800", "HP3970", "HP4070", "HP4370", "UA4900", "HPG3010", +"BQ5550", "HPG2710", "HPG3110", 0 }; + + /* allocate space to save list */ + model = (SANE_String_Const *) malloc (sizeof (mymodel)); + if (model != NULL) + memcpy (model, &mymodel, sizeof (mymodel)); + + if (model != NULL) + { + /* free previous list */ + if (scanner->list_models != NULL) + free (scanner->list_models); + + /* set new list */ + scanner->list_models = model; + rst = SANE_STATUS_GOOD; + } + } + + return rst; +} + +static SANE_Status +bknd_colormodes (TScanner * scanner, SANE_Int model) +{ + SANE_Status rst = SANE_STATUS_INVAL; + + DBG (DBG_FNC, "> bknd_colormodes(*scanner, model=%i)\n", model); + + if (scanner != NULL) + { + SANE_String_Const *colormode = NULL; + + /* at this moment all devices use the same list */ + SANE_String_Const mycolormode[] = + { SANE_VALUE_SCAN_MODE_COLOR, SANE_VALUE_SCAN_MODE_GRAY, SANE_VALUE_SCAN_MODE_LINEART, 0 }; + + /* silence gcc */ + model = model; + + colormode = (SANE_String_Const *) malloc (sizeof (mycolormode)); + if (colormode != NULL) + memcpy (colormode, &mycolormode, sizeof (mycolormode)); + + if (colormode != NULL) + { + if (scanner->list_colormodes != NULL) + free (scanner->list_colormodes); + + scanner->list_colormodes = colormode; + rst = SANE_STATUS_GOOD; + } + } + + return rst; +} + +static SANE_Status +bknd_sources (TScanner * scanner, SANE_Int model) +{ + SANE_Status rst = SANE_STATUS_INVAL; + + DBG (DBG_FNC, "> bknd_sources(*scanner, model=%i)\n", model); + + if (scanner != NULL) + { + SANE_String_Const *source = NULL; + + switch (model) + { + case UA4900: + { + SANE_String_Const mysource[] = { SANE_I18N ("Flatbed"), 0 }; + source = (SANE_String_Const *) malloc (sizeof (mysource)); + if (source != NULL) + memcpy (source, &mysource, sizeof (mysource)); + } + break; + default: /* hp3970, hp4070, hp4370 and others */ + { + SANE_String_Const mysource[] = + { SANE_I18N ("Flatbed"), SANE_I18N ("Slide"), +SANE_I18N ("Negative"), 0 }; + source = (SANE_String_Const *) malloc (sizeof (mysource)); + if (source != NULL) + memcpy (source, &mysource, sizeof (mysource)); + } + break; + } + + if (source != NULL) + { + if (scanner->list_sources != NULL) + free (scanner->list_sources); + + scanner->list_sources = source; + rst = SANE_STATUS_GOOD; + } + } + + return rst; +} + +static SANE_Status +bknd_depths (TScanner * scanner, SANE_Int model) +{ + SANE_Status rst = SANE_STATUS_INVAL; + + DBG (DBG_FNC, "> bknd_depths(*scanner, model=%i\n", model); + + if (scanner != NULL) + { + SANE_Int *depth = NULL; + + /* at this moment all devices use the same list */ + SANE_Int mydepth[] = { 2, 8, 16 }; /*{3, 8, 12, 16}; */ + + /* silence gcc */ + model = model; + + depth = (SANE_Int *) malloc (sizeof (mydepth)); + if (depth != NULL) + memcpy (depth, &mydepth, sizeof (mydepth)); + + if (depth != NULL) + { + if (scanner->list_depths != NULL) + free (scanner->list_depths); + + scanner->list_depths = depth; + rst = SANE_STATUS_GOOD; + } + } + + return rst; +} + +static SANE_Status +bknd_info (TScanner * scanner) +{ + SANE_Status rst = SANE_STATUS_INVAL; + + DBG (DBG_FNC, "> bknd_info(*scanner)"); + + if (scanner != NULL) + { + char data[256]; + + /* update chipset name */ + Chipset_Name (device, data, 255); + if (scanner->aValues[opt_chipname].s != NULL) + { + free (scanner->aValues[opt_chipname].s); + scanner->aValues[opt_chipname].s = NULL; + } + + scanner->aValues[opt_chipname].s = strdup (data); + scanner->aOptions[opt_chipname].size = strlen (data) + 1; + + /* update chipset id */ + scanner->aValues[opt_chipid].w = Chipset_ID (device); + + /* update scans counter */ + scanner->aValues[opt_scancount].w = RTS_ScanCounter_Get (device); + + rst = SANE_STATUS_GOOD; + } + + return rst; +} + +static SANE_Int +GetUSB_device_model (SANE_String_Const name) +{ + SANE_Int usbid, model; + + /* default model is unknown */ + model = -1; + + /* open usb device */ + if (sanei_usb_open (name, &usbid) == SANE_STATUS_GOOD) + { + SANE_Int vendor, product; + + if (sanei_usb_get_vendor_product (usbid, &vendor, &product) == + SANE_STATUS_GOOD) + model = Device_get (product, vendor); + + sanei_usb_close (usbid); + } + + return model; +} + +static void +Silent_Compile (void) +{ + /* + There are some functions in hp3900_rts8822.c that aren't used yet. + To avoid compilation warnings we will use them here + */ + + SANE_Byte a = 1; + + if (a == 0) + { + Buttons_Status (device); + Calib_WriteTable (device, NULL, 0, 0); + Gamma_GetTables (device, NULL); + } +} + +static void +bknd_constrains (TScanner * scanner, SANE_Int source, SANE_Int type) +{ + struct st_coords *coords = Constrains_Get (device, source); + + if ((coords != NULL) && (scanner != NULL)) + { + switch (type) + { + case 1: /* Y */ + scanner->rng_vertical.max = coords->height; + break; + default: /* X */ + scanner->rng_horizontal.max = coords->width; + break; + } + } +} + +static SANE_Status +img_buffers_free (TScanner * scanner) +{ + if (scanner != NULL) + { + if (scanner->image != NULL) + { + free (scanner->image); + scanner->image = NULL; + } + + if (scanner->rest != NULL) + { + free (scanner->rest); + scanner->rest = NULL; + } + + scanner->rest_amount = 0; + } + + return SANE_STATUS_GOOD; +} + +static SANE_Status +img_buffers_alloc (TScanner * scanner, SANE_Int size) +{ + SANE_Status rst; + + /* default result at this point */ + rst = SANE_STATUS_INVAL; + + if (scanner != NULL) + { + /* default result at this point */ + rst = SANE_STATUS_NO_MEM; + + /* free previous allocs */ + img_buffers_free (scanner); + + scanner->image = (SANE_Byte *) malloc (size * sizeof (SANE_Byte)); + if (scanner->image != NULL) + { + scanner->rest = (SANE_Byte *) malloc (size * sizeof (SANE_Byte)); + if (scanner->rest != NULL) + rst = SANE_STATUS_GOOD; /* ok !! */ + } + + if (rst != SANE_STATUS_GOOD) + img_buffers_free (scanner); + } + + return rst; +} + +static SANE_Int +set_ScannerModel (SANE_Int proposed, SANE_Int product, SANE_Int vendor) +{ + /* This function will set the device behaviour */ + + SANE_Int current = Device_get (product, vendor); + char *sdevname[10] = + { "Unknown", "HP3970", "HP4070", "HP4370", "UA4900", "HP3800", "HPG3010", +"BQ5550", "HPG2710", "HPG3110" }; + + DBG (DBG_FNC, + "> set_ScannerModel(proposed=%i, product=%04x, vendor=%04x)\n", + proposed, product, vendor); + + if (proposed < 0) + { + if ((current < 0) || (current >= DEVSCOUNT)) + { + DBG (DBG_VRB, " -> Unknown device. Defaulting to HP3970...\n"); + RTS_Debug->dev_model = HP3970; + } + else + { + RTS_Debug->dev_model = current; + DBG (DBG_VRB, " -> Device model is %s\n", sdevname[current + 1]); + } + } + else + { + if (proposed < DEVSCOUNT) + { + RTS_Debug->dev_model = proposed; + DBG (DBG_VRB, " -> Device %s , treating as %s ...\n", + sdevname[current + 1], sdevname[proposed + 1]); + } + else + { + if ((current >= 0) && (current < DEVSCOUNT)) + { + RTS_Debug->dev_model = current; + DBG (DBG_VRB, + " -> Device not supported. Defaulting to %s ...\n", + sdevname[current + 1]); + } + else + { + RTS_Debug->dev_model = HP3970; + DBG (DBG_VRB, + "-> Device not supported. Defaulting to HP3970...\n"); + } + } + } + + return OK; +} + +static void +Set_Coordinates (SANE_Int scantype, SANE_Int resolution, + struct st_coords *coords) +{ + struct st_coords *limits = Constrains_Get (device, scantype); + + DBG (DBG_FNC, "> Set_Coordinates(res=%i, *coords):\n", resolution); + + if (coords->left == -1) + coords->left = 0; + + if (coords->width == -1) + coords->width = limits->width; + + if (coords->top == -1) + coords->top = 0; + + if (coords->height == -1) + coords->height = limits->height; + + DBG (DBG_FNC, " -> Coords [MM] : xy(%i, %i) wh(%i, %i)\n", coords->left, + coords->top, coords->width, coords->height); + + coords->left = MM_TO_PIXEL (coords->left, resolution); + coords->width = MM_TO_PIXEL (coords->width, resolution); + coords->top = MM_TO_PIXEL (coords->top, resolution); + coords->height = MM_TO_PIXEL (coords->height, resolution); + + DBG (DBG_FNC, " -> Coords [px] : xy(%i, %i) wh(%i, %i)\n", coords->left, + coords->top, coords->width, coords->height); + + Constrains_Check (device, resolution, scantype, coords); + + DBG (DBG_FNC, " -> Coords [check]: xy(%i, %i) wh(%i, %i)\n", coords->left, + coords->top, coords->width, coords->height); +} + +static void +Color_Negative (SANE_Byte * buffer, SANE_Int size, SANE_Int depth) +{ + if (buffer != NULL) + { + SANE_Int a; + SANE_Int max_value = (1 << depth) - 1; + + if (depth > 8) + { + USHORT *sColor = (void *) buffer; + for (a = 0; a < size / 2; a++) + { + *sColor = max_value - *sColor; + sColor++; + } + } + else + { + for (a = 0; a < size; a++) + *(buffer + a) = max_value - *(buffer + a); + } + } +} + +static SANE_Status +get_button_status (TScanner * s) +{ + if (s != NULL) + { + SANE_Int a, b, status, btn; + + b = 1; + status = Buttons_Released (device) & 63; + for (a = 0; a < 6; a++) + { + if ((status & b) != 0) + { + btn = Buttons_Order (device, b); + if (btn != -1) + s->aValues[opt_button_0 + btn].w = SANE_TRUE; + } + + b <<= 1; + } + } + + return SANE_STATUS_GOOD; +} + +static void +Depth_16_to_8 (SANE_Byte * from_buffer, SANE_Int size, SANE_Byte * to_buffer) +{ + if ((from_buffer != NULL) && (to_buffer != NULL)) + { + SANE_Int a, b; + + a = 1; + b = 0; + + while (a < size) + { + *(to_buffer + b) = *(from_buffer + a); + a += 2; + b++; + } + } +} + +static void +Gray_to_Lineart (SANE_Byte * buffer, SANE_Int size, SANE_Int threshold) +{ + /* code provided by tobias leutwein */ + + if (buffer != NULL) + { + SANE_Byte toBufferByte; + SANE_Int fromBufferPos_i = 0; + SANE_Int toBufferPos_i = 0; + SANE_Int bitPos_i; + + while (fromBufferPos_i < size) + { + toBufferByte = 0; + + for (bitPos_i = 7; bitPos_i != (-1); bitPos_i--) + { + if ((fromBufferPos_i < size) + && (buffer[fromBufferPos_i] < threshold)) + toBufferByte |= (1u << bitPos_i); + + fromBufferPos_i++; + } + + buffer[toBufferPos_i] = toBufferByte; + toBufferPos_i++; + } + } +} + +static void +Color_to_Gray (SANE_Byte * buffer, SANE_Int size, SANE_Int depth) +{ + /* converts 3 color channel into 1 gray channel of specified bit depth */ + + if (buffer != NULL) + { + SANE_Int c, chn, chn_size; + SANE_Byte *ptr_src = NULL; + SANE_Byte *ptr_dst = NULL; + float data, chn_data; + float coef[3] = { 0.299, 0.587, 0.114 }; /* coefficients per channel */ + + chn_size = (depth > 8) ? 2 : 1; + ptr_src = (void *) buffer; + ptr_dst = (void *) buffer; + + for (c = 0; c < size / (3 * chn_size); c++) + { + data = 0.; + + /* get, apply coeffs and sum channels */ + for (chn = 0; chn < 3; chn++) + { + chn_data = data_lsb_get (ptr_src + (chn * chn_size), chn_size); + data += (chn_data * coef[chn]); + } + + /* save result */ + data_lsb_set (ptr_dst, (SANE_Int) data, chn_size); + + ptr_src += 3 * chn_size; /* next triplet */ + ptr_dst += chn_size; + } + } +} + +static void +gamma_free (TScanner * s) +{ + DBG (DBG_FNC, "> gamma_free()\n"); + + if (s != NULL) + { + /* Destroy gamma tables */ + SANE_Int a; + + for (a = CL_RED; a <= CL_BLUE; a++) + { + if (s->aGammaTable[a] != NULL) + { + free (s->aGammaTable[a]); + s->aGammaTable[a] = NULL; + } + } + } +} + +static SANE_Int +gamma_create (TScanner * s, double gamma) +{ + SANE_Int rst = ERROR; /* by default */ + + DBG (DBG_FNC, "> gamma_create(*s)\n"); + + if (s != NULL) + { + SANE_Int a; + double value, c; + + /* default result */ + rst = OK; + + /* destroy previus gamma tables */ + gamma_free (s); + + /* check gamma value */ + if (gamma < 0) + gamma = GAMMA_DEFAULT; + + /* allocate space for 16 bit gamma tables */ + for (a = CL_RED; a <= CL_BLUE; a++) + { + s->aGammaTable[a] = malloc (65536 * sizeof (SANE_Word)); + if (s->aGammaTable[a] == NULL) + { + rst = ERROR; + break; + } + } + + if (rst == OK) + { + /* fill tables */ + for (a = 0; a < 65536; a++) + { + value = (a / (65536. - 1)); + value = pow (value, (1. / gamma)); + value = value * (65536. - 1); + + c = (SANE_Int) value; + if (c > (65536. - 1)) + c = (65536. - 1); + else if (c < 0) + c = 0; + + s->aGammaTable[CL_RED][a] = c; + s->aGammaTable[CL_GREEN][a] = c; + s->aGammaTable[CL_BLUE][a] = c; + } + } + else + gamma_free (s); + } + + return rst; +} + +static void +gamma_apply (TScanner * s, SANE_Byte * buffer, SANE_Int size, SANE_Int depth) +{ + if ((s != NULL) && (buffer != NULL)) + { + SANE_Int c; + SANE_Int dot_size = 3 * ((depth > 8) ? 2 : 1); + SANE_Byte *pColor = buffer; + USHORT *sColor = (void *) buffer; + + if ((s->aGammaTable[CL_RED] != NULL) + && (s->aGammaTable[CL_GREEN] != NULL) + && (s->aGammaTable[CL_BLUE] != NULL)) + { + for (c = 0; c < size / dot_size; c++) + { + if (depth > 8) + { + *sColor = s->aGammaTable[CL_RED][*sColor]; + *(sColor + 1) = s->aGammaTable[CL_GREEN][*(sColor + 1)]; + *(sColor + 2) = s->aGammaTable[CL_BLUE][*(sColor + 2)]; + sColor += 3; + } + else + { + /* 8 bits gamma */ + *pColor = + (s->aGammaTable[CL_RED][*pColor * 256] >> 8) & 0xff; + *(pColor + 1) = + (s-> + aGammaTable[CL_GREEN][*(pColor + 1) * 256] >> 8) & 0xff; + *(pColor + 2) = + (s-> + aGammaTable[CL_BLUE][*(pColor + 2) * 256] >> 8) & 0xff; + pColor += 3; + } + } + } + } +} + +static SANE_Int +Get_Model (SANE_String model) +{ + SANE_Int rst; + + if (strcmp (model, "HP3800") == 0) + rst = HP3800; + else if (strcmp (model, "HPG2710") == 0) + rst = HPG2710; + else if (strcmp (model, "HP3970") == 0) + rst = HP3970; + else if (strcmp (model, "HP4070") == 0) + rst = HP4070; + else if (strcmp (model, "HP4370") == 0) + rst = HP4370; + else if (strcmp (model, "HPG3010") == 0) + rst = HPG3010; + else if (strcmp (model, "HPG3110") == 0) + rst = HPG3110; + else if (strcmp (model, "UA4900") == 0) + rst = UA4900; + else if (strcmp (model, "BQ5550") == 0) + rst = BQ5550; + else + rst = HP3970; /* default */ + + return rst; +} + +static SANE_Int +Get_Source (SANE_String source) +{ + SANE_Int rst; + + if (strcmp (source, SANE_I18N ("Flatbed")) == 0) + rst = ST_NORMAL; + else if (strcmp (source, SANE_I18N ("Slide")) == 0) + rst = ST_TA; + else if (strcmp (source, SANE_I18N ("Negative")) == 0) + rst = ST_NEG; + else + rst = ST_NORMAL; /* default */ + + return rst; +} + +static SANE_Int +Get_Colormode (SANE_String colormode) +{ + SANE_Int rst; + + if (strcmp (colormode, SANE_VALUE_SCAN_MODE_COLOR) == 0) + rst = CM_COLOR; + else if (strcmp (colormode, SANE_VALUE_SCAN_MODE_GRAY) == 0) + rst = CM_GRAY; + else if (strcmp (colormode, SANE_VALUE_SCAN_MODE_LINEART) == 0) + rst = CM_LINEART; + else + rst = CM_COLOR; /* default */ + + return rst; +} + +static SANE_Status +Translate_coords (struct st_coords *coords) +{ + SANE_Int data; + + DBG (DBG_FNC, "> Translate_coords(*coords)\n"); + + if ((coords->left < 0) || (coords->top < 0) || + (coords->width < 0) || (coords->height < 0)) + return SANE_STATUS_INVAL; + + if (coords->width < coords->left) + { + data = coords->left; + coords->left = coords->width; + coords->width = data; + } + + if (coords->height < coords->top) + { + data = coords->top; + coords->top = coords->height; + coords->height = data; + } + + coords->width -= coords->left; + coords->height -= coords->top; + + if (coords->width == 0) + coords->width++; + + if (coords->height == 0) + coords->height++; + + return SANE_STATUS_GOOD; +} + +static size_t +max_string_size (const SANE_String_Const strings[]) +{ + size_t size, max_size = 0; + SANE_Int i; + + DBG (DBG_FNC, "> max_string_size:\n"); + + for (i = 0; strings[i]; ++i) + { + size = strlen (strings[i]) + 1; + if (size > max_size) + max_size = size; + } + + return max_size; +} + +static void +options_free (TScanner * scanner) +{ + /* frees all information contained in controls */ + + DBG (DBG_FNC, "> options_free\n"); + + if (scanner != NULL) + { + SANE_Int i; + SANE_Option_Descriptor *pDesc; + TOptionValue *pVal; + + /* free gamma tables */ + gamma_free (scanner); + + /* free lists */ + if (scanner->list_resolutions != NULL) + free (scanner->list_resolutions); + + if (scanner->list_depths != NULL) + free (scanner->list_depths); + + if (scanner->list_sources != NULL) + free (scanner->list_sources); + + if (scanner->list_colormodes != NULL) + free (scanner->list_colormodes); + + if (scanner->list_models != NULL) + free (scanner->list_models); + + /* free values in certain controls */ + for (i = opt_begin; i < opt_count; i++) + { + pDesc = &scanner->aOptions[i]; + pVal = &scanner->aValues[i]; + + if (pDesc->type == SANE_TYPE_STRING) + { + if (pVal->s != NULL) + free (pVal->s); + } + } + } +} + +static void +options_init (TScanner * scanner) +{ + /* initializes all controls */ + + DBG (DBG_FNC, "> options_init\n"); + + if (scanner != NULL) + { + SANE_Int i; + SANE_Option_Descriptor *pDesc; + TOptionValue *pVal; + + /* set gamma */ + gamma_create (scanner, 2.2); + + /* color convertion */ + scanner->cnv.colormode = -1; + scanner->cnv.negative = FALSE; + scanner->cnv.threshold = 40; + scanner->cnv.real_depth = FALSE; + scanner->cnv.depth = -1; + + /* setting threshold */ + scanner->rng_threshold.min = 0; + scanner->rng_threshold.max = 255; + scanner->rng_threshold.quant = 0; + + /* setting gamma range (16 bits depth) */ + scanner->rng_gamma.min = 0; + scanner->rng_gamma.max = 65535; + scanner->rng_gamma.quant = 0; + + /* setting default horizontal constrain in milimeters */ + scanner->rng_horizontal.min = 0; + scanner->rng_horizontal.max = 220; + scanner->rng_horizontal.quant = 1; + + /* setting default vertical constrain in milimeters */ + scanner->rng_vertical.min = 0; + scanner->rng_vertical.max = 300; + scanner->rng_vertical.quant = 1; + + /* allocate option lists */ + bknd_info (scanner); + bknd_colormodes (scanner, RTS_Debug->dev_model); + bknd_depths (scanner, RTS_Debug->dev_model); + bknd_models (scanner); + bknd_resolutions (scanner, RTS_Debug->dev_model); + bknd_sources (scanner, RTS_Debug->dev_model); + + /* By default preview scan */ + scanner->ScanParams.scantype = ST_NORMAL; + scanner->ScanParams.colormode = CM_COLOR; + scanner->ScanParams.resolution_x = 75; + scanner->ScanParams.resolution_y = 75; + scanner->ScanParams.coords.left = 0; + scanner->ScanParams.coords.top = 0; + scanner->ScanParams.coords.width = 220; + scanner->ScanParams.coords.height = 300; + scanner->ScanParams.depth = 8; + scanner->ScanParams.channel = 0; + + for (i = opt_begin; i < opt_count; i++) + { + pDesc = &scanner->aOptions[i]; + pVal = &scanner->aValues[i]; + + /* defaults */ + pDesc->name = ""; + pDesc->title = ""; + pDesc->desc = ""; + pDesc->type = SANE_TYPE_INT; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->cap = 0; + + switch (i) + { + case opt_begin: + pDesc->title = SANE_TITLE_NUM_OPTIONS; + pDesc->desc = SANE_DESC_NUM_OPTIONS; + pDesc->cap = SANE_CAP_SOFT_DETECT; + pVal->w = (SANE_Word) opt_count; + break; + + case grp_geometry: + pDesc->name = SANE_NAME_GEOMETRY; + pDesc->title = SANE_TITLE_GEOMETRY; + pDesc->desc = SANE_DESC_GEOMETRY; + pDesc->type = SANE_TYPE_GROUP; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = 0; + pDesc->cap = 0; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pVal->w = 0; + break; + + case opt_tlx: + pDesc->name = SANE_NAME_SCAN_TL_X; + pDesc->title = SANE_TITLE_SCAN_TL_X; + pDesc->desc = SANE_DESC_SCAN_TL_X; + pDesc->unit = SANE_UNIT_MM; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_horizontal; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->w = 0; + break; + + case opt_tly: + pDesc->name = SANE_NAME_SCAN_TL_Y; + pDesc->title = SANE_TITLE_SCAN_TL_Y; + pDesc->desc = SANE_DESC_SCAN_TL_Y; + pDesc->unit = SANE_UNIT_MM; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_vertical; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->w = 0; + break; + + case opt_brx: + pDesc->name = SANE_NAME_SCAN_BR_X; + pDesc->title = SANE_TITLE_SCAN_BR_X; + pDesc->desc = SANE_DESC_SCAN_BR_X; + pDesc->unit = SANE_UNIT_MM; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_horizontal; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->w = scanner->rng_horizontal.max; + break; + + case opt_bry: + pDesc->name = SANE_NAME_SCAN_BR_Y; + pDesc->title = SANE_TITLE_SCAN_BR_Y; + pDesc->desc = SANE_DESC_SCAN_BR_Y; + pDesc->unit = SANE_UNIT_MM; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_vertical; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->w = scanner->rng_vertical.max; + break; + + case opt_resolution: + pDesc->name = SANE_NAME_SCAN_RESOLUTION; + pDesc->title = SANE_TITLE_SCAN_RESOLUTION; + pDesc->desc = SANE_DESC_SCAN_RESOLUTION; + pDesc->unit = SANE_UNIT_DPI; + pDesc->constraint_type = SANE_CONSTRAINT_WORD_LIST; + pDesc->constraint.word_list = scanner->list_resolutions; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->w = scanner->list_resolutions[1]; + break; + + case opt_gamma_red: + pDesc->name = SANE_NAME_GAMMA_VECTOR_R; + pDesc->title = SANE_TITLE_GAMMA_VECTOR_R; + pDesc->desc = SANE_DESC_GAMMA_VECTOR_R; + pDesc->size = scanner->rng_gamma.max * sizeof (SANE_Word); + pDesc->unit = SANE_UNIT_NONE; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_gamma; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->wa = scanner->aGammaTable[CL_RED]; + break; + + case opt_gamma_green: + pDesc->name = SANE_NAME_GAMMA_VECTOR_G; + pDesc->title = SANE_TITLE_GAMMA_VECTOR_G; + pDesc->desc = SANE_DESC_GAMMA_VECTOR_G; + pDesc->size = scanner->rng_gamma.max * sizeof (SANE_Word); + pDesc->unit = SANE_UNIT_NONE; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_gamma; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->wa = scanner->aGammaTable[CL_GREEN]; + break; + + case opt_gamma_blue: + pDesc->name = SANE_NAME_GAMMA_VECTOR_B; + pDesc->title = SANE_TITLE_GAMMA_VECTOR_B; + pDesc->desc = SANE_DESC_GAMMA_VECTOR_B; + pDesc->size = scanner->rng_gamma.max * sizeof (SANE_Word); + pDesc->unit = SANE_UNIT_NONE; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_gamma; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->wa = scanner->aGammaTable[CL_BLUE]; + break; + + case opt_scantype: + pDesc->name = SANE_NAME_SCAN_SOURCE; + pDesc->title = SANE_TITLE_SCAN_SOURCE; + pDesc->desc = SANE_DESC_SCAN_SOURCE; + pDesc->type = SANE_TYPE_STRING; + pDesc->size = max_string_size (scanner->list_sources); + pDesc->constraint_type = SANE_CONSTRAINT_STRING_LIST; + pDesc->constraint.string_list = scanner->list_sources; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->s = strdup (scanner->list_sources[0]); + break; + + case opt_colormode: + pDesc->name = SANE_NAME_SCAN_MODE; + pDesc->title = SANE_TITLE_SCAN_MODE; + pDesc->desc = SANE_DESC_SCAN_MODE; + pDesc->type = SANE_TYPE_STRING; + pDesc->size = max_string_size (scanner->list_colormodes); + pDesc->constraint_type = SANE_CONSTRAINT_STRING_LIST; + pDesc->constraint.string_list = scanner->list_colormodes; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->s = strdup (scanner->list_colormodes[0]); + break; + + case opt_depth: + pDesc->name = SANE_NAME_BIT_DEPTH; + pDesc->title = SANE_TITLE_BIT_DEPTH; + pDesc->desc = SANE_DESC_BIT_DEPTH; + pDesc->type = SANE_TYPE_INT; + pDesc->unit = SANE_UNIT_BIT; + pDesc->constraint_type = SANE_CONSTRAINT_WORD_LIST; + pDesc->constraint.word_list = scanner->list_depths; + pDesc->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + pVal->w = scanner->list_depths[1]; + break; + + case opt_threshold: + pDesc->name = SANE_NAME_THRESHOLD; + pDesc->title = SANE_TITLE_THRESHOLD; + pDesc->desc = SANE_DESC_THRESHOLD; + pDesc->type = SANE_TYPE_INT; + pDesc->unit = SANE_UNIT_NONE; + pDesc->constraint_type = SANE_CONSTRAINT_RANGE; + pDesc->constraint.range = &scanner->rng_threshold; + pDesc->cap |= + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | + SANE_CAP_INACTIVE; + pVal->w = 0x80; + break; + + /* debugging options */ + case grp_debug: + pDesc->name = "grp_debug"; + pDesc->title = SANE_I18N ("Debugging Options"); + pDesc->desc = ""; + pDesc->type = SANE_TYPE_GROUP; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = 0; + pDesc->cap = SANE_CAP_ADVANCED; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pVal->w = 0; + break; + + case opt_model: + pDesc->name = "opt_model"; + pDesc->title = SANE_I18N ("Scanner model"); + pDesc->desc = + SANE_I18N + ("Allows to test device behaviour with other supported models"); + pDesc->type = SANE_TYPE_STRING; + pDesc->size = max_string_size (scanner->list_models); + pDesc->constraint_type = SANE_CONSTRAINT_STRING_LIST; + pDesc->constraint.string_list = scanner->list_models; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_SELECT | + SANE_CAP_SOFT_DETECT; + pVal->s = strdup (scanner->list_models[0]); + break; + + case opt_negative: + pDesc->name = "opt_negative"; + pDesc->title = SANE_I18N ("Negative"); + pDesc->desc = SANE_I18N ("Image colours will be inverted"); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_nogamma: + pDesc->name = "opt_nogamma"; + pDesc->title = SANE_I18N ("Disable gamma correction"); + pDesc->desc = SANE_I18N ("Gamma correction will be disabled"); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_nowshading: + pDesc->name = "opt_nowshading"; + pDesc->title = SANE_I18N ("Disable white shading correction"); + pDesc->desc = + SANE_I18N ("White shading correction will be disabled"); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_nowarmup: + pDesc->name = "opt_nowarmup"; + pDesc->title = SANE_I18N ("Skip warmup process"); + pDesc->desc = SANE_I18N ("Warmup process will be disabled"); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_realdepth: + pDesc->name = "opt_realdepth"; + pDesc->title = SANE_I18N ("Force real depth"); + pDesc->desc = + SANE_I18N + ("If gamma is enabled, scans are always made in 16 bits depth to improve image quality and then converted to the selected depth. This option avoids depth emulation."); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_emulategray: + pDesc->name = "opt_emulategray"; + pDesc->title = SANE_I18N ("Emulate Grayscale"); + pDesc->desc = + SANE_I18N + ("If enabled, image will be scanned in color mode and then converted to grayscale by software. This may improve image quality in some circumstances."); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_dbgimages: + pDesc->name = "opt_dbgimages"; + pDesc->title = SANE_I18N ("Save debugging images"); + pDesc->desc = + SANE_I18N + ("If enabled, some images involved in scanner processing are saved to analyze them."); + pDesc->type = SANE_TYPE_BOOL; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pDesc->cap = + SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT | + SANE_CAP_SOFT_SELECT; + pVal->w = SANE_FALSE; + break; + + case opt_reset: + pDesc->name = "opt_reset"; + pDesc->title = SANE_I18N ("Reset chipset"); + pDesc->desc = SANE_I18N ("Resets chipset data"); + pDesc->type = SANE_TYPE_BUTTON; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = 0; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.string_list = 0; + pDesc->cap = SANE_CAP_ADVANCED | SANE_CAP_SOFT_SELECT; + pVal->w = 0; + break; + + /* device information */ + case grp_info: + pDesc->name = "grp_info"; + pDesc->title = SANE_I18N ("Information"); + pDesc->desc = ""; + pDesc->type = SANE_TYPE_GROUP; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = 0; + pDesc->cap = 0; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pVal->w = 0; + break; + + case opt_chipname: + pDesc->name = "opt_chipname"; + pDesc->title = SANE_I18N ("Chipset name"); + pDesc->desc = SANE_I18N ("Shows chipset name used in device."); + pDesc->type = SANE_TYPE_STRING; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->cap = SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT; + pVal->s = strdup (SANE_I18N ("Unknown")); + pDesc->size = strlen(pVal->s) + 1; + break; + + case opt_chipid: + pDesc->name = "opt_chipid"; + pDesc->title = SANE_I18N ("Chipset ID"); + pDesc->desc = SANE_I18N ("Shows the chipset ID"); + pDesc->type = SANE_TYPE_INT; + pDesc->unit = SANE_UNIT_NONE; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->cap = SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT; + pVal->w = -1; + break; + + case opt_scancount: + pDesc->name = "opt_scancount"; + pDesc->title = SANE_I18N ("Scan counter"); + pDesc->desc = + SANE_I18N ("Shows the number of scans made by scanner"); + pDesc->type = SANE_TYPE_INT; + pDesc->unit = SANE_UNIT_NONE; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->cap = SANE_CAP_ADVANCED | SANE_CAP_SOFT_DETECT; + pVal->w = -1; + break; + + case opt_infoupdate: + pDesc->name = "opt_infoupdate"; + pDesc->title = SANE_I18N ("Update information"); + pDesc->desc = SANE_I18N ("Updates information about device"); + pDesc->type = SANE_TYPE_BUTTON; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = 0; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.string_list = 0; + pDesc->cap = SANE_CAP_ADVANCED | SANE_CAP_SOFT_SELECT; + pVal->w = 0; + break; + + /* buttons support */ + case grp_sensors: + pDesc->name = SANE_NAME_SENSORS; + pDesc->title = SANE_TITLE_SENSORS; + pDesc->desc = SANE_DESC_SENSORS; + pDesc->type = SANE_TYPE_GROUP; + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = 0; + pDesc->cap = 0; + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pDesc->constraint.range = 0; + pVal->w = 0; + break; + + case opt_button_0: + case opt_button_1: + case opt_button_2: + case opt_button_3: + case opt_button_4: + case opt_button_5: + { + char name[12]; + char title[128]; + + sprintf (name, "button %d", i - opt_button_0); + sprintf (title, "Scanner button %d", i - opt_button_0); + pDesc->name = strdup (name); + pDesc->title = strdup (title); + pDesc->desc = + SANE_I18N + ("This option reflects a front panel scanner button"); + pDesc->type = SANE_TYPE_BOOL; + pDesc->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; + + if (i - opt_button_0 >= Buttons_Count (device)) + pDesc->cap |= SANE_CAP_INACTIVE; + + pDesc->unit = SANE_UNIT_NONE; + pDesc->size = sizeof (SANE_Word); + pDesc->constraint_type = SANE_CONSTRAINT_NONE; + pVal->w = SANE_FALSE; + } + break; + } + } + } +} + +static SANE_Int +_ReportDevice (TScannerModel * pModel, const char *pszDeviceName) +{ + SANE_Int rst = ERROR; + TDevListEntry *pNew, *pDev; + + DBG (DBG_FNC, "> _ReportDevice:\n"); + + pNew = malloc (sizeof (TDevListEntry)); + if (pNew != NULL) + { + rst = OK; + + /* add new element to the end of the list */ + if (_pFirstSaneDev != NULL) + { + /* Add at the end of existing list */ + for (pDev = _pFirstSaneDev; pDev->pNext; pDev = pDev->pNext); + + pDev->pNext = pNew; + } + else + _pFirstSaneDev = pNew; + + /* fill in new element */ + pNew->pNext = NULL; + pNew->devname = (char *) strdup (pszDeviceName); + pNew->dev.name = pNew->devname; + pNew->dev.vendor = pModel->pszVendor; + pNew->dev.model = pModel->pszName; + pNew->dev.type = SANE_I18N ("flatbed scanner"); + + iNumSaneDev++; + } + + return rst; +} + +static SANE_Status +attach_one_device (SANE_String_Const devname) +{ + static TScannerModel sModel; + + DBG (DBG_FNC, "> attach_one_device(devname=%s)\n", devname); + + switch (GetUSB_device_model (devname)) + { + case HP3800: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet 3800"); + break; + case HPG2710: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet G2710"); + break; + case HP3970: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet 3970"); + break; + case HP4070: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet 4070 Photosmart"); + break; + case HP4370: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet 4370"); + break; + case HPG3010: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet G3010"); + break; + case HPG3110: + sModel.pszVendor = (char *) strdup ("Hewlett-Packard"); + sModel.pszName = (char *) strdup ("Scanjet G3110"); + break; + case UA4900: + sModel.pszVendor = (char *) strdup ("UMAX"); + sModel.pszName = (char *) strdup ("Astra 4900"); + break; + case BQ5550: + sModel.pszVendor = (char *) strdup ("BenQ"); + sModel.pszName = (char *) strdup ("5550"); + break; + default: + sModel.pszVendor = (char *) strdup ("Unknown"); + sModel.pszName = (char *) strdup ("RTS8822 chipset based"); + break; + } + + _ReportDevice (&sModel, devname); + + return SANE_STATUS_GOOD; +} + +/* Sane default functions */ + +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ + FILE *conf_fp; /* Config file stream */ + SANE_Char line[PATH_MAX]; + SANE_Char *str = NULL; + SANE_String_Const proper_str; + SANE_Int nline = 0; + + /* Initialize debug */ + DBG_INIT (); + + DBG (DBG_FNC, "> sane_init\n"); + + /* silence gcc */ + authorize = authorize; + + /* Initialize usb */ + sanei_usb_init (); + + /* Parse config file */ + conf_fp = sanei_config_open (HP3900_CONFIG_FILE); + if (conf_fp) + { + while (sanei_config_read (line, sizeof (line), conf_fp)) + { + nline++; + if (str) + free (str); + + proper_str = sanei_config_get_string (line, &str); + + /* Discards white lines and comments */ + if ((str != NULL) && (proper_str != line) && (str[0] != '#')) + { + /* If line's not blank or a comment, then it's the device + * filename or a usb directive. */ + sanei_usb_attach_matching_devices (line, attach_one_device); + } + } + fclose (conf_fp); + } + else + { + /* default */ + DBG (DBG_VRB, "- %s not found. Looking for hardcoded usb ids ...\n", + HP3900_CONFIG_FILE); + + sanei_usb_attach_matching_devices ("usb 0x03f0 0x2605", attach_one_device); /* HP3800 */ + sanei_usb_attach_matching_devices ("usb 0x03f0 0x2805", attach_one_device); /* HPG2710 */ + sanei_usb_attach_matching_devices ("usb 0x03f0 0x2305", attach_one_device); /* HP3970 */ + sanei_usb_attach_matching_devices ("usb 0x03f0 0x2405", attach_one_device); /* HP4070 */ + sanei_usb_attach_matching_devices ("usb 0x03f0 0x4105", attach_one_device); /* HP4370 */ + sanei_usb_attach_matching_devices ("usb 0x03f0 0x4205", attach_one_device); /* HPG3010 */ + sanei_usb_attach_matching_devices ("usb 0x03f0 0x4305", attach_one_device); /* HPG3110 */ + sanei_usb_attach_matching_devices ("usb 0x06dc 0x0020", attach_one_device); /* UA4900 */ + sanei_usb_attach_matching_devices ("usb 0x04a5 0x2211", attach_one_device); /* BQ5550 */ + } + + /* Return backend version */ + if (version_code != NULL) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) +{ + SANE_Status rst = SANE_STATUS_GOOD; + + local_only = local_only; + + if (_pSaneDevList) + free (_pSaneDevList); + + _pSaneDevList = malloc (sizeof (*_pSaneDevList) * (iNumSaneDev + 1)); + if (_pSaneDevList != NULL) + { + TDevListEntry *pDev; + SANE_Int i = 0; + + for (pDev = _pFirstSaneDev; pDev; pDev = pDev->pNext) + _pSaneDevList[i++] = &pDev->dev; + + _pSaneDevList[i++] = 0; /* last entry is 0 */ + *device_list = _pSaneDevList; + } + else + rst = SANE_STATUS_NO_MEM; + + DBG (DBG_FNC, "> sane_get_devices: %i\n", rst); + + return rst; +} + +SANE_Status +sane_open (SANE_String_Const name, SANE_Handle * h) +{ + TScanner *s; + SANE_Status rst; + + /* check the name */ + if (strlen (name) == 0) + /* default to first available device */ + name = _pFirstSaneDev->dev.name; + + /* allocate space for RTS environment */ + device = RTS_Alloc (); + if (device != NULL) + { + /* Open device */ + rst = sanei_usb_open (name, &device->usb_handle); + if (rst == SANE_STATUS_GOOD) + { + /* Allocating memory for device */ + s = malloc (sizeof (TScanner)); + if (s != NULL) + { + memset (s, 0, sizeof (TScanner)); + + /* Initializing RTS */ + if (Init_Vars () == OK) + { + SANE_Int vendor, product; + + /* Setting device model */ + if (sanei_usb_get_vendor_product + (device->usb_handle, &vendor, + &product) == SANE_STATUS_GOOD) + s->model = Device_get (product, vendor); + else + s->model = HP3970; + + set_ScannerModel (s->model, product, vendor); + + /* Initialize device */ + if (RTS_Scanner_Init (device) == OK) + { + /* silencing unused functions */ + Silent_Compile (); + + /* initialize backend options */ + options_init (s); + *h = s; + + /* everything went ok */ + rst = SANE_STATUS_GOOD; + } + else + { + free ((void *) s); + rst = SANE_STATUS_INVAL; + } + } + else + rst = SANE_STATUS_NO_MEM; + } + else + rst = SANE_STATUS_NO_MEM; + } + } + else + rst = SANE_STATUS_NO_MEM; + + DBG (DBG_FNC, "> sane_open(name=%s): %i\n", name, rst); + + return rst; +} + +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle h, SANE_Int n) +{ + SANE_Option_Descriptor *rst = NULL; + + if ((n >= opt_begin) && (n < opt_count)) + { + TScanner *s = (TScanner *) h; + rst = &s->aOptions[n]; + } + + DBG (DBG_FNC, "> SANE_Option_Descriptor(handle, n=%i): %i\n", n, + (rst == NULL) ? -1 : 0); + + return rst; +} + +static SANE_Status +option_get (TScanner * scanner, SANE_Int optid, void *result) +{ + /* This function returns value contained in selected option */ + + DBG (DBG_FNC, "> option_get(optid=%i)\n", optid); + + if ((scanner != NULL) && (result != NULL)) + { + switch (optid) + { + /* SANE_Word */ + case opt_begin: /* null */ + case opt_reset: /* null */ + case opt_negative: + case opt_nogamma: + case opt_nowshading: + case opt_emulategray: + case opt_dbgimages: + case opt_nowarmup: + case opt_realdepth: + case opt_depth: + case opt_resolution: + case opt_threshold: + case opt_brx: + case opt_tlx: + case opt_bry: + case opt_tly: + *(SANE_Word *) result = scanner->aValues[optid].w; + break; + + /* SANE_Int */ + case opt_chipid: + case opt_scancount: + *(SANE_Int *) result = scanner->aValues[optid].w; + break; + + /* SANE_Word array */ + case opt_gamma_red: + case opt_gamma_green: + case opt_gamma_blue: + memcpy (result, scanner->aValues[optid].wa, + scanner->aOptions[optid].size); + break; + + /* String */ + case opt_colormode: + case opt_scantype: + case opt_model: + case opt_chipname: + strncpy (result, scanner->aValues[optid].s, scanner->aOptions[optid].size); + ((char*)result)[scanner->aOptions[optid].size-1] = '\0'; + + break; + + /* scanner buttons */ + case opt_button_0: + get_button_status (scanner); + case opt_button_1: + case opt_button_2: + case opt_button_3: + case opt_button_4: + case opt_button_5: + /* copy the button state */ + *(SANE_Word *) result = scanner->aValues[optid].w; + /* clear the button state */ + scanner->aValues[optid].w = SANE_FALSE; + break; + } + } + + return SANE_STATUS_GOOD; +} + +static SANE_Status +option_set (TScanner * scanner, SANE_Int optid, void *value, SANE_Int * pInfo) +{ + SANE_Status rst; + + DBG (DBG_FNC, "> option_set(optid=%i)\n", optid); + + rst = SANE_STATUS_INVAL; + + if (scanner != NULL) + { + if (scanner->fScanning == FALSE) + { + SANE_Int info = 0; + + rst = SANE_STATUS_GOOD; + + switch (optid) + { + case opt_brx: + case opt_tlx: + case opt_bry: + case opt_tly: + case opt_depth: + case opt_nogamma: + case opt_nowshading: + case opt_nowarmup: + case opt_negative: + case opt_emulategray: + case opt_dbgimages: + case opt_threshold: + case opt_resolution: + info |= SANE_INFO_RELOAD_PARAMS; + scanner->aValues[optid].w = *(SANE_Word *) value; + break; + + case opt_gamma_red: + case opt_gamma_green: + case opt_gamma_blue: + memcpy (scanner->aValues[optid].wa, value, + scanner->aOptions[optid].size); + break; + + case opt_scantype: + if (strcmp (scanner->aValues[optid].s, value) != 0) + { + struct st_coords *coords; + SANE_Int source; + + if (scanner->aValues[optid].s) + free (scanner->aValues[optid].s); + + scanner->aValues[optid].s = strdup (value); + + source = Get_Source (scanner->aValues[opt_scantype].s); + coords = Constrains_Get (device, source); + if (coords != NULL) + { + bknd_constrains (scanner, source, 0); + bknd_constrains (scanner, source, 1); + scanner->aValues[opt_tlx].w = 0; + scanner->aValues[opt_tly].w = 0; + scanner->aValues[opt_brx].w = coords->width; + scanner->aValues[opt_bry].w = coords->height; + } + + info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + } + break; + + case opt_colormode: + if (strcmp (scanner->aValues[optid].s, value) != 0) + { + if (scanner->aValues[optid].s) + free (scanner->aValues[optid].s); + scanner->aValues[optid].s = strdup (value); + if (Get_Colormode (scanner->aValues[optid].s) == CM_LINEART) + scanner->aOptions[opt_threshold].cap &= + ~SANE_CAP_INACTIVE; + else + scanner->aOptions[opt_threshold].cap |= SANE_CAP_INACTIVE; + info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + } + break; + + case opt_model: + if (strcmp (scanner->aValues[optid].s, value) != 0) + { + SANE_Int model; + + if (scanner->aValues[optid].s) + free (scanner->aValues[optid].s); + scanner->aValues[optid].s = strdup (value); + + model = Get_Model (scanner->aValues[optid].s); + if (model != RTS_Debug->dev_model) + { + SANE_Int source; + struct st_coords *coords; + + /* free configuration of last model */ + Free_Config (device); + + /* set new model */ + RTS_Debug->dev_model = model; + + /* and load configuration of current model */ + Load_Config (device); + + /* update options according to selected device */ + bknd_info (scanner); + bknd_colormodes (scanner, model); + bknd_depths (scanner, model); + bknd_resolutions (scanner, model); + bknd_sources (scanner, model); + + /* updating lists */ + scanner->aOptions[opt_colormode].size = + max_string_size (scanner->list_colormodes); + scanner->aOptions[opt_colormode].constraint. + string_list = scanner->list_colormodes; + scanner->aOptions[opt_depth].constraint.word_list = + scanner->list_depths; + scanner->aOptions[opt_resolution].constraint.word_list = + scanner->list_resolutions; + scanner->aOptions[opt_scantype].size = + max_string_size (scanner->list_sources); + scanner->aOptions[opt_scantype].constraint.string_list = + scanner->list_sources; + + /* default values */ + if (scanner->aValues[opt_colormode].s != NULL) + free (scanner->aValues[opt_colormode].s); + + if (scanner->aValues[opt_scantype].s != NULL) + free (scanner->aValues[opt_scantype].s); + + scanner->aValues[opt_colormode].s = + strdup (scanner->list_colormodes[0]); + scanner->aValues[opt_scantype].s = + strdup (scanner->list_sources[0]); + scanner->aValues[opt_resolution].w = + scanner->list_resolutions[1]; + scanner->aValues[opt_depth].w = scanner->list_depths[1]; + + source = Get_Source (scanner->aValues[opt_scantype].s); + coords = Constrains_Get (device, source); + if (coords != NULL) + { + bknd_constrains (scanner, source, 0); + bknd_constrains (scanner, source, 1); + scanner->aValues[opt_tlx].w = 0; + scanner->aValues[opt_tly].w = 0; + scanner->aValues[opt_brx].w = coords->width; + scanner->aValues[opt_bry].w = coords->height; + } + } + + info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + } + break; + + case opt_reset: + Chipset_Reset (device); + break; + + case opt_realdepth: + scanner->aValues[optid].w = + (scanner->cnv.real_depth == TRUE) ? SANE_TRUE : SANE_FALSE; + break; + + case opt_infoupdate: + if (bknd_info (scanner) == SANE_STATUS_GOOD) + info |= SANE_INFO_RELOAD_OPTIONS; + break; + + default: + rst = SANE_STATUS_INVAL; + break; + } + + if (pInfo != NULL) + *pInfo = info; + } + } + + return rst; +} + +SANE_Status +sane_control_option (SANE_Handle h, SANE_Int n, SANE_Action Action, + void *pVal, SANE_Int * pInfo) +{ + TScanner *scanner; + SANE_Status rst; + + DBG (DBG_FNC, "> sane_control_option\n"); + + scanner = (TScanner *) h; + + switch (Action) + { + case SANE_ACTION_GET_VALUE: + rst = option_get (scanner, n, pVal); + break; + + case SANE_ACTION_SET_VALUE: + rst = option_set (scanner, n, pVal, pInfo); + break; + + case SANE_ACTION_SET_AUTO: + rst = SANE_STATUS_UNSUPPORTED; + break; + + default: + rst = SANE_STATUS_INVAL; + break; + } + + return rst; +} + +SANE_Status +sane_get_parameters (SANE_Handle h, SANE_Parameters * p) +{ + SANE_Status rst = SANE_STATUS_INVAL; + TScanner *s = (TScanner *) h; + + DBG (DBG_FNC, "+ sane_get_parameters:"); + + if (s != NULL) + { + struct st_coords coords; + SANE_Int res, source, depth, colormode, frameformat, bpl; + + /* first do some checks */ + + /* colormode */ + colormode = Get_Colormode (s->aValues[opt_colormode].s); + + /* frameformat */ + frameformat = + (colormode == CM_COLOR) ? SANE_FRAME_RGB : SANE_FRAME_GRAY; + + /* depth */ + depth = (colormode == CM_LINEART) ? 1 : s->aValues[opt_depth].w; + + /* scan type */ + source = Get_Source (s->aValues[opt_scantype].s); + + /* resolution */ + res = s->aValues[opt_resolution].w; + + /* image coordinates in milimeters */ + coords.left = s->aValues[opt_tlx].w; + coords.top = s->aValues[opt_tly].w; + coords.width = s->aValues[opt_brx].w; + coords.height = s->aValues[opt_bry].w; + + /* validate coords */ + if (Translate_coords (&coords) == SANE_STATUS_GOOD) + { + Set_Coordinates (source, res, &coords); + + if (colormode != CM_LINEART) + { + bpl = coords.width * ((depth > 8) ? 2 : 1); + if (colormode == CM_COLOR) + bpl *= 3; /* three channels */ + } + else + bpl = (coords.width + 7) / 8; + + /* return the data */ + p->format = frameformat; + p->last_frame = SANE_TRUE; + p->depth = depth; + p->lines = coords.height; + p->pixels_per_line = coords.width; + p->bytes_per_line = bpl; + + DBG (DBG_FNC, " -> Depth : %i\n", depth); + DBG (DBG_FNC, " -> Height: %i\n", coords.height); + DBG (DBG_FNC, " -> Width : %i\n", coords.width); + DBG (DBG_FNC, " -> BPL : %i\n", bpl); + + rst = SANE_STATUS_GOOD; + } + } + + DBG (DBG_FNC, "- sane_get_parameters: %i\n", rst); + + return rst; +} + +SANE_Status +sane_start (SANE_Handle h) +{ + SANE_Status rst = SANE_STATUS_INVAL; + TScanner *s; + + DBG (DBG_FNC, "+ sane_start\n"); + + s = (TScanner *) h; + if (s != NULL) + { + struct st_coords coords; + SANE_Int res, source, colormode, depth, channel; + + /* first do some checks */ + /* Get Scan type */ + source = Get_Source (s->aValues[opt_scantype].s); + + /* Check if scanner supports slides and negatives in case selected source is tma */ + if (!((source != ST_NORMAL) && (RTS_isTmaAttached (device) == FALSE))) + { + /* Get depth */ + depth = s->aValues[opt_depth].w; + + /* Get color mode */ + colormode = Get_Colormode (s->aValues[opt_colormode].s); + + /* Emulating certain color modes */ + if (colormode == CM_LINEART) + { + /* emulate lineart */ + s->cnv.colormode = CM_LINEART; + colormode = CM_GRAY; + depth = 8; + } + else if ((colormode == CM_GRAY) + && (s->aValues[opt_emulategray].w == SANE_TRUE)) + { + /* emulate grayscale */ + s->cnv.colormode = CM_GRAY; + colormode = CM_COLOR; + } + else + s->cnv.colormode = -1; + + /* setting channel for colormodes different than CM_COLOR */ + channel = (colormode != CM_COLOR) ? 1 : 0; + + /* negative colors */ + s->cnv.negative = + (s->aValues[opt_negative].w == SANE_TRUE) ? TRUE : FALSE; + + /* Get threshold */ + s->cnv.threshold = s->aValues[opt_threshold].w; + + /* Get resolution */ + res = s->aValues[opt_resolution].w; + + /* set depth emulation */ + if (s->cnv.colormode == CM_LINEART) + s->cnv.real_depth = TRUE; + else + s->cnv.real_depth = + (s->aValues[opt_realdepth].w == SANE_TRUE) ? TRUE : FALSE; + + /* use gamma? */ + RTS_Debug->EnableGamma = + (s->aValues[opt_nogamma].w == SANE_TRUE) ? FALSE : TRUE; + + /* disable white shading correction? */ + RTS_Debug->wshading = + (s->aValues[opt_nowshading].w == SANE_TRUE) ? FALSE : TRUE; + + /* skip warmup process? */ + RTS_Debug->warmup = + (s->aValues[opt_nowarmup].w == SANE_TRUE) ? FALSE : TRUE; + + /* save debugging images? */ + RTS_Debug->SaveCalibFile = + (s->aValues[opt_dbgimages].w == SANE_TRUE) ? TRUE : FALSE; + + /* Get image coordinates in milimeters */ + coords.left = s->aValues[opt_tlx].w; + coords.top = s->aValues[opt_tly].w; + coords.width = s->aValues[opt_brx].w; + coords.height = s->aValues[opt_bry].w; + + /* Validate coords */ + if (Translate_coords (&coords) == SANE_STATUS_GOOD) + { + + /* Stop previusly started scan */ + RTS_Scanner_StopScan (device, TRUE); + + s->ScanParams.scantype = source; + s->ScanParams.colormode = colormode; + s->ScanParams.resolution_x = res; + s->ScanParams.resolution_y = res; + s->ScanParams.channel = channel; + + memcpy (&s->ScanParams.coords, &coords, + sizeof (struct st_coords)); + Set_Coordinates (source, res, &s->ScanParams.coords); + + /* emulating depth? */ + if ((s->cnv.real_depth == FALSE) && (depth < 16) + && (RTS_Debug->EnableGamma == TRUE)) + { + /* In order to improve image quality, we will scan at 16bits if + we are using gamma correction */ + s->cnv.depth = depth; + s->ScanParams.depth = 16; + } + else + { + s->ScanParams.depth = depth; + s->cnv.depth = -1; + } + + /* set scanning parameters */ + if (RTS_Scanner_SetParams (device, &s->ScanParams) == OK) + { + /* Start scanning process */ + if (RTS_Scanner_StartScan (device) == OK) + { + /* Allocate buffer to read one line */ + s->mylin = 0; + rst = img_buffers_alloc (s, bytesperline); + } + } + } + } + else + rst = SANE_STATUS_COVER_OPEN; + } + + DBG (DBG_FNC, "- sane_start: %i\n", rst); + + return rst; +} + +SANE_Status +sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * len) +{ + SANE_Status rst = SANE_STATUS_GOOD; + TScanner *s = (TScanner *) h; + + DBG (DBG_FNC, "+ sane_read\n"); + + if ((s != NULL) && (buf != NULL) && (len != NULL)) + { + /* nothing has been read at the moment */ + *len = 0; + + /* if we read all the lines return EOF */ + if ((s->mylin == s->ScanParams.coords.height) + || (device->status->cancel == TRUE)) + { + rst = + (device->status->cancel == + TRUE) ? SANE_STATUS_CANCELLED : SANE_STATUS_EOF; + + RTS_Scanner_StopScan (device, FALSE); + img_buffers_free (s); + } + else + { + SANE_Int emul_len, emul_maxlen; + SANE_Int thwidth, transferred, bufflength; + SANE_Byte *buffer, *pbuffer; + + emul_len = 0; + if (s->cnv.depth != -1) + emul_maxlen = maxlen * (s->ScanParams.depth / s->cnv.depth); + else + emul_maxlen = maxlen; + + /* if grayscale emulation is enabled check that retrieved data is multiple of three */ + if (s->cnv.colormode == CM_GRAY) + { + SANE_Int chn_size, rest; + + chn_size = (s->ScanParams.depth > 8) ? 2 : 1; + rest = emul_maxlen % (3 * chn_size); + + if (rest != 0) + emul_maxlen -= rest; + } + + /* this is important to keep lines alignment in lineart mode */ + if (s->cnv.colormode == CM_LINEART) + emul_maxlen = s->ScanParams.coords.width; + + /* if we are emulating depth, we scan at 16bit when frontend waits + for 8bit data. Next buffer will be used to retrieve data from + scanner prior to convert to 8 bits depth */ + buffer = (SANE_Byte *) malloc (emul_maxlen * sizeof (SANE_Byte)); + + if (buffer != NULL) + { + pbuffer = buffer; + + /* get bytes per line */ + if (s->ScanParams.colormode != CM_LINEART) + { + thwidth = + s->ScanParams.coords.width * + ((s->ScanParams.depth > 8) ? 2 : 1); + + if (s->ScanParams.colormode == CM_COLOR) + thwidth *= 3; /* three channels */ + } + else + thwidth = (s->ScanParams.coords.width + 7) / 8; + + /* read as many lines the buffer may contain and while there are lines to be read */ + while ((emul_len < emul_maxlen) + && (s->mylin < s->ScanParams.coords.height)) + { + /* Is there any data waiting for being passed ? */ + if (s->rest_amount != 0) + { + /* copy to buffer as many bytes as we can */ + bufflength = + min (emul_maxlen - emul_len, s->rest_amount); + memcpy (pbuffer, s->rest, bufflength); + emul_len += bufflength; + pbuffer += bufflength; + s->rest_amount -= bufflength; + if (s->rest_amount == 0) + s->mylin++; + } + else + { + /* read from scanner up to one line */ + if (Read_Image + (device, bytesperline, s->image, + &transferred) != OK) + { + /* error, exit function */ + rst = SANE_STATUS_EOF; + break; + } + + /* is there any data? */ + if (transferred != 0) + { + /* copy to buffer as many bytes as we can */ + bufflength = min (emul_maxlen - emul_len, thwidth); + + memcpy (pbuffer, s->image, bufflength); + emul_len += bufflength; + pbuffer += bufflength; + + /* the rest will be copied to s->rest buffer */ + if (bufflength < thwidth) + { + s->rest_amount = thwidth - bufflength; + memcpy (s->rest, s->image + bufflength, + s->rest_amount); + } + else + s->mylin++; + } + else + break; + } + } /* while */ + + /* process buffer before sending to frontend */ + if ((emul_len > 0) && (rst != SANE_STATUS_EOF)) + { + /* at this point ... + buffer : contains retrieved image + emul_len: contains size in bytes of retrieved image + + after this code ... + buf : will contain postprocessed image + len : will contain size in bytes of postprocessed image */ + + /* apply gamma if neccesary */ + if (RTS_Debug->EnableGamma == TRUE) + gamma_apply (s, buffer, emul_len, s->ScanParams.depth); + + /* if we are scanning negatives, let's invert colors */ + if (s->ScanParams.scantype == ST_NEG) + { + if (s->cnv.negative == FALSE) + Color_Negative (buffer, emul_len, + s->ScanParams.depth); + } + else if (s->cnv.negative != FALSE) + Color_Negative (buffer, emul_len, s->ScanParams.depth); + + /* emulating grayscale ? */ + if (s->cnv.colormode == CM_GRAY) + { + Color_to_Gray (buffer, emul_len, s->ScanParams.depth); + emul_len /= 3; + } + + /* emulating depth */ + if (s->cnv.depth != -1) + { + switch (s->cnv.depth) + { + /* case 1: treated separately as lineart */ + /*case 12: in the future */ + case 8: + Depth_16_to_8 (buffer, emul_len, buffer); + emul_len /= 2; + break; + } + } + + /* lineart mode ? */ + if (s->cnv.colormode == CM_LINEART) + { + /* I didn't see any scanner supporting lineart mode. + Windows drivers scan in grayscale and then convert image to lineart + so let's perform convertion */ + SANE_Int rest = emul_len % 8; + + Gray_to_Lineart (buffer, emul_len, s->cnv.threshold); + emul_len /= 8; + if (rest > 0) + emul_len++; + } + + /* copy postprocessed image */ + *len = emul_len; + memcpy (buf, buffer, *len); + } + + free (buffer); + } + } + } + else + rst = SANE_STATUS_EOF; + + DBG (DBG_FNC, "- sane_read: %s\n", sane_strstatus (rst)); + + return rst; +} + +void +sane_cancel (SANE_Handle h) +{ + DBG (DBG_FNC, "> sane_cancel\n"); + + /* silence gcc */ + h = h; + + device->status->cancel = TRUE; +} + +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + DBG (DBG_FNC, "> sane_set_io_mode\n"); + + /* silence gcc */ + handle = handle; + non_blocking = non_blocking; + + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + DBG (DBG_FNC, "> sane_get_select_fd\n"); + + /* silence gcc */ + handle = handle; + fd = fd; + + return SANE_STATUS_UNSUPPORTED; +} + +void +sane_close (SANE_Handle h) +{ + TScanner *scanner = (TScanner *) h; + + DBG (DBG_FNC, "- sane_close...\n"); + + /* stop previus scans */ + RTS_Scanner_StopScan (device, TRUE); + + /* close usb */ + sanei_usb_close (device->usb_handle); + + /* free scanner internal variables */ + RTS_Scanner_End (device); + + /* free RTS enviroment */ + RTS_Free (device); + + /* free backend variables */ + if (scanner != NULL) + { + options_free (scanner); + + img_buffers_free (scanner); + } +} + +void +sane_exit (void) +{ + /* free device list memory */ + if (_pSaneDevList) + { + TDevListEntry *pDev, *pNext; + + for (pDev = _pFirstSaneDev; pDev; pDev = pNext) + { + pNext = pDev->pNext; + /* pDev->dev.name is the same pointer that pDev->devname */ + free (pDev->devname); + free (pDev); + } + + _pFirstSaneDev = NULL; + free (_pSaneDevList); + _pSaneDevList = NULL; + } +} |