diff options
Diffstat (limited to 'backend/mustek_usb.c')
| -rw-r--r-- | backend/mustek_usb.c | 1610 |
1 files changed, 1610 insertions, 0 deletions
diff --git a/backend/mustek_usb.c b/backend/mustek_usb.c new file mode 100644 index 0000000..66b1813 --- /dev/null +++ b/backend/mustek_usb.c @@ -0,0 +1,1610 @@ +/* sane - Scanner Access Now Easy. + + Copyright (C) 2000 Mustek. + Originally maintained by Tom Wang <tom.wang@mustek.com.tw> + + Copyright (C) 2001 - 2004 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 Mustek 1200UB and similar + USB flatbed scanners. */ + +#define BUILD 18 + +#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 <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_usb + +#include "../include/sane/sanei_backend.h" +#include "../include/sane/sanei_config.h" +#include "../include/sane/sanei_usb.h" + +#include "mustek_usb.h" +#include "mustek_usb_high.c" + +#ifndef SANE_I18N +#define SANE_I18N(text) text +#endif + +static SANE_Int num_devices; +static Mustek_Usb_Device *first_dev; +static Mustek_Usb_Scanner *first_handle; +static const SANE_Device **devlist = 0; + +/* Maximum amount of data read in one turn from USB. */ +static SANE_Word max_block_size = (8 * 1024); + +/* Array of newly attached devices */ +static Mustek_Usb_Device **new_dev; + +/* Length of new_dev array */ +static SANE_Int new_dev_len; + +/* Number of entries alloced for new_dev */ +static SANE_Int new_dev_alloced; + +static SANE_String_Const mode_list[6]; + +static const SANE_Range char_range = { + -127, 127, 1 +}; + +static const SANE_Range u8_range = { + 0, /* minimum */ + 255, /* maximum */ + 0 /* quantization */ +}; + + +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_Usb_Scanner * s) +{ + SANE_String val; + SANE_Status status = SANE_STATUS_GOOD; + SANE_Int max_x, max_y; + + DBG (5, "calc_parameters: start\n"); + val = s->val[OPT_MODE].s; + + s->params.last_frame = SANE_TRUE; + + if (!strcmp (val, SANE_VALUE_SCAN_MODE_LINEART)) + { + s->params.format = SANE_FRAME_GRAY; + s->params.depth = 1; + s->bpp = 1; + s->channels = 1; + } + else if (!strcmp (val, SANE_VALUE_SCAN_MODE_GRAY)) + { + s->params.format = SANE_FRAME_GRAY; + s->params.depth = 8; + s->bpp = 8; + s->channels = 1; + } + else if (!strcmp (val, SANE_VALUE_SCAN_MODE_COLOR)) + { + s->params.format = SANE_FRAME_RGB; + s->params.depth = 8; + s->bpp = 24; + s->channels = 3; + } + else + { + DBG (1, "calc_parameters: invalid mode %s\n", (SANE_Char *) val); + status = SANE_STATUS_INVAL; + } + + s->tl_x = SANE_UNFIX (s->val[OPT_TL_X].w) / MM_PER_INCH; + s->tl_y = SANE_UNFIX (s->val[OPT_TL_Y].w) / MM_PER_INCH; + s->width = SANE_UNFIX (s->val[OPT_BR_X].w) / MM_PER_INCH - s->tl_x; + s->height = SANE_UNFIX (s->val[OPT_BR_Y].w) / MM_PER_INCH - s->tl_y; + + if (s->width < 0) + { + DBG (1, "calc_parameters: warning: tl_x > br_x\n"); + } + if (s->height < 0) + { + DBG (1, "calc_parameters: warning: tl_y > br_y\n"); + } + max_x = s->hw->max_width * SANE_UNFIX (s->val[OPT_RESOLUTION].w) / 300; + max_y = s->hw->max_height * SANE_UNFIX (s->val[OPT_RESOLUTION].w) / 300; + + s->tl_x_dots = s->tl_x * SANE_UNFIX (s->val[OPT_RESOLUTION].w); + s->width_dots = s->width * SANE_UNFIX (s->val[OPT_RESOLUTION].w); + s->tl_y_dots = s->tl_y * SANE_UNFIX (s->val[OPT_RESOLUTION].w); + s->height_dots = s->height * SANE_UNFIX (s->val[OPT_RESOLUTION].w); + + if (s->width_dots > max_x) + s->width_dots = max_x; + if (s->height_dots > max_y) + s->height_dots = max_y; + if (!strcmp (val, SANE_VALUE_SCAN_MODE_LINEART)) + { + s->width_dots = (s->width_dots / 8) * 8; + if (s->width_dots == 0) + s->width_dots = 8; + } + if (s->tl_x_dots < 0) + s->tl_x_dots = 0; + if (s->tl_y_dots < 0) + s->tl_y_dots = 0; + if (s->tl_x_dots + s->width_dots > max_x) + s->tl_x_dots = max_x - s->width_dots; + if (s->tl_y_dots + s->height_dots > max_y) + s->tl_y_dots = max_y - s->height_dots; + + s->val[OPT_TL_X].w = SANE_FIX (s->tl_x * MM_PER_INCH); + s->val[OPT_TL_Y].w = SANE_FIX (s->tl_y * MM_PER_INCH); + s->val[OPT_BR_X].w = SANE_FIX ((s->tl_x + s->width) * MM_PER_INCH); + s->val[OPT_BR_Y].w = SANE_FIX ((s->tl_y + s->height) * MM_PER_INCH); + + s->params.pixels_per_line = s->width_dots; + if (s->params.pixels_per_line < 0) + s->params.pixels_per_line = 0; + s->params.lines = s->height_dots; + if (s->params.lines < 0) + s->params.lines = 0; + s->params.bytes_per_line = s->params.pixels_per_line * s->params.depth / 8 + * s->channels; + + DBG (4, "calc_parameters: format=%d\n", s->params.format); + DBG (4, "calc_parameters: last frame=%d\n", s->params.last_frame); + DBG (4, "calc_parameters: lines=%d\n", s->params.lines); + DBG (4, "calc_parameters: pixels per line=%d\n", s->params.pixels_per_line); + DBG (4, "calc_parameters: bytes per line=%d\n", s->params.bytes_per_line); + DBG (4, "calc_parameters: Pixels %dx%dx%d\n", + s->params.pixels_per_line, s->params.lines, 1 << s->params.depth); + + DBG (5, "calc_parameters: exit\n"); + return status; +} + + +static SANE_Status +init_options (Mustek_Usb_Scanner * s) +{ + SANE_Int option; + SANE_Status status; + + DBG (5, "init_options: start\n"); + + memset (s->opt, 0, sizeof (s->opt)); + memset (s->val, 0, sizeof (s->val)); + + for (option = 0; option < NUM_OPTIONS; ++option) + { + s->opt[option].size = sizeof (SANE_Word); + s->opt[option].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; + s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + s->val[OPT_NUM_OPTS].w = NUM_OPTIONS; + + /* "Mode" group: */ + s->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); + s->opt[OPT_MODE_GROUP].desc = ""; + s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + s->opt[OPT_MODE_GROUP].size = 0; + s->opt[OPT_MODE_GROUP].cap = 0; + s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* scan mode */ + mode_list[0] = SANE_VALUE_SCAN_MODE_COLOR; + mode_list[1] = SANE_VALUE_SCAN_MODE_GRAY; + mode_list[2] = SANE_VALUE_SCAN_MODE_LINEART; + mode_list[3] = NULL; + + 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 (mode_list[1]); + + /* resolution */ + 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_FIXED; + s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_RESOLUTION].constraint.range = &s->hw->dpi_range; + s->val[OPT_RESOLUTION].w = s->hw->dpi_range.min; + if (s->hw->chip->scanner_type == MT_600CU) + s->hw->dpi_range.max = SANE_FIX (600); + else + s->hw->dpi_range.max = SANE_FIX (1200); + + /* 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; + + /* "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; + + /* 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 = &s->hw->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 = &s->hw->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 = &s->hw->x_range; + s->val[OPT_BR_X].w = s->hw->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 = &s->hw->y_range; + s->val[OPT_BR_Y].w = s->hw->y_range.max; + + /* "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 = 128; + + /* custom-gamma table */ + s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA; + s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA; + s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA; + s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL; + s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE; + + /* gray gamma vector */ + s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR; + s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR; + s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR; + s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT; + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE; + s->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word); + s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range; + s->val[OPT_GAMMA_VECTOR].wa = &s->gray_gamma_table[0]; + + /* red gamma vector */ + s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; + s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; + s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; + s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE; + s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word); + s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range; + s->val[OPT_GAMMA_VECTOR_R].wa = &s->red_gamma_table[0]; + + /* green gamma vector */ + s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; + s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; + s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; + s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE; + s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word); + s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range; + s->val[OPT_GAMMA_VECTOR_G].wa = &s->green_gamma_table[0]; + + /* blue gamma vector */ + s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; + s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; + s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; + s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE; + s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word); + s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range; + s->val[OPT_GAMMA_VECTOR_B].wa = &s->blue_gamma_table[0]; + + RIE (calc_parameters (s)); + + DBG (5, "init_options: exit\n"); + return SANE_STATUS_GOOD; +} + + +static SANE_Status +attach (SANE_String_Const devname, Mustek_Usb_Device ** devp, + SANE_Bool may_wait) +{ + Mustek_Usb_Device *dev; + SANE_Status status; + Mustek_Type scanner_type; + SANE_Int fd; + + DBG (5, "attach: start: devp %s NULL, may_wait = %d\n", devp ? "!=" : "==", + may_wait); + if (!devname) + { + DBG (1, "attach: devname == NULL\n"); + return SANE_STATUS_INVAL; + } + + for (dev = first_dev; dev; dev = dev->next) + if (strcmp (dev->sane.name, devname) == 0) + { + if (devp) + *devp = dev; + DBG (4, "attach: device `%s' was already in device list\n", devname); + return SANE_STATUS_GOOD; + } + + DBG (4, "attach: trying to open device `%s'\n", devname); + status = sanei_usb_open (devname, &fd); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "attach: couldn't open device `%s': %s\n", devname, + sane_strstatus (status)); + return status; + } + DBG (4, "attach: device `%s' successfully opened\n", devname); + + /* try to identify model */ + DBG (4, "attach: trying to identify device `%s'\n", devname); + status = usb_low_identify_scanner (fd, &scanner_type); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "attach: device `%s' doesn't look like a supported scanner\n", + devname); + sanei_usb_close (fd); + return status; + } + sanei_usb_close (fd); + if (scanner_type == MT_UNKNOWN) + { + DBG (3, "attach: warning: couldn't identify device `%s', must set " + "type manually\n", devname); + } + + dev = malloc (sizeof (Mustek_Usb_Device)); + if (!dev) + { + DBG (1, "attach: couldn't malloc Mustek_Usb_Device\n"); + return SANE_STATUS_NO_MEM; + } + + memset (dev, 0, sizeof (*dev)); + dev->name = strdup (devname); + dev->sane.name = (SANE_String_Const) dev->name; + dev->sane.vendor = "Mustek"; + switch (scanner_type) + { + case MT_1200CU: + dev->sane.model = "1200 CU"; + break; + case MT_1200CU_PLUS: + dev->sane.model = "1200 CU Plus"; + break; + case MT_1200USB: + dev->sane.model = "1200 USB (unsupported)"; + break; + case MT_1200UB: + dev->sane.model = "1200 UB"; + break; + case MT_600CU: + dev->sane.model = "600 CU"; + break; + case MT_600USB: + dev->sane.model = "600 USB (unsupported)"; + break; + default: + dev->sane.model = "(unidentified)"; + break; + } + dev->sane.type = "flatbed scanner"; + + dev->x_range.min = 0; + dev->x_range.max = SANE_FIX (8.4 * MM_PER_INCH); + dev->x_range.quant = 0; + + dev->y_range.min = 0; + dev->y_range.max = SANE_FIX (11.7 * MM_PER_INCH); + dev->y_range.quant = 0; + + dev->max_height = 11.7 * 300; + dev->max_width = 8.4 * 300; + dev->dpi_range.min = SANE_FIX (50); + dev->dpi_range.max = SANE_FIX (600); + dev->dpi_range.quant = SANE_FIX (1); + + status = usb_high_scan_init (dev); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "attach: usb_high_scan_init returned status: %s\n", + sane_strstatus (status)); + free (dev); + return status; + } + dev->chip->scanner_type = scanner_type; + dev->chip->max_block_size = max_block_size; + + DBG (2, "attach: found %s %s %s at %s\n", dev->sane.vendor, dev->sane.type, + dev->sane.model, dev->sane.name); + ++num_devices; + dev->next = first_dev; + first_dev = dev; + + if (devp) + *devp = dev; + + DBG (5, "attach: exit\n"); + return SANE_STATUS_GOOD; +} + +static SANE_Status +attach_one_device (SANE_String_Const devname) +{ + Mustek_Usb_Device *dev; + SANE_Status status; + + RIE (attach (devname, &dev, SANE_FALSE)); + + if (dev) + { + /* Keep track of newly attached devices so we can set options as + necessary. */ + if (new_dev_len >= new_dev_alloced) + { + new_dev_alloced += 4; + if (new_dev) + new_dev = + realloc (new_dev, new_dev_alloced * sizeof (new_dev[0])); + else + new_dev = malloc (new_dev_alloced * sizeof (new_dev[0])); + if (!new_dev) + { + DBG (1, "attach_one_device: out of memory\n"); + return SANE_STATUS_NO_MEM; + } + } + new_dev[new_dev_len++] = dev; + } + return SANE_STATUS_GOOD; +} + +static SANE_Status +fit_lines (Mustek_Usb_Scanner * s, SANE_Byte * src, SANE_Byte * dst, + SANE_Word src_lines, SANE_Word * dst_lines) +{ + SANE_Int threshold; + SANE_Word src_width, dst_width; + SANE_Word dst_pixel, src_pixel; + SANE_Word dst_line, src_line; + SANE_Word pixel_switch; + SANE_Word src_address, dst_address; + src_width = s->hw->width; + dst_width = s->width_dots; + + threshold = s->val[OPT_THRESHOLD].w; + + DBG (5, "fit_lines: dst_width=%d, src_width=%d, src_lines=%d, " + "offset=%d\n", dst_width, src_width, src_lines, s->hw->line_offset); + + dst_line = 0; + src_line = s->hw->line_offset; + + while (src_line < src_lines) + { + DBG (5, "fit_lines: getting line: dst_line=%d, src_line=%d, " + "line_switch=%d\n", dst_line, src_line, s->hw->line_switch); + + src_pixel = 0; + pixel_switch = src_width; + for (dst_pixel = 0; dst_pixel < dst_width; dst_pixel++) + { + while (pixel_switch > dst_width) + { + src_pixel++; + pixel_switch -= dst_width; + } + pixel_switch += src_width; + + src_address = src_pixel * s->hw->bpp / 8 + + src_width * src_line * s->hw->bpp / 8; + dst_address = dst_pixel * s->bpp / 8 + + dst_width * dst_line * s->bpp / 8; + + if (s->bpp == 8) + { + dst[dst_address] = s->gray_table[src[src_address]]; + } + else if (s->bpp == 24) + { + dst[dst_address] + = s->red_table[s->gray_table[src[src_address]]]; + dst[dst_address + 1] + = s->green_table[s->gray_table[src[src_address + 1]]]; + dst[dst_address + 2] + = s->blue_table[s->gray_table[src[src_address + 2]]]; + } + else /* lineart */ + { + if ((dst_pixel % 8) == 0) + dst[dst_address] = 0; + dst[dst_address] |= + (((src[src_address] > threshold) ? 0 : 1) + << (7 - (dst_pixel % 8))); + } + } + + dst_line++; + while (s->hw->line_switch >= s->height_dots) + { + src_line++; + s->hw->line_switch -= s->height_dots; + } + s->hw->line_switch += s->hw->height; + } + + *dst_lines = dst_line; + s->hw->line_offset = (src_line - src_lines); + + DBG (4, "fit_lines: exit, src_line=%d, *dst_lines=%d, offset=%d\n", + src_line, *dst_lines, s->hw->line_offset); + return SANE_STATUS_GOOD; +} + +static SANE_Status +check_gamma_table (SANE_Word * table) +{ + SANE_Word entry, value; + SANE_Status status = SANE_STATUS_GOOD; + + for (entry = 0; entry < 256; entry++) + { + value = table[entry]; + if (value > 255) + { + DBG (1, "check_gamma_table: warning: entry %d > 255 (%d) - fixed\n", + entry, value); + table[entry] = 255; + status = SANE_STATUS_INVAL; + } + } + + return status; +} + +/* -------------------------- SANE API functions ------------------------- */ + +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ + SANE_Char line[PATH_MAX]; + SANE_Char *word, *end; + SANE_String_Const cp; + SANE_Int linenumber; + FILE *fp; + + DBG_INIT (); + DBG (2, "SANE Mustek USB backend version %d.%d build %d from %s\n", SANE_CURRENT_MAJOR, + V_MINOR, BUILD, PACKAGE_STRING); + + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); + + DBG (5, "sane_init: authorize %s null\n", authorize ? "!=" : "=="); + + + num_devices = 0; + first_dev = 0; + first_handle = 0; + devlist = 0; + new_dev = 0; + new_dev_len = 0; + new_dev_alloced = 0; + + sanei_usb_init (); + + fp = sanei_config_open (MUSTEK_USB_CONFIG_FILE); + if (!fp) + { + /* default to /dev/usb/scanner instead of insisting on config file */ + DBG (3, "sane_init: couldn't open config file `%s': %s. Using " + "/dev/usb/scanner directly\n", MUSTEK_USB_CONFIG_FILE, + strerror (errno)); + attach ("/dev/usb/scanner", 0, SANE_FALSE); + return SANE_STATUS_GOOD; + } + linenumber = 0; + DBG (4, "sane_init: reading config file `%s'\n", MUSTEK_USB_CONFIG_FILE); + + while (sanei_config_read (line, sizeof (line), fp)) + { + word = 0; + linenumber++; + + cp = sanei_config_get_string (line, &word); + if (!word || cp == line) + { + DBG (5, "sane_init: config file line %d: ignoring empty line\n", + linenumber); + if (word) + free (word); + continue; + } + if (word[0] == '#') + { + DBG (5, "sane_init: config file line %d: ignoring comment line\n", + linenumber); + free (word); + continue; + } + + if (strcmp (word, "option") == 0) + { + free (word); + word = 0; + cp = sanei_config_get_string (cp, &word); + + if (!word) + { + DBG (1, "sane_init: config file line %d: missing quotation mark?\n", + linenumber); + continue; + } + + if (strcmp (word, "max_block_size") == 0) + { + free (word); + word = 0; + cp = sanei_config_get_string (cp, &word); + if (!word) + { + DBG (1, "sane_init: config file line %d: missing quotation mark?\n", + linenumber); + continue; + } + + errno = 0; + max_block_size = strtol (word, &end, 0); + if (end == word) + { + DBG (3, "sane-init: config file line %d: max_block_size " + "must have a parameter; using 8192 bytes\n", + linenumber); + max_block_size = 8192; + } + if (errno) + { + DBG (3, + "sane-init: config file line %d: max_block_size `%s' " + "is invalid (%s); using 8192 bytes\n", linenumber, + word, strerror (errno)); + max_block_size = 8192; + } + else + { + DBG (3, + "sane_init: config file line %d: max_block_size set " + "to %d bytes\n", linenumber, max_block_size); + } + if (word) + free (word); + word = 0; + } + else if (strcmp (word, "1200ub") == 0) + { + if (new_dev_len > 0) + { + /* this is a 1200 UB */ + new_dev[new_dev_len - 1]->chip->scanner_type = MT_1200UB; + new_dev[new_dev_len - 1]->sane.model = "1200 UB"; + DBG (3, "sane_init: config file line %d: `%s' is a Mustek " + "1200 UB\n", linenumber, + new_dev[new_dev_len - 1]->sane.name); + } + else + { + DBG (3, "sane_init: config file line %d: option " + "1200ub ignored, was set before any device " + "name\n", linenumber); + } + if (word) + free (word); + word = 0; + } + else if (strcmp (word, "1200cu") == 0) + { + if (new_dev_len > 0) + { + /* this is a 1200 CU */ + new_dev[new_dev_len - 1]->chip->scanner_type = MT_1200CU; + new_dev[new_dev_len - 1]->sane.model = "1200 CU"; + DBG (3, "sane_init: config file line %d: `%s' is a Mustek " + "1200 CU\n", linenumber, + new_dev[new_dev_len - 1]->sane.name); + } + else + { + DBG (3, "sane_init: config file line %d: option " + "1200cu ignored, was set before any device " + "name\n", linenumber); + } + if (word) + free (word); + word = 0; + } + else if (strcmp (word, "1200cu_plus") == 0) + { + if (new_dev_len > 0) + { + /* this is a 1200 CU Plus */ + new_dev[new_dev_len - 1]->chip->scanner_type + = MT_1200CU_PLUS; + new_dev[new_dev_len - 1]->sane.model = "1200 CU Plus"; + DBG (3, "sane_init: config file line %d: `%s' is a Mustek " + "1200 CU Plus\n", linenumber, + new_dev[new_dev_len - 1]->sane.name); + } + else + { + DBG (3, "sane_init: config file line %d: option " + "1200cu_plus ignored, was set before any device " + "name\n", linenumber); + } + if (word) + free (word); + word = 0; + } + else if (strcmp (word, "600cu") == 0) + { + if (new_dev_len > 0) + { + /* this is a 600 CU */ + new_dev[new_dev_len - 1]->chip->scanner_type = MT_600CU; + new_dev[new_dev_len - 1]->sane.model = "600 CU"; + DBG (3, "sane_init: config file line %d: `%s' is a Mustek " + "600 CU\n", linenumber, + new_dev[new_dev_len - 1]->sane.name); + } + else + { + DBG (3, "sane_init: config file line %d: option " + "600cu ignored, was set before any device " + "name\n", linenumber); + } + if (word) + free (word); + word = 0; + } + else + { + DBG (3, "sane_init: config file line %d: option " + "%s is unknown\n", linenumber, word); + if (word) + free (word); + word = 0; + } + } + else + { + new_dev_len = 0; + DBG (4, "sane_init: config file line %d: trying to attach `%s'\n", + linenumber, line); + sanei_usb_attach_matching_devices (line, attach_one_device); + if (word) + free (word); + word = 0; + } + } + + if (new_dev_alloced > 0) + { + new_dev_len = new_dev_alloced = 0; + free (new_dev); + } + + fclose (fp); + DBG (5, "sane_init: exit\n"); + + return SANE_STATUS_GOOD; +} + +void +sane_exit (void) +{ + Mustek_Usb_Device *dev, *next; + SANE_Status status; + + DBG (5, "sane_exit: start\n"); + for (dev = first_dev; dev; dev = next) + { + next = dev->next; + if (dev->is_prepared) + { + status = usb_high_scan_clearup (dev); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_close: usb_high_scan_clearup returned %s\n", + sane_strstatus (status)); + } + status = usb_high_scan_exit (dev); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_close: usb_high_scan_exit returned %s\n", + sane_strstatus (status)); + if (dev->chip) + { + status = usb_high_scan_exit (dev); + if (status != SANE_STATUS_GOOD) + DBG (3, + "sane_exit: while closing %s, usb_high_scan_exit returned: " + "%s\n", dev->name, sane_strstatus (status)); + } + free ((void *) dev->name); + free (dev); + } + first_dev = 0; + if (devlist) + free (devlist); + devlist = 0; + + DBG (5, "sane_exit: exit\n"); +} + +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) +{ + Mustek_Usb_Device *dev; + SANE_Int dev_num; + + DBG (5, "sane_get_devices: start: local_only = %s\n", + local_only == SANE_TRUE ? "true" : "false"); + + if (devlist) + free (devlist); + + devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); + if (!devlist) + return SANE_STATUS_NO_MEM; + + dev_num = 0; + for (dev = first_dev; dev_num < num_devices; dev = dev->next) + devlist[dev_num++] = &dev->sane; + devlist[dev_num++] = 0; + + *device_list = devlist; + + DBG (5, "sane_get_devices: exit\n"); + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_open (SANE_String_Const devicename, SANE_Handle * handle) +{ + Mustek_Usb_Device *dev; + SANE_Status status; + Mustek_Usb_Scanner *s; + SANE_Int value; + + DBG (5, "sane_open: start (devicename = `%s')\n", devicename); + + if (devicename[0]) + { + for (dev = first_dev; dev; dev = dev->next) + if (strcmp (dev->sane.name, devicename) == 0) + break; + + if (!dev) + { + DBG (5, + "sane_open: couldn't find `%s' in devlist, trying attach)\n", + devicename); + RIE (attach (devicename, &dev, SANE_TRUE)); + } + else + DBG (5, "sane_open: found `%s' in devlist\n", dev->name); + } + else + { + /* empty devicname -> use first device */ + dev = first_dev; + if (dev) + DBG (5, "sane_open: empty devicename, trying `%s'\n", dev->name); + } + + if (!dev) + return SANE_STATUS_INVAL; + + if (dev->chip->scanner_type == MT_UNKNOWN) + { + DBG (0, "sane_open: the type of your scanner is unknown, edit " + "mustek_usb.conf before using the scanner\n"); + return SANE_STATUS_INVAL; + } + s = malloc (sizeof (*s)); + if (!s) + return SANE_STATUS_NO_MEM; + memset (s, 0, sizeof (*s)); + s->hw = dev; + + RIE (init_options (s)); + + /* insert newly opened handle into list of open handles: */ + s->next = first_handle; + first_handle = s; + + *handle = s; + strcpy (s->hw->device_name, dev->name); + + RIE (usb_high_scan_turn_power (s->hw, SANE_TRUE)); + RIE (usb_high_scan_back_home (s->hw)); + + s->hw->scan_buffer = (SANE_Byte *) malloc (SCAN_BUFFER_SIZE * 2); + if (!s->hw->scan_buffer) + { + DBG (5, "sane_open: couldn't malloc s->hw->scan_buffer (%d bytes)\n", + SCAN_BUFFER_SIZE * 2); + return SANE_STATUS_NO_MEM; + } + s->hw->scan_buffer_len = 0; + s->hw->scan_buffer_start = s->hw->scan_buffer; + + s->hw->temp_buffer = (SANE_Byte *) malloc (SCAN_BUFFER_SIZE); + if (!s->hw->temp_buffer) + { + DBG (5, "sane_open: couldn't malloc s->hw->temp_buffer (%d bytes)\n", + SCAN_BUFFER_SIZE); + return SANE_STATUS_NO_MEM; + } + s->hw->temp_buffer_len = 0; + s->hw->temp_buffer_start = s->hw->temp_buffer; + + for (value = 0; value < 256; value++) + { + s->linear_gamma_table[value] = value; + s->red_gamma_table[value] = value; + s->green_gamma_table[value] = value; + s->blue_gamma_table[value] = value; + s->gray_gamma_table[value] = value; + } + + s->red_table = s->linear_gamma_table; + s->green_table = s->linear_gamma_table; + s->blue_table = s->linear_gamma_table; + s->gray_table = s->linear_gamma_table; + + DBG (5, "sane_open: exit\n"); + + return SANE_STATUS_GOOD; +} + +void +sane_close (SANE_Handle handle) +{ + Mustek_Usb_Scanner *prev, *s; + SANE_Status status; + + DBG (5, "sane_close: start\n"); + + /* remove handle from list of open handles: */ + prev = 0; + for (s = first_handle; s; s = s->next) + { + if (s == handle) + break; + prev = s; + } + if (!s) + { + DBG (5, "close: invalid handle %p\n", handle); + return; /* oops, not a handle we know about */ + } + + if (prev) + prev->next = s->next; + else + first_handle = s->next; + + if (s->hw->is_open) + { + status = usb_high_scan_turn_power (s->hw, SANE_FALSE); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_close: usb_high_scan_turn_power returned %s\n", + sane_strstatus (status)); + } +#if 0 + if (s->hw->is_prepared) + { + status = usb_high_scan_clearup (s->hw); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_close: usb_high_scan_clearup returned %s\n", + sane_strstatus (status)); + } + status = usb_high_scan_exit (s->hw); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_close: usb_high_scan_exit returned %s\n", + sane_strstatus (status)); +#endif + if (s->hw->scan_buffer) + { + free (s->hw->scan_buffer); + s->hw->scan_buffer = 0; + } + if (s->hw->temp_buffer) + { + free (s->hw->temp_buffer); + s->hw->temp_buffer = 0; + } + + free (handle); + + DBG (5, "sane_close: exit\n"); +} + +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + Mustek_Usb_Scanner *s = handle; + + if ((unsigned) option >= NUM_OPTIONS) + return 0; + DBG (5, "sane_get_option_descriptor: option = %s (%d)\n", + s->opt[option].name, option); + return s->opt + option; +} + +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *val, SANE_Int * info) +{ + Mustek_Usb_Scanner *s = handle; + SANE_Status status; + SANE_Word cap; + SANE_Int myinfo = 0; + + DBG (5, "sane_control_option: start: action = %s, option = %s (%d)\n", + (action == SANE_ACTION_GET_VALUE) ? "get" : + (action == SANE_ACTION_SET_VALUE) ? "set" : + (action == SANE_ACTION_SET_AUTO) ? "set_auto" : "unknown", + s->opt[option].name, option); + + if (info) + *info = 0; + + if (s->scanning) + { + DBG (1, "sane_control_option: don't call this function while " + "scanning\n"); + return SANE_STATUS_DEVICE_BUSY; + } + + if (option >= NUM_OPTIONS || option < 0) + { + DBG (1, "sane_control_option: option %d >= NUM_OPTIONS || option < 0\n", + option); + return SANE_STATUS_INVAL; + } + + cap = s->opt[option].cap; + + if (!SANE_OPTION_IS_ACTIVE (cap)) + { + DBG (2, "sane_control_option: option %d is inactive\n", option); + return SANE_STATUS_INVAL; + } + + if (action == SANE_ACTION_GET_VALUE) + { + switch (option) + { + /* word options: */ + case OPT_NUM_OPTS: + case OPT_RESOLUTION: + case OPT_PREVIEW: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + case OPT_THRESHOLD: + case OPT_CUSTOM_GAMMA: + *(SANE_Word *) val = s->val[option].w; + break; + /* word-array options: */ + case OPT_GAMMA_VECTOR: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + memcpy (val, s->val[option].wa, s->opt[option].size); + break; + /* string options: */ + case OPT_MODE: + strcpy (val, s->val[option].s); + break; + default: + DBG (2, "sane_control_option: can't get unknown option %d\n", + option); + } + } + else if (action == SANE_ACTION_SET_VALUE) + { + if (!SANE_OPTION_IS_SETTABLE (cap)) + { + DBG (2, "sane_control_option: option %d is not settable\n", option); + return SANE_STATUS_INVAL; + } + + status = sanei_constrain_value (s->opt + option, val, &myinfo); + + if (status != SANE_STATUS_GOOD) + { + DBG (2, "sane_control_option: sanei_constrain_value returned %s\n", + sane_strstatus (status)); + return status; + } + + switch (option) + { + /* (mostly) side-effect-free word options: */ + case OPT_RESOLUTION: + 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: + s->val[option].w = *(SANE_Word *) val; + break; + /* Boolean */ + case OPT_PREVIEW: + s->val[option].w = *(SANE_Bool *) val; + break; + /* side-effect-free word-array options: */ + case OPT_GAMMA_VECTOR: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + memcpy (s->val[option].wa, val, s->opt[option].size); + check_gamma_table (s->val[option].wa); + break; + case OPT_CUSTOM_GAMMA: + s->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val; + myinfo |= SANE_INFO_RELOAD_OPTIONS; + if (s->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE) + { + s->red_table = s->red_gamma_table; + s->green_table = s->green_gamma_table; + s->blue_table = s->blue_gamma_table; + s->gray_table = s->gray_gamma_table; + if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) == 0) + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + else if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) + { + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + else + { + s->red_table = s->linear_gamma_table; + s->green_table = s->linear_gamma_table; + s->blue_table = s->linear_gamma_table; + s->gray_table = s->linear_gamma_table; + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } + break; + case OPT_MODE: + if (s->val[option].s) + free (s->val[option].s); + s->val[option].s = strdup (val); + + RIE (calc_parameters (s)); + + s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + + if (strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) == 0) + { + s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + } + else + { + s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; + if (s->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE) + { + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + myinfo |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + break; + default: + DBG (2, "sane_control_option: can't set unknown option %d\n", + option); + } + } + else + { + DBG (2, "sane_control_option: unknown action %d for option %d\n", + action, option); + return SANE_STATUS_INVAL; + } + if (info) + *info = myinfo; + + DBG (5, "sane_control_option: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + Mustek_Usb_Scanner *s = handle; + SANE_Status status; + + DBG (5, "sane_get_parameters: start\n"); + + RIE (calc_parameters (s)); + if (params) + *params = s->params; + + DBG (5, "sane_get_parameters: exit\n"); + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_start (SANE_Handle handle) +{ + Mustek_Usb_Scanner *s = handle; + SANE_Status status; + SANE_String val; + Colormode color_mode; + SANE_Word dpi, x, y, width, height; + + DBG (5, "sane_start: start\n"); + + /* First make sure we have a current parameter set. Some of the + parameters will be overwritten below, but that's OK. */ + + s->total_bytes = 0; + s->total_lines = 0; + RIE (calc_parameters (s)); + + if (s->width_dots <= 0) + { + DBG (0, "sane_start: top left x > bottom right x --- exiting\n"); + return SANE_STATUS_INVAL; + } + if (s->height_dots <= 0) + { + DBG (0, "sane_start: top left y > bottom right y --- exiting\n"); + return SANE_STATUS_INVAL; + } + + + val = s->val[OPT_MODE].s; + if (!strcmp (val, SANE_VALUE_SCAN_MODE_LINEART)) + color_mode = GRAY8; + else if (!strcmp (val, SANE_VALUE_SCAN_MODE_GRAY)) + color_mode = GRAY8; + else /* Color */ + color_mode = RGB24; + + dpi = SANE_UNFIX (s->val[OPT_RESOLUTION].w); + x = s->tl_x_dots; + y = s->tl_y_dots; + width = s->width_dots; + height = s->height_dots; + + if (!s->hw->is_prepared) + { + RIE (usb_high_scan_prepare (s->hw)); + RIE (usb_high_scan_reset (s->hw)); + } + RIE (usb_high_scan_set_threshold (s->hw, 128)); + RIE (usb_high_scan_embed_gamma (s->hw, NULL)); + RIE (usb_high_scan_suggest_parameters (s->hw, dpi, x, y, width, height, + color_mode)); + RIE (usb_high_scan_setup_scan (s->hw, s->hw->scan_mode, s->hw->x_dpi, + s->hw->y_dpi, 0, s->hw->x, s->hw->y, + s->hw->width)); + + DBG (3, "sane_start: wanted: dpi=%d, x=%d, y=%d, width=%d, height=%d, " + "scan_mode=%d\n", dpi, x, y, width, height, color_mode); + DBG (3, "sane_start: got: x_dpi=%d, y_dpi=%d, x=%d, y=%d, width=%d, " + "height=%d, scan_mode=%d\n", s->hw->x_dpi, s->hw->y_dpi, s->hw->x, + s->hw->y, s->hw->width, s->hw->height, s->hw->scan_mode); + + s->scanning = SANE_TRUE; + s->read_rows = s->hw->height; + s->hw->line_switch = s->hw->height; + s->hw->line_offset = 0; + s->hw->scan_buffer_len = 0; + + DBG (5, "sane_start: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, + SANE_Int * len) +{ + Mustek_Usb_Scanner *s = handle; + SANE_Word lines_to_read, lines_read; + SANE_Status status; + + DBG (5, "sane_read: start\n"); + + if (!s) + { + DBG (1, "sane_read: handle is null!\n"); + return SANE_STATUS_INVAL; + } + + if (!buf) + { + DBG (1, "sane_read: buf is null!\n"); + return SANE_STATUS_INVAL; + } + + if (!len) + { + DBG (1, "sane_read: len is null!\n"); + return SANE_STATUS_INVAL; + } + + *len = 0; + + if (!s->scanning) + { + DBG (3, "sane_read: scan was cancelled, is over or has not been " + "initiated yet\n"); + return SANE_STATUS_CANCELLED; + } + + if (s->hw->scan_buffer_len == 0) + { + if (s->read_rows > 0) + { + lines_to_read = SCAN_BUFFER_SIZE / (s->hw->width * s->hw->bpp / 8); + if (lines_to_read > s->read_rows) + lines_to_read = s->read_rows; + s->hw->temp_buffer_start = s->hw->temp_buffer; + s->hw->temp_buffer_len = (s->hw->width * s->hw->bpp / 8) + * lines_to_read; + DBG (4, "sane_read: reading %d source lines\n", lines_to_read); + RIE (usb_high_scan_get_rows (s->hw, s->hw->temp_buffer, + lines_to_read, SANE_FALSE)); + RIE (fit_lines (s, s->hw->temp_buffer, s->hw->scan_buffer, + lines_to_read, &lines_read)); + s->read_rows -= lines_to_read; + if ((s->total_lines + lines_read) > s->height_dots) + lines_read = s->height_dots - s->total_lines; + s->total_lines += lines_read; + DBG (4, "sane_read: %d destination lines, %d total\n", + lines_read, s->total_lines); + s->hw->scan_buffer_start = s->hw->scan_buffer; + s->hw->scan_buffer_len = (s->width_dots * s->bpp / 8) * lines_read; + } + else + { + DBG (4, "sane_read: scan finished -- exit\n"); + return SANE_STATUS_EOF; + } + } + if (s->hw->scan_buffer_len == 0) + { + DBG (4, "sane_read: scan finished -- exit\n"); + return SANE_STATUS_EOF; + } + + *len = MIN (max_len, (SANE_Int) s->hw->scan_buffer_len); + memcpy (buf, s->hw->scan_buffer_start, *len); + DBG (4, "sane_read: exit, read %d bytes from scan_buffer; " + "%ld bytes remaining\n", *len, + (long int) (s->hw->scan_buffer_len - *len)); + s->hw->scan_buffer_len -= (*len); + s->hw->scan_buffer_start += (*len); + s->total_bytes += (*len); + return SANE_STATUS_GOOD; +} + +void +sane_cancel (SANE_Handle handle) +{ + Mustek_Usb_Scanner *s = handle; + SANE_Status status; + + DBG (5, "sane_cancel: start\n"); + + status = usb_high_scan_stop_scan (s->hw); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_cancel: usb_high_scan_stop_scan returned `%s' for `%s'\n", + sane_strstatus (status), s->hw->name); + usb_high_scan_back_home (s->hw); + if (status != SANE_STATUS_GOOD) + DBG (3, "sane_cancel: usb_high_scan_back_home returned `%s' for `%s'\n", + sane_strstatus (status), s->hw->name); + + if (s->scanning) + { + s->scanning = SANE_FALSE; + if (s->total_bytes != (s->params.bytes_per_line * s->params.lines)) + DBG (1, "sane_cancel: warning: scanned %d bytes, expected %d " + "bytes\n", s->total_bytes, + s->params.bytes_per_line * s->params.lines); + else + DBG (3, "sane_cancel: scan finished, scanned %d bytes\n", + s->total_bytes); + } + else + { + DBG (4, "sane_cancel: scan has not been initiated yet, " + "or it is allready aborted\n"); + } + DBG (5, "sane_cancel: exit\n"); + return; +} + +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + Mustek_Usb_Scanner *s = handle; + + DBG (5, "sane_set_io_mode: handle = %p, non_blocking = %s\n", + handle, non_blocking == SANE_TRUE ? "true" : "false"); + if (!s->scanning) + { + DBG (1, "sane_set_io_mode: not scanning\n"); + return SANE_STATUS_INVAL; + } + if (non_blocking) + return SANE_STATUS_UNSUPPORTED; + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + Mustek_Usb_Scanner *s = handle; + + DBG (5, "sane_get_select_fd: handle = %p, fd = %p\n", handle, (void *) fd); + if (!s->scanning) + { + DBG (1, "sane_get_select_fd: not scanning\n"); + return SANE_STATUS_INVAL; + } + return SANE_STATUS_UNSUPPORTED; +} |