diff options
Diffstat (limited to 'backend/pieusb.c')
| -rw-r--r-- | backend/pieusb.c | 1422 |
1 files changed, 1422 insertions, 0 deletions
diff --git a/backend/pieusb.c b/backend/pieusb.c new file mode 100644 index 0000000..4b07304 --- /dev/null +++ b/backend/pieusb.c @@ -0,0 +1,1422 @@ +/* sane - Scanner Access Now Easy. + + pieusb.c + + Copyright (C) 2012-2015 Jan Vleeshouwers, Michael Rickmann, Klaus Kaempf + + 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. */ + +/* ========================================================================= + * + * SANE interface to three Reflecta USB scanners with USB-id 0x05e3/0x0145: + * - Reflecta CrystalScan 7200 (model id 0x30) + * - Reflecta ProScan 7200 (model id 0x36) + * - Reflecta 6000 Multiple Slide Scanner (model id 0x3A) + * + * ========================================================================= */ + +#define DEBUG_NOT_STATIC +/* -------------------------------------------------------------------------- + * + * INCLUDES + * + * --------------------------------------------------------------------------*/ + +#include "../include/sane/config.h" +/* Standard includes for various utiliy functions */ +#include <stdio.h> /* for FILE */ +#include <string.h> /* for strlen */ +#include <stdlib.h> /* for NULL */ +#include <stdint.h> +#include <math.h> + +/* Configuration defines */ +#include "../include/sane/config.h" + +/* SANE includes */ +#include "../include/sane/sane.h" +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei_usb.h" +#include "../include/sane/sanei_config.h" + +/* Backend includes */ +#define BACKEND_NAME pieusb +#include "../include/sane/sanei_backend.h" +#include "pieusb.h" +#include "pieusb_specific.h" + +#define CAN_DO_4_CHANNEL_TIFF + +#ifdef CAN_DO_4_CHANNEL_TIFF +extern void write_tiff_rgbi_header (FILE *fptr, int width, int height, int depth, int resolution, const char *icc_profile); +#endif + +/* -------------------------------------------------------------------------- + * + * DEFINES + * + * --------------------------------------------------------------------------*/ + +/* Build number of this backend */ +#define BUILD 1 + +/* Configuration filename */ +#define PIEUSB_CONFIG_FILE "pieusb.conf" + +/* Debug error levels */ +#define DBG_error 1 /* errors */ +#define DBG_warning 3 /* warnings */ +#define DBG_info 5 /* information */ +#define DBG_info_sane 7 /* information sane interface level */ +#define DBG_inquiry 8 /* inquiry data */ +#define DBG_info_proc 9 /* information pieusb backend functions */ +#define DBG_info_scan 11 /* information scanner commands */ +#define DBG_info_usb 13 /* information usb level functions */ + +/* -------------------------------------------------------------------------- + * + * SUPPORTED DEVICES SPECIFICS + * + * --------------------------------------------------------------------------*/ + +struct Pieusb_USB_Device_Entry* pieusb_supported_usb_device_list = NULL; +struct Pieusb_USB_Device_Entry pieusb_supported_usb_device; /* for searching */ + +/* -------------------------------------------------------------------------- + * + * LISTS OF ACTIVE DEVICE DEFINITIONS AND SCANNERS + * + * --------------------------------------------------------------------------*/ + +Pieusb_Device_Definition *pieusb_definition_list_head = NULL; +static Pieusb_Scanner *first_handle = NULL; +static const SANE_Device **devlist = NULL; + +/* -------------------------------------------------------------------------- + * + * SANE INTERFACE + * + * --------------------------------------------------------------------------*/ + +/** + * Initializes the debugging system, the USB system, the version code and + * 'attaches' available scanners, i.e. creates device definitions for all + * scanner devices found. + * + * @param version_code + * @param authorize + * @return SANE_STATUS_GOOD + */ +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize) +{ + FILE *fp; + char config_line[PATH_MAX]; + SANE_Word vendor_id; + SANE_Word product_id; + SANE_Word model_number; + SANE_Status status; + int i; + + /* Initialize debug logging */ + DBG_INIT (); + + DBG (DBG_info_sane, "sane_init() build %d\n", BUILD); + + /* Set version code to current major, minor and build number */ + /* TODO: use V_MINOR instead or SANE_CURRENT_MINOR? If so, why? */ + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BUILD); + + /* Initialize usb */ + sanei_usb_init (); + sanei_usb_set_timeout (30 * 1000); /* 30 sec timeout */ + + /* There are currently 3 scanners hardcoded into this backend, see below. + * The config file may add other scanners using a line like + * usb 0x1234 0x5678 0x9A + * where the first two hex numbers are vendor and product id, and the last + * number is the model number. Unfortunately, this is not according to the + * config file standard. Anyone any suggestions? */ + + /* Create default list */ + pieusb_supported_usb_device_list = calloc (4, sizeof(struct Pieusb_USB_Device_Entry)); + if (pieusb_supported_usb_device_list == NULL) + return SANE_STATUS_NO_MEM; + /* Reflecta CrystalScan 7200, model number 0x30 */ + pieusb_supported_usb_device_list[0].vendor = 0x05e3; + pieusb_supported_usb_device_list[0].product = 0x0145; + pieusb_supported_usb_device_list[0].model = 0x30; + /* Reflecta ProScan 7200, model number 0x36 */ + pieusb_supported_usb_device_list[1].vendor = 0x05e3; + pieusb_supported_usb_device_list[1].product = 0x0145; + pieusb_supported_usb_device_list[1].model = 0x36; + /* Reflecta 6000 Multiple Slide Scanner */ + pieusb_supported_usb_device_list[2].vendor = 0x05e3; + pieusb_supported_usb_device_list[2].product = 0x0142; + pieusb_supported_usb_device_list[2].model = 0x3a; + /* end of list */ + pieusb_supported_usb_device_list[3].vendor = 0; + pieusb_supported_usb_device_list[3].product = 0; + pieusb_supported_usb_device_list[3].model = 0; + + /* Add entries from config file */ + fp = sanei_config_open (PIEUSB_CONFIG_FILE); + if (!fp) { + DBG (DBG_info_sane, "sane_init() did not find a config file, using default list of supported devices\n"); + } else { + while (sanei_config_read (config_line, sizeof (config_line), fp)) { + /* Ignore line comments and empty lines */ + if (config_line[0] == '#') continue; + if (strlen (config_line) == 0) continue; + /* Ignore lines which do not begin with 'usb ' */ + if (strncmp (config_line, "usb ", 4) != 0) continue; + /* Parse vendor-id, product-id and model number and add to list */ + DBG (DBG_info_sane, "sane_init() config file parsing %s\n", config_line); + status = sanei_pieusb_parse_config_line(config_line, &vendor_id, &product_id, &model_number); + if (status == SANE_STATUS_GOOD) { + DBG (DBG_info_sane, "sane_init() config file lists device %04x %04x %02x\n",vendor_id, product_id, model_number); + if (!sanei_pieusb_supported_device_list_contains(vendor_id, product_id, model_number)) { + DBG (DBG_info_sane, "sane_init() adding device %04x %04x %02x\n",vendor_id, product_id, model_number); + sanei_pieusb_supported_device_list_add(vendor_id, product_id, model_number); + } else { + DBG (DBG_info_sane, "sane_init() list already contains %04x %04x %02x\n", vendor_id, product_id, model_number); + } + } else { + DBG (DBG_info_sane, "sane_init() config file parsing %s: error\n", config_line); + } + } + fclose (fp); + } + + /* Loop through supported device list */ + i = 0; + while (pieusb_supported_usb_device_list[i].vendor != 0) { + /* Check if the supported device is present. If so, create a device + * definition structure for it. + * The variable pieusb_supported_usb_device is set to current values, + * which are used in the callback. */ + pieusb_supported_usb_device.vendor = pieusb_supported_usb_device_list[i].vendor; + pieusb_supported_usb_device.product = pieusb_supported_usb_device_list[i].product; + pieusb_supported_usb_device.model = pieusb_supported_usb_device_list[i].model; + pieusb_supported_usb_device.device_number = -1; /* No device number (yet) */ + DBG( DBG_info_sane, "sane_init() looking for Reflecta scanner %04x %04x model %02x\n", pieusb_supported_usb_device.vendor, pieusb_supported_usb_device.product, pieusb_supported_usb_device.model); + sanei_usb_find_devices (pieusb_supported_usb_device.vendor, pieusb_supported_usb_device.product, sanei_pieusb_find_device_callback); + i++; + } + return SANE_STATUS_GOOD; +} + +/** + * Backend exit. + * Clean up allocated memory. + */ +void +sane_exit (void) +{ + Pieusb_Device_Definition *dev, *next; + + DBG (DBG_info_sane, "sane_exit()\n"); + + for (dev = pieusb_definition_list_head; dev; dev = next) { + next = dev->next; + free((void *)dev->sane.name); + free((void *)dev->sane.vendor); + free((void *)dev->sane.model); + free (dev->version); + free (dev); + } + pieusb_definition_list_head = NULL; + + if (devlist) { + free (devlist); + devlist = NULL; + } +} + +/** + * Create a SANE device list from the device list generated by sane_init(). + * + * @param device_list List of SANE_Device elements + * @param local_only If true, disregard network scanners. Not applicable for USB scanners. + * @return SANE_STATUS_GOOD, or SANE_STATUS_NO_MEM if the list cannot be allocated + */ +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool __sane_unused__ local_only) +{ + Pieusb_Device_Definition *dev; + int i; + + DBG (DBG_info_sane, "sane_get_devices\n"); + + /* Create SANE_DEVICE list from device list created in sane_init() */ + i = 0; + for (dev = pieusb_definition_list_head; dev; dev = dev->next) { + i++; + } + if (devlist) { + free (devlist); + } + devlist = malloc ((i + 1) * sizeof (devlist[0])); + if (!devlist) { + return SANE_STATUS_NO_MEM; + } + i = 0; + for (dev = pieusb_definition_list_head; dev; dev = dev->next) { + devlist[i++] = &dev->sane; + } + devlist[i] = NULL; + *device_list = devlist; + return SANE_STATUS_GOOD; +} + +/** + * Open the scanner with the given devicename and return a handle to it, which + * is a pointer to a Pieusb_Scanner struct. The handle will be an input to + * a couple of other functions of the SANE interface. + * + * @param devicename Name of the device, corresponds to SANE_Device.name + * @param handle handle to scanner (pointer to a Pieusb_Scanner struct) + * @return SANE_STATUS_GOOD if the device has been opened + */ +SANE_Status +sane_open (SANE_String_Const devicename, SANE_Handle * handle) +{ + Pieusb_Device_Definition *dev; + SANE_Status status; + Pieusb_Scanner *scanner, *s; + + DBG (DBG_info_sane, "sane_open(%s)\n", devicename); + + /* Search for devicename */ + if (devicename[0]) { + for (dev = pieusb_definition_list_head; dev; dev = dev->next) { + if (strcmp (dev->sane.name, devicename) == 0) { + break; + } + } + if (!dev) { + /* Is it a valid USB device? */ + SANE_Word vendor; + SANE_Word product; + int i = 0; + + status = sanei_usb_get_vendor_product_byname (devicename, &vendor, &product); + if (status != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_open: sanei_usb_get_vendor_product_byname failed %s\n", devicename); + return status; + } + /* Get vendor-product-model & verify that is is supported */ + /* Loop through supported device list */ + while (pieusb_supported_usb_device_list[i].vendor != 0) { + /* Check if vendor and product match */ + if (pieusb_supported_usb_device_list[i].vendor == vendor + && pieusb_supported_usb_device_list[i].product == product) { + /* Check if a supported device is present + * If so, create a device definition structure for it. */ + /* Set pieusb_supported_usb_device to current values: these are used in callback */ + pieusb_supported_usb_device.vendor = vendor; + pieusb_supported_usb_device.product = product; + pieusb_supported_usb_device.model = pieusb_supported_usb_device_list[i].model; + pieusb_supported_usb_device.device_number = -1; + sanei_usb_find_devices (vendor, product, sanei_pieusb_find_device_callback); + if (pieusb_supported_usb_device.device_number == -1) { + /* Did not succeed in opening the USB device, which is an error. + * This error is not caught by sanei_usb_find_devices(), so handle + * it here. */ + DBG (DBG_error, "sane_open: sanei_usb_find_devices did not open device %s\n", devicename); + return SANE_STATUS_INVAL; + } + } + i++; + } + /* Now rescan the device list to see if it is present */ + for (dev = pieusb_definition_list_head; dev; dev = dev->next) { + if (strcmp (dev->sane.name, devicename) == 0) { + break; + } + } + } + } else { + /* empty devicename -> use first device */ + dev = pieusb_definition_list_head; + } + /* If no device found, return error */ + if (!dev) { + return SANE_STATUS_INVAL; + } + + /* Now create a scanner structure to return */ + + /* Check if we are not opening the same scanner again. */ + for (s = first_handle; s; s = s->next) { + if (s->device->sane.name == devicename) { + *handle = s; + return SANE_STATUS_GOOD; + } + } + + /* Create a new scanner instance */ + scanner = malloc (sizeof (*scanner)); + if (!scanner) { + return SANE_STATUS_NO_MEM; + } + memset (scanner, 0, sizeof (*scanner)); + scanner->device = dev; + sanei_usb_open (dev->sane.name, &scanner->device_number); + scanner->cancel_request = 0; + scanner->shading_data_present = SANE_FALSE; + /* Options and buffers */ + (void)sanei_pieusb_init_options (scanner); + + /* wait for warmup */ + status = sanei_pieusb_wait_ready (scanner, 0); + if (status != SANE_STATUS_GOOD) { + sanei_usb_close(scanner->device_number); + free (scanner); + DBG (DBG_error, "sane_open: scanner not ready\n"); + return status; + } + + /* First time settings */ + /* ? */ + /* Insert newly opened handle into list of open handles: */ + scanner->next = first_handle; + first_handle = scanner; + + *handle = scanner; + return SANE_STATUS_GOOD; +} + +/** + * Close the scanner and remove the scanner from the list of active scanners. + * + * @param handle Scanner handle + */ +void +sane_close (SANE_Handle handle) +{ + Pieusb_Scanner *prev, *scanner; + SANE_Int k; + + DBG (DBG_info_sane, "sane_close()\n"); + + /* Find handle in list of open handles: */ + prev = 0; + for (scanner = first_handle; scanner; scanner = scanner->next) { + if (scanner == handle) { + break; + } + prev = scanner; + } + /* Not a handle we know about. This may happen since all different backend + * scanner instances are all cast to SANE_Handle (a void pointer) */ + if (!scanner) { + DBG (DBG_error, "sane_close(): invalid handle %p\n", handle); + return; + } + + /* Stop scan if still scanning */ + if (scanner->scanning) { + sanei_pieusb_on_cancel(scanner); + } + + /* USB scanners may be still open here */ + if (scanner->device_number >= 0) { + sanei_usb_reset (scanner->device_number); + sanei_usb_close (scanner->device_number); + } + /* Remove handle from list */ + if (prev) { + prev->next = scanner->next; + } else { + first_handle = scanner->next; + } + + /* Free scanner related allocated memory and the scanner itself */ + /*TODO: check if complete */ + if (scanner->buffer.data) sanei_pieusb_buffer_delete(&scanner->buffer); + free (scanner->ccd_mask); + for (k=0; k<4; k++) free (scanner->shading_ref[k]); + free (scanner->val[OPT_MODE].s); + free (scanner->val[OPT_HALFTONE_PATTERN].s); + free (scanner); +} + +/** + * Get option descriptor. Return the option descriptor with the given index + * + * @param handle Scanner handle + * @param option Index of option descriptor to return + * @return The option descriptor + */ +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + Pieusb_Scanner *scanner = handle; + + DBG (DBG_info_proc, "sane_get_option_descriptor() option=%d\n", option); + + if ((unsigned) option >= NUM_OPTIONS) + { + return 0; + } + + return scanner->opt + option; +} + +/** + * Set or inquire the current value of option number 'option' of the device + * represented by the given handle. + * + * @param handle Scanner handle + * @param option Index of option to set or get + * @param action Determines if the option value is read or set + * @param val Pointer to value to set or get + * @param info About set result. May be NULL. + * @return SANE_STATUS_GOOD, or SANE_STATUS_INVAL if a parameter cannot be set + */ +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action, + void *val, SANE_Int * info) +{ + Pieusb_Scanner *scanner = handle; + SANE_Status status; + SANE_Word cap; + SANE_String_Const name; + + DBG(DBG_info_sane,"sane_control_option()\n"); + if (info) { + *info = 0; + } + + /* Don't set or get options while the scanner is busy */ + if (scanner->scanning) { + DBG(DBG_error,"Device busy scanning, no option returned\n"); + return SANE_STATUS_DEVICE_BUSY; + } + + /* Check if option index is between bounds */ + if ((unsigned) option >= NUM_OPTIONS) { + DBG(DBG_error,"Index too large, no option returned\n"); + return SANE_STATUS_INVAL; + } + + /* Check if option is switched on */ + cap = scanner->opt[option].cap; + if (!SANE_OPTION_IS_ACTIVE (cap)) + { + DBG(DBG_error,"Option inactive (%s)\n", scanner->opt[option].name); + return SANE_STATUS_INVAL; + } + + /* Get name of option */ + name = scanner->opt[option].name; + if (!name) + { + name = "(no name)"; + } + + /* */ + switch (action) { + case SANE_ACTION_GET_VALUE: + + DBG (DBG_info_sane, "get %s [#%d]\n", name, option); + + switch (option) { + + /* word options: */ + case OPT_NUM_OPTS: + case OPT_BIT_DEPTH: + case OPT_RESOLUTION: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + case OPT_THRESHOLD: + case OPT_SHARPEN: + case OPT_SHADING_ANALYSIS: + case OPT_FAST_INFRARED: + case OPT_ADVANCE_SLIDE: + case OPT_CORRECT_SHADING: + case OPT_CORRECT_INFRARED: + case OPT_CLEAN_IMAGE: + case OPT_SMOOTH_IMAGE: + case OPT_TRANSFORM_TO_SRGB: + case OPT_INVERT_IMAGE: + case OPT_PREVIEW: + case OPT_SAVE_SHADINGDATA: + case OPT_SAVE_CCDMASK: + case OPT_LIGHT: + case OPT_DOUBLE_TIMES: + case OPT_SET_EXPOSURE_R: + case OPT_SET_EXPOSURE_G: + case OPT_SET_EXPOSURE_B: + case OPT_SET_EXPOSURE_I: + case OPT_SET_GAIN_R: + case OPT_SET_GAIN_G: + case OPT_SET_GAIN_B: + case OPT_SET_GAIN_I: + case OPT_SET_OFFSET_R: + case OPT_SET_OFFSET_G: + case OPT_SET_OFFSET_B: + case OPT_SET_OFFSET_I: + *(SANE_Word *) val = scanner->val[option].w; + DBG (DBG_info_sane, "get %s [#%d] val=%d\n", name, option,scanner->val[option].w); + return SANE_STATUS_GOOD; + + /* word-array options: => for exposure gain offset? */ + case OPT_CROP_IMAGE: + memcpy (val, scanner->val[option].wa, scanner->opt[option].size); + return SANE_STATUS_GOOD; + + /* string options */ + case OPT_MODE: + case OPT_CALIBRATION_MODE: + case OPT_GAIN_ADJUST: + case OPT_HALFTONE_PATTERN: + strcpy (val, scanner->val[option].s); + DBG (DBG_info_sane, "get %s [#%d] val=%s\n", name, option,scanner->val[option].s); + return SANE_STATUS_GOOD; + } + break; + + case SANE_ACTION_SET_VALUE: + + switch (scanner->opt[option].type) { + case SANE_TYPE_INT: + DBG (DBG_info_sane, "set %s [#%d] to %d, size=%d\n", name, option, *(SANE_Word *) val, scanner->opt[option].size); + break; + case SANE_TYPE_FIXED: + DBG (DBG_info_sane, "set %s [#%d] to %f\n", name, option, SANE_UNFIX (*(SANE_Word *) val)); + break; + case SANE_TYPE_STRING: + DBG (DBG_info_sane, "set %s [#%d] to %s\n", name, option, (char *) val); + break; + case SANE_TYPE_BOOL: + DBG (DBG_info_sane, "set %s [#%d] to %d\n", name, option, *(SANE_Word *) val); + break; + default: + DBG (DBG_info_sane, "set %s [#%d]\n", name, option); + } + /* Check if option can be set */ + if (!SANE_OPTION_IS_SETTABLE (cap)) { + return SANE_STATUS_INVAL; + } + /* Check if new value within bounds */ + status = sanei_constrain_value (scanner->opt + option, val, info); + if (status != SANE_STATUS_GOOD) { + return status; + } + /* Set option and handle info return */ + switch (option) + { + /* (mostly) side-effect-free word options: */ + case OPT_BIT_DEPTH: + case OPT_RESOLUTION: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + case OPT_SHARPEN: + case OPT_SHADING_ANALYSIS: + case OPT_FAST_INFRARED: + if (info) { + *info |= SANE_INFO_RELOAD_PARAMS; + } + /* fall through */ + case OPT_NUM_OPTS: + case OPT_PREVIEW: + case OPT_ADVANCE_SLIDE: + case OPT_CORRECT_SHADING: + case OPT_CORRECT_INFRARED: + case OPT_CLEAN_IMAGE: + case OPT_SMOOTH_IMAGE: + case OPT_TRANSFORM_TO_SRGB: + case OPT_INVERT_IMAGE: + case OPT_SAVE_SHADINGDATA: + case OPT_SAVE_CCDMASK: + case OPT_THRESHOLD: + case OPT_LIGHT: + case OPT_DOUBLE_TIMES: + case OPT_SET_GAIN_R: + case OPT_SET_GAIN_G: + case OPT_SET_GAIN_B: + case OPT_SET_GAIN_I: + case OPT_SET_OFFSET_R: + case OPT_SET_OFFSET_G: + case OPT_SET_OFFSET_B: + case OPT_SET_OFFSET_I: + case OPT_SET_EXPOSURE_R: + case OPT_SET_EXPOSURE_G: + case OPT_SET_EXPOSURE_B: + case OPT_SET_EXPOSURE_I: + scanner->val[option].w = *(SANE_Word *) val; + break; + + /* side-effect-free word-array options: */ + case OPT_CROP_IMAGE: + memcpy (scanner->val[option].wa, val, scanner->opt[option].size); + break; + + /* options with side-effects: */ + case OPT_MODE: + { + /* Free current setting */ + if (scanner->val[option].s) { + free (scanner->val[option].s); + } + /* New setting */ + scanner->val[option].s = (SANE_Char *) strdup (val); + /* Info */ + if (info) { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + break; + } + + case OPT_CALIBRATION_MODE: + case OPT_GAIN_ADJUST: + case OPT_HALFTONE_PATTERN: + { + /* Free current setting */ + if (scanner->val[option].s) { + free (scanner->val[option].s); + } + /* New setting */ + scanner->val[option].s = (SANE_Char *) strdup (val); + break; + } + + } + + /* Check the whole set */ + if (sanei_pieusb_analyse_options(scanner)) { + return SANE_STATUS_GOOD; + } else { + return SANE_STATUS_INVAL; + } + + break; + default: + return SANE_STATUS_INVAL; + break; + } + return SANE_STATUS_INVAL; +} + +/** + * Obtain the current scan parameters. The returned parameters are guaranteed + * to be accurate between the time a scan has been started (sane start() has + * been called) and the completion of that request. Outside of that window, the + * returned values are best-effort estimates of what the parameters will be when + * sane start() gets invoked. - says the SANE standard. + * + * @param handle Scanner handle + * @param params Scan parameters + * @return SANE_STATUS_GOOD + */ +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + Pieusb_Scanner *scanner = handle; + const char *mode; + double resolution, width, height; + SANE_Int colors; + + DBG (DBG_info_sane, "sane_get_parameters\n"); + + if (params) { + + if (scanner->scanning) { + /* sane_start() initialized a SANE_Parameters struct in the scanner */ + DBG (DBG_info_sane, "sane_get_parameters from scanner values\n"); + params->bytes_per_line = scanner->scan_parameters.bytes_per_line; + params->depth = scanner->scan_parameters.depth; + params->format = scanner->scan_parameters.format; + params->last_frame = scanner->scan_parameters.last_frame; + params->lines = scanner->scan_parameters.lines; + params->pixels_per_line = scanner->scan_parameters.pixels_per_line; + } else { + /* Calculate appropriate values from option settings */ + DBG (DBG_info_sane, "sane_get_parameters from option values\n"); + if (scanner->val[OPT_PREVIEW].b) { + resolution = scanner->device->fast_preview_resolution; + } else { + resolution = SANE_UNFIX(scanner->val[OPT_RESOLUTION].w); + } + DBG (DBG_info_sane, " resolution %f\n", resolution); + width = SANE_UNFIX(scanner->val[OPT_BR_X].w)-SANE_UNFIX(scanner->val[OPT_TL_X].w); + height = SANE_UNFIX(scanner->val[OPT_BR_Y].w)-SANE_UNFIX(scanner->val[OPT_TL_Y].w); + DBG (DBG_info_sane, " width x height: %f x %f\n", width, height); + params->lines = height / MM_PER_INCH * resolution; + params->pixels_per_line = width / MM_PER_INCH * resolution; + mode = scanner->val[OPT_MODE].s; + if (strcmp(mode, SANE_VALUE_SCAN_MODE_LINEART) == 0) { + params->format = SANE_FRAME_GRAY; + params->depth = 1; + colors = 1; + } else if(strcmp(mode, SANE_VALUE_SCAN_MODE_HALFTONE) == 0) { + params->format = SANE_FRAME_GRAY; + params->depth = 1; + colors = 1; + } else if(strcmp(mode, SANE_VALUE_SCAN_MODE_GRAY) == 0) { + params->format = SANE_FRAME_GRAY; + params->depth = scanner->val[OPT_BIT_DEPTH].w; + colors = 1; + } else if(strcmp(mode, SANE_VALUE_SCAN_MODE_RGBI) == 0) { + params->format = SANE_FRAME_RGB; /* was: SANE_FRAME_RGBI */ + params->depth = scanner->val[OPT_BIT_DEPTH].w; + colors = 4; + } else { /* SANE_VALUE_SCAN_MODE_COLOR */ + params->format = SANE_FRAME_RGB; + params->depth = scanner->val[OPT_BIT_DEPTH].w; + colors = 3; + } + DBG (DBG_info_sane, " colors: %d\n", colors); + if (params->depth == 1) { + params->bytes_per_line = colors * (params->pixels_per_line + 7)/8; + } else if (params->depth <= 8) { + params->bytes_per_line = colors * params->pixels_per_line; + } else if (params->depth <= 16) { + params->bytes_per_line = 2 * colors * params->pixels_per_line; + } + params->last_frame = SANE_TRUE; + } + + DBG(DBG_info_sane,"sane_get_parameters(): SANE parameters\n"); + DBG(DBG_info_sane," format = %d\n",params->format); + DBG(DBG_info_sane," last_frame = %d\n",params->last_frame); + DBG(DBG_info_sane," bytes_per_line = %d\n",params->bytes_per_line); + DBG(DBG_info_sane," pixels_per_line = %d\n",params->pixels_per_line); + DBG(DBG_info_sane," lines = %d\n",params->lines); + DBG(DBG_info_sane," depth = %d\n",params->depth); + + } else { + + DBG(DBG_info_sane," no params argument, no values returned\n"); + + } + + return SANE_STATUS_GOOD; +} + +/** + * Initiates aquisition of an image from the scanner. + * SCAN Phase 1: initialization and calibration + * (SCAN Phase 2: line-by-line scan & read is not implemented) + * SCAN Phase 3: get CCD-mask + * SCAN phase 4: scan slide and save data in scanner buffer + + * @param handle Scanner handle + * @return + */ +SANE_Status +sane_start (SANE_Handle handle) +{ + struct Pieusb_Scanner *scanner = handle; + struct Pieusb_Command_Status status; + SANE_Byte colors; + const char *mode; + SANE_Bool shading_correction_relevant; + SANE_Bool infrared_post_processing_relevant; + SANE_Status st; + SANE_Int bytes_per_line; + + SANE_Int shading_width; + SANE_Int shading_idx; + + struct Pieusb_Exposure_Time exptime = { + 0x93, /* code 0x93 */ + 3 * 2 * sizeof(SANE_Int), /* number of bytes in rest of structure */ + { { 0x02, 100 }, { 0x04, 100 }, { 0x08, 100 } } + }; + + struct Pieusb_Highlight_Shadow shadow = { + 0x94, /* code 0x94 */ + 3 * 2 * sizeof(SANE_Int), /* number of bytes in rest of structure */ + { { 0x02, 100 }, { 0x04, 100 }, { 0x08, 100 } } + }; + + DBG (DBG_info_sane, "sane_start()\n"); + + /* ---------------------------------------------------------------------- + * + * Exit if currently scanning + * + * ---------------------------------------------------------------------- */ + if (scanner->scanning) { + DBG (DBG_error, "sane_start(): scanner is already scanning, exiting\n"); + return SANE_STATUS_DEVICE_BUSY; + } + + /* ---------------------------------------------------------------------- + * + * Exit with pause if not warmed up + * + * ---------------------------------------------------------------------- */ + + sanei_pieusb_cmd_read_state (scanner->device_number, &(scanner->state), &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + if (status.pieusb_status == PIEUSB_STATUS_DEVICE_BUSY) + return SANE_STATUS_DEVICE_BUSY; /* was: SANE_STATUS_WARMING_UP */ + DBG (DBG_error, "sane_start(): warmed up check returns status: %s\n", sane_strstatus (sanei_pieusb_convert_status(status.pieusb_status))); + return SANE_STATUS_IO_ERROR; + } + if (scanner->state.warmingUp) { + DBG (DBG_error, "sane_start(): warming up, exiting\n"); + /* Seen SANE_STATUS_WARMING_UP in scanimage => enabled */ + sleep (10); /* scanimage does not pause, so do it here */ + return SANE_STATUS_DEVICE_BUSY; /* was: SANE_STATUS_WARMING_UP */ + } + + /* ---------------------------------------------------------------------- + * set exposure time + * ---------------------------------------------------------------------- */ + + sanei_pieusb_cmd_set_exposure_time (scanner->device_number, &exptime, &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): sanei_pieusb_cmd_set_exposure_time failed: %d\n", status.pieusb_status); + return SANE_STATUS_IO_ERROR; + } + + /* ---------------------------------------------------------------------- + * set highlight shadow + * ---------------------------------------------------------------------- */ + + sanei_pieusb_cmd_set_highlight_shadow (scanner->device_number, &shadow, &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): sanei_pieusb_cmd_set_highlight_shadow failed: %d\n", status.pieusb_status); + return SANE_STATUS_IO_ERROR; + } + + /* ---------------------------------------------------------------------- + * get calibration info + * ---------------------------------------------------------------------- */ + + sanei_pieusb_cmd_get_shading_parms (scanner->device_number, scanner->device->shading_parameters, &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "sane_scan: sanei_pieusb_cmd_get_shading_parms failed: %d\n", status.pieusb_status); + return SANE_STATUS_INVAL; + } + shading_width = scanner->device->shading_parameters[0].pixelsPerLine; + DBG (DBG_info, "shading_width %d\n", shading_width); + for (shading_idx = 0; shading_idx < SHADING_PARAMETERS_INFO_COUNT; shading_idx++) { + scanner->shading_ref[shading_idx] = + realloc(scanner->shading_ref[shading_idx], 2 * shading_width * sizeof(SANE_Int)); + if (scanner->shading_ref[shading_idx] == NULL) { + return SANE_STATUS_NO_MEM; + } + } + scanner->ccd_mask = realloc (scanner->ccd_mask, shading_width); + scanner->ccd_mask_size = shading_width; + if (scanner->ccd_mask == NULL) { + return SANE_STATUS_NO_MEM; + } + + /* ---------------------------------------------------------------------- + * + * Standard run does; + * - set exposure time 0x0A/0x13 + * - set highlight shadow 0x0A/0x14 + * - read shading parameters 0x0A/0x95/0x08 + * - set scan frame 0x0A/0x12 + * "12 00 0a00 80 00 0300 0000 b829 e31a" + * => 0:12 1:0 2:10 4:80 5:0 6:3 8:0 10:10680 12:6883 + * - read gain offset 0xD7 + * - set gain offset 0xDC + * - set mode 0x15 + * "00 0f 2c01 80 04 04 00 01 0a 00 00 00 80 10 00" + * size res pass dpt frm ord bitmap ptn thr + * 15 300 RGB 8 inx intel 1=sharpen 0 128 + * 3=skipshad + * + * ---------------------------------------------------------------------- */ + + /* ---------------------------------------------------------------------- + * + * Show and check options + * + * ---------------------------------------------------------------------- */ + sanei_pieusb_print_options (scanner); + if (!sanei_pieusb_analyse_options (scanner)) { + return SANE_STATUS_IO_ERROR; + } + + /* ---------------------------------------------------------------------- + * + * Set scan frame + * + * ---------------------------------------------------------------------- */ + if (sanei_pieusb_set_frame_from_options (scanner) != SANE_STATUS_GOOD) { + return SANE_STATUS_IO_ERROR; + } + + /* ---------------------------------------------------------------------- + * + * Function 17 + * + * ---------------------------------------------------------------------- */ + + sanei_pieusb_cmd_17 (scanner->device_number, 1, &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): sanei_pieusb_cmd_17 failed: %d\n", status.pieusb_status); + return SANE_STATUS_IO_ERROR; + } + st = sanei_pieusb_wait_ready (scanner, 0); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): scanner not ready after sanei_pieusb_cmd_17: %d\n", st); + return st; + } + + /* ---------------------------------------------------------------------- + * + * Get & set initial gains and offsets + * + * There does not seem to be much reason to set exposure/gain/offset + * now, but it does make a large difference in speed, because it + * creates a small BADF-table. This is probably because without SET GAIN + * OFFSET, extraEntries has a random value (it is not initialised). + * + * TODO: test if this may be done just once, in sane_open(). + * + * ---------------------------------------------------------------------- */ + + if (sanei_pieusb_set_gain_offset (scanner, scanner->val[OPT_CALIBRATION_MODE].s) != SANE_STATUS_GOOD) { + return SANE_STATUS_IO_ERROR; + } + + st = sanei_pieusb_wait_ready (scanner, 0); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_start: scanner not ready %d\n", st); + return st; + } + + /* ---------------------------------------------------------------------- + * + * Set mode + * + * ---------------------------------------------------------------------- */ + if (sanei_pieusb_set_mode_from_options (scanner) != SANE_STATUS_GOOD) { + return SANE_STATUS_IO_ERROR; + } + + /* ---------------------------------------------------------------------- + * + * Lamp on + * + * ---------------------------------------------------------------------- */ + sanei_pieusb_cmd_slide (scanner->device_number, SLIDE_LAMP_ON, &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): sanei_pieusb_cmd_slide failed: %d\n", status.pieusb_status); + return SANE_STATUS_IO_ERROR; + } + st = sanei_pieusb_wait_ready (scanner, 0); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_start: scanner not ready %d\n", st); + return st; + } + + /* Enter SCAN phase 1 */ + DBG (DBG_info_sane, "sane_start(): scan phase 1\n"); + + /* ---------------------------------------------------------------------- + * + * Start scan & wait until device ready + * + * ---------------------------------------------------------------------- */ + scanner->scanning = SANE_TRUE; + scanner->cancel_request = SANE_FALSE; + for (;;) { + sanei_pieusb_cmd_start_scan (scanner->device_number, &status); + if (status.pieusb_status != PIEUSB_STATUS_WARMING_UP) + break; + sleep(5); + } + sanei_pieusb_wait_ready (scanner, 0); + if ((status.pieusb_status == PIEUSB_STATUS_MUST_CALIBRATE) + || (scanner->val[OPT_SHADING_ANALYSIS].b != 0)) { + + /* Overriding skip calibration */ + DBG (DBG_info_sane, "sane_start(): process shading data\n"); + + /* ------------------------------------------------------------------ + * + * Get and set gain and offset + * Get settings from scanner, from preview data, from options, + * or use defaults. + * + * ------------------------------------------------------------------ */ + if (sanei_pieusb_set_gain_offset (scanner, scanner->val[OPT_CALIBRATION_MODE].s) != SANE_STATUS_GOOD) { + sanei_pieusb_cmd_stop_scan (scanner->device_number, &status); + scanner->scanning = SANE_FALSE; + return SANE_STATUS_IO_ERROR; + } + /* ------------------------------------------------------------------ + * + * Obtain shading data + * Get parameters from scanner->device->shading_parameters[0] although + * it's 45 lines, scanner->ccd_mask_size pixels, 16 bit depth in all cases. + * + * ------------------------------------------------------------------ */ + if (sanei_pieusb_get_shading_data (scanner) != SANE_STATUS_GOOD) { + sanei_pieusb_cmd_stop_scan (scanner->device_number, &status); + scanner->scanning = SANE_FALSE; + return SANE_STATUS_IO_ERROR; + } + } + + /* Enter SCAN phase 2 */ + DBG (DBG_info_sane, "sane_start(): scan phase 2\n"); + + /* SCAN phase 2 (line-by-line scan) not implemented */ + + st = sanei_pieusb_wait_ready (scanner, 0); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_start: scanner not ready %d\n", st); + return st; + } + + /* Enter SCAN phase 3 */ + + DBG (DBG_info_sane, "sane_start(): scan phase 3\n"); + + /* Handle cancel request */ + if (scanner->cancel_request) { + return sanei_pieusb_on_cancel (scanner); + } + + /* ---------------------------------------------------------------------- + * + * Get CCD mask + * + * ---------------------------------------------------------------------- */ + + if (sanei_pieusb_get_ccd_mask (scanner) != SANE_STATUS_GOOD) { + sanei_pieusb_cmd_stop_scan (scanner->device_number, &status); + scanner->scanning = SANE_FALSE; + return SANE_STATUS_IO_ERROR; + } + + /* Enter SCAN phase 4 */ + + /* ---------------------------------------------------------------------- + * + * Read scan parameters & wait until ready for reading + * + * ---------------------------------------------------------------------- */ + if (sanei_pieusb_get_parameters (scanner, &bytes_per_line) != SANE_STATUS_GOOD) { + sanei_pieusb_cmd_stop_scan (scanner->device_number, &status); + scanner->scanning = SANE_FALSE; + return SANE_STATUS_IO_ERROR; + } + + st = sanei_pieusb_wait_ready (scanner, 0); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_start: scanner not ready %d\n", st); + return st; + } + + /* ---------------------------------------------------------------------- + * + * Prepare read buffer + * Currently this buffer is always a memory mapped buffer + * Might be faster to use RAM buffers for small images (such as preview) + * + * ---------------------------------------------------------------------- */ + colors = 0x00; + switch (scanner->mode.passes) { + case SCAN_FILTER_RED: colors = 0x01; break; + case SCAN_FILTER_GREEN: colors = 0x02; break; + case SCAN_FILTER_BLUE: colors = 0x04; break; + case SCAN_FILTER_INFRARED: colors = 0x08; break; + case SCAN_ONE_PASS_COLOR: colors = 0x07; break; + case SCAN_ONE_PASS_RGBI: colors = 0x0F; break; + } + if (scanner->buffer.data) sanei_pieusb_buffer_delete(&scanner->buffer); /* free resources from previous invocation */ + st = sanei_pieusb_buffer_create (&(scanner->buffer), scanner->scan_parameters.pixels_per_line, + scanner->scan_parameters.lines, colors, + scanner->scan_parameters.depth); + if (st != SANE_STATUS_GOOD) { + scanner->scanning = SANE_FALSE; + return st; + } + + /* ---------------------------------------------------------------------- + * + * Read all image data into the buffer + * + * ---------------------------------------------------------------------- */ + if (sanei_pieusb_get_scan_data (scanner, bytes_per_line) != SANE_STATUS_GOOD) { + scanner->scanning = SANE_FALSE; + return SANE_STATUS_IO_ERROR; + } + sleep(2); + st = sanei_pieusb_wait_ready (scanner, 0); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): scanner not ready after sanei_pieusb_get_scan_data: %d\n", st); + scanner->scanning = SANE_FALSE; + return st; + } + + /* ---------------------------------------------------------------------- + * + * Advance to next slide (except for preview) + * + * ---------------------------------------------------------------------- */ + if (scanner->val[OPT_ADVANCE_SLIDE].b && !scanner->val[OPT_PREVIEW].b) { + sanei_pieusb_cmd_slide (scanner->device_number, SLIDE_NEXT, &status); + if (status.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "sane_start(): sanei_pieusb_cmd_slide failed: %d\n", status.pieusb_status); + + } + } + + /* ---------------------------------------------------------------------- + * + * Post processing: + * 1. Correct for shading + * 2. Remove R-component from IR data + * 3. Remove dust + * + * ---------------------------------------------------------------------- */ + + mode = scanner->val[OPT_MODE].s; + if (strcmp(mode, SANE_VALUE_SCAN_MODE_LINEART) == 0) { + shading_correction_relevant = SANE_FALSE; /* Shading correction irrelavant at bit depth 1 */ + infrared_post_processing_relevant = SANE_FALSE; /* No infrared, no postprocessing */ + } else if (strcmp(mode, SANE_VALUE_SCAN_MODE_HALFTONE) == 0) { + shading_correction_relevant = SANE_FALSE; /* Shading correction irrelavant at bit depth 1 */ + infrared_post_processing_relevant = SANE_FALSE; /* No infrared, no postprocessing */ + } else if (strcmp(mode, SANE_VALUE_SCAN_MODE_GRAY) == 0) { + shading_correction_relevant = SANE_TRUE; + infrared_post_processing_relevant = SANE_FALSE; /* No infrared, no postprocessing */ + } else if (scanner->val[OPT_PREVIEW].b) { + /* Catch preview here, otherwise next ifs get complicated */ + shading_correction_relevant = SANE_TRUE; + infrared_post_processing_relevant = SANE_FALSE; + } else if (strcmp(mode, SANE_VALUE_SCAN_MODE_RGBI) == 0) { + shading_correction_relevant = SANE_TRUE; + infrared_post_processing_relevant = SANE_TRUE; + } else if (strcmp(mode, SANE_VALUE_SCAN_MODE_COLOR) == 0 && scanner->val[OPT_CLEAN_IMAGE].b) { + shading_correction_relevant = SANE_TRUE; + infrared_post_processing_relevant = SANE_TRUE; + } else { /* SANE_VALUE_SCAN_MODE_COLOR */ + shading_correction_relevant = SANE_TRUE; + infrared_post_processing_relevant = SANE_TRUE; + } + if (scanner->val[OPT_CORRECT_SHADING].b && shading_correction_relevant) { + if (scanner->shading_data_present) { + sanei_pieusb_correct_shading (scanner, &scanner->buffer); + } else { + DBG(DBG_warning, "sane_start(): unable to correct for shading, no shading data available\n"); + } + } + if ((scanner->val[OPT_CORRECT_INFRARED].b || scanner->val[OPT_CLEAN_IMAGE].b) && !scanner->val[OPT_PREVIEW].b && infrared_post_processing_relevant) { + /* Create array of pointers to color planes R, G, B, I */ + SANE_Uint *planes[PLANES]; + SANE_Int N; + N = scanner->buffer.width * scanner->buffer.height; + planes[0] = scanner->buffer.data; + planes[1] = scanner->buffer.data + N; + planes[2] = scanner->buffer.data + 2 * N; + planes[3] = scanner->buffer.data + 3 * N; + sanei_ir_init (); + sanei_pieusb_post (scanner, planes, scanner->buffer.colors); + } + + /* Save preview data. Preview data only used once to set gain and offset. */ + if (scanner->val[OPT_PREVIEW].b) { + sanei_pieusb_analyze_preview(scanner); + } else { + scanner->preview_done = SANE_FALSE; + } + + /* Modify buffer in case the buffer has infrared, but no infrared should be returned */ + if (scanner->buffer.colors == PLANES && (strcmp(mode,SANE_VALUE_SCAN_MODE_COLOR) == 0 && scanner->val[OPT_CLEAN_IMAGE].b)) { + DBG(DBG_info_sane, "sane_start(): modifying buffer to ignore I\n"); + /* Base buffer parameters */ + scanner->buffer.colors = 3; + /* Derived quantities */ + scanner->buffer.image_size_bytes = scanner->buffer.colors * scanner->buffer.height * scanner->buffer.line_size_bytes; + scanner->buffer.color_index_infrared = -1; + scanner->buffer.bytes_unread = scanner->buffer.bytes_unread * 3 / 4; + scanner->buffer.bytes_written = scanner->buffer.bytes_written * 3 / 4; + } + + return SANE_STATUS_GOOD; + +} + +/** + * Read image data from the scanner buffer. + * + * @param handle + * @param buf + * @param max_len + * @param len + * @return + */ +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len) +{ + + struct Pieusb_Scanner *scanner = handle; + SANE_Int return_size; + + DBG(DBG_info_sane, "sane_read(): requested %d bytes\n", max_len); + + /* No reading if not scanning */ + if (!scanner->scanning) { + *len = 0; + return SANE_STATUS_IO_ERROR; /* SANE standard does not allow a SANE_STATUS_INVAL return */ + } + + /* Handle cancel request */ + if (scanner->cancel_request) { + return sanei_pieusb_on_cancel(scanner); + } +#if 0 + /* Return image data, just read from scanner buffer */ + DBG(DBG_info_sane, "sane_read():\n"); + DBG(DBG_info_sane, " image size %d\n", scanner->buffer.image_size_bytes); + DBG(DBG_info_sane, " unread %d\n", scanner->buffer.bytes_unread); + DBG(DBG_info_sane, " read %d\n", scanner->buffer.bytes_read); + DBG(DBG_info_sane, " max_len %d\n", max_len); +#endif + if (scanner->buffer.bytes_read > scanner->buffer.image_size_bytes) { + /* Test if not reading past buffer boundaries */ + DBG(DBG_error, "sane_read(): reading past buffer boundaries (contains %d, read %d)\n", scanner->buffer.image_size_bytes, scanner->buffer.bytes_read); + *len = 0; + sanei_pieusb_on_cancel(scanner); + return SANE_STATUS_EOF; + } else if (scanner->buffer.bytes_read == scanner->buffer.image_size_bytes) { + /* Return EOF since all data of this frame has already been read. */ + *len = 0; + scanner->scanning = SANE_FALSE; + return SANE_STATUS_EOF; + } else if (scanner->buffer.bytes_unread >= max_len) { + /* Already enough data to return, do not read */ + DBG(DBG_info_sane, "sane_read(): buffer suffices (contains %d, requested %d)\n", scanner->buffer.bytes_unread, max_len); + return_size = max_len; + } else if (scanner->buffer.bytes_read + scanner->buffer.bytes_unread == scanner->buffer.image_size_bytes) { + /* All the remaining data is in the buffer, do not read */ + DBG(DBG_info_sane, "sane_read(): buffer suffices (contains %d, requested %d, last batch though)\n", scanner->buffer.bytes_unread, max_len); + return_size = scanner->buffer.bytes_unread; + } else { + /* Should not happen in this implementation - all data read by sane_start() */ + DBG(DBG_error, "sane_read(): shouldn't be here...\n"); + return SANE_STATUS_IO_ERROR; + } + + /* Check */ + if (return_size == 0 && scanner->buffer.bytes_read < scanner->buffer.image_size_bytes) { + DBG(DBG_error, "sane_read(): unable to service read request, %d bytes in frame, %d read\n", scanner->buffer.image_size_bytes, scanner->buffer.bytes_read); + } + + /* Return the available data: Output return_size bytes from buffer */ + sanei_pieusb_buffer_get(&scanner->buffer, buf, max_len, len); +#if 0 + DBG(DBG_info_sane, "sane_read(): currently read %.2f lines of %d\n", + (double)scanner->buffer.bytes_written/(scanner->buffer.line_size_bytes*scanner->buffer.colors), + scanner->buffer.height); + DBG(DBG_info_sane, "sane_read(): returning %d bytes (requested %d), returned %d of %d \n", + *len, max_len,scanner->buffer.bytes_read, scanner->buffer.image_size_bytes); +#endif + return SANE_STATUS_GOOD; + +} + +/** + * Request cancellation of current scanning process. + * + * @param handle Scanner handle + */ +void +sane_cancel (SANE_Handle handle) +{ + struct Pieusb_Scanner *scanner = handle; + + DBG (DBG_info_sane, "sane_cancel\n"); + + if (scanner->scanning) { + scanner->cancel_request = 1; + } +} + +/** + * Set the I/O mode of handle h. The I/O mode can be either blocking or + * non-blocking, but for USB devices, only blocking mode is supported. + * + * @param handle Scanner handle + * @param non_blocking + * @return SANE_STATUS_UNSUPPORTED; + */ +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + /* Pieusb_Scanner *scanner = handle; */ + + DBG (DBG_info_sane, "sane_set_io_mode: handle = %p, non_blocking = %s\n", handle, non_blocking == SANE_TRUE ? "true" : "false"); + + if (non_blocking) { + return SANE_STATUS_UNSUPPORTED; + } + + return SANE_STATUS_GOOD; +} + +/** + * Obtain a file-descriptor for the scanner that is readable if image data is + * available. The select file-descriptor is returned in *fd. + * The function has not been implemented since USB-device only operate in + * blocking mode. + * + * @param handle Scanner handle + * @param fd File descriptor with imae data + * @return SANE_STATUS_INVAL + */ +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + DBG(DBG_info_sane,"sane_get_select_fd(): not supported (only for non-blocking IO)\n"); + handle = handle; + fd = fd; + return SANE_STATUS_UNSUPPORTED; +} |