diff --git a/backend/leo.c b/backend/leo.c index a1ac30521..9012ef611 100644 --- a/backend/leo.c +++ b/backend/leo.c @@ -48,7 +48,7 @@ /*--------------------------------------------------------------------------*/ -#define BUILD 3 /* 2002/04/21 */ +#define BUILD 3 /* 2002/04/21 */ #define BACKEND_NAME leo #define LEO_CONFIG_FILE "leo.conf" @@ -82,10 +82,10 @@ /* Lists of possible scan modes. */ static SANE_String_Const scan_mode_list[] = { - BLACK_WHITE_STR, - GRAY_STR, - COLOR_STR, - NULL + BLACK_WHITE_STR, + GRAY_STR, + COLOR_STR, + NULL }; /*--------------------------------------------------------------------------*/ @@ -93,43 +93,43 @@ static SANE_String_Const scan_mode_list[] = { /* Minimum and maximum width and length supported. */ static SANE_Range x_range = { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }; static SANE_Range y_range = - { SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0 }; + { SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0 }; /*--------------------------------------------------------------------------*/ static const SANE_Range gamma_range = { - 0, /* minimum */ - 255, /* maximum */ - 0 /* quantization */ + 0, /* minimum */ + 255, /* maximum */ + 0 /* quantization */ }; /*--------------------------------------------------------------------------*/ static SANE_String_Const halftone_pattern_list[] = { - SANE_I18N ("None"), - SANE_I18N ("Diamond"), - SANE_I18N ("8x8 Coarse Fatting"), - SANE_I18N ("8x8 Fine Fatting"), - SANE_I18N ("8x8 Bayer"), - SANE_I18N ("8x8 Vertical Line"), - NULL + SANE_I18N ("None"), + SANE_I18N ("Diamond"), + SANE_I18N ("8x8 Coarse Fatting"), + SANE_I18N ("8x8 Fine Fatting"), + SANE_I18N ("8x8 Bayer"), + SANE_I18N ("8x8 Vertical Line"), + NULL }; static const halftone_pattern_t *const halftone_pattern_val[] = { - NULL, - &haltfone_pattern_diamond, - &haltfone_pattern_8x8_Coarse_Fatting, - &haltfone_pattern_8x8_Fine_Fatting, - &haltfone_pattern_8x8_Bayer, - &haltfone_pattern_8x8_Vertical_Line + NULL, + &haltfone_pattern_diamond, + &haltfone_pattern_8x8_Coarse_Fatting, + &haltfone_pattern_8x8_Fine_Fatting, + &haltfone_pattern_8x8_Bayer, + &haltfone_pattern_8x8_Vertical_Line }; /*--------------------------------------------------------------------------*/ /* Define the supported scanners and their characteristics. */ static const struct scanners_supported scanners[] = { - {6, "ACROSS ", " ", - "Across", "FS-1130"} + {6, "ACROSS ", " ", + "Across", "FS-1130"} }; /*--------------------------------------------------------------------------*/ @@ -146,41 +146,46 @@ static const SANE_Device **devlist = NULL; static void hexdump (int level, char *comment, unsigned char *p, int l) { - int i; - char line[128]; - char *ptr; - char asc_buf[17]; - char *asc_ptr; + int i; + char line[128]; + char *ptr; + char asc_buf[17]; + char *asc_ptr; - DBG (level, "%s\n", comment); + DBG (level, "%s\n", comment); - ptr = line; - *ptr = '\0'; - asc_ptr = asc_buf; - *asc_ptr = '\0'; + ptr = line; + *ptr = '\0'; + asc_ptr = asc_buf; + *asc_ptr = '\0'; - for (i = 0; i < l; i++, p++) { - if ((i % 16) == 0) { - if (ptr != line) { - DBG (level, "%s %s\n", line, asc_buf); - ptr = line; - *ptr = '\0'; - asc_ptr = asc_buf; - *asc_ptr = '\0'; - } - sprintf (ptr, "%3.3d:", i); - ptr += 4; - } - ptr += sprintf (ptr, " %2.2x", *p); - if (*p >= 32 && *p <= 127) { - asc_ptr += sprintf (asc_ptr, "%c", *p); - } - else { - asc_ptr += sprintf (asc_ptr, "."); - } + for (i = 0; i < l; i++, p++) + { + if ((i % 16) == 0) + { + if (ptr != line) + { + DBG (level, "%s %s\n", line, asc_buf); + ptr = line; + *ptr = '\0'; + asc_ptr = asc_buf; + *asc_ptr = '\0'; + } + sprintf (ptr, "%3.3d:", i); + ptr += 4; } - *ptr = '\0'; - DBG (level, "%s %s\n", line, asc_buf); + ptr += sprintf (ptr, " %2.2x", *p); + if (*p >= 32 && *p <= 127) + { + asc_ptr += sprintf (asc_ptr, "%c", *p); + } + else + { + asc_ptr += sprintf (asc_ptr, "."); + } + } + *ptr = '\0'; + DBG (level, "%s %s\n", line, asc_buf); } /* Returns the length of the longest string, including the terminating @@ -188,38 +193,42 @@ hexdump (int level, char *comment, unsigned char *p, int l) static size_t max_string_size (SANE_String_Const strings[]) { - size_t size, max_size = 0; - int i; + size_t size, max_size = 0; + int i; - for (i = 0; strings[i]; ++i) { - size = strlen (strings[i]) + 1; - if (size > max_size) { - max_size = size; - } + for (i = 0; strings[i]; ++i) + { + size = strlen (strings[i]) + 1; + if (size > max_size) + { + max_size = size; } + } - return max_size; + return max_size; } /* Lookup a string list from one array and return its index. */ static int get_string_list_index (SANE_String_Const list[], SANE_String_Const name) { - int index; + int index; - index = 0; - while (list[index] != NULL) { - if (strcmp (list[index], name) == 0) { - return (index); - } - index++; + index = 0; + while (list[index] != NULL) + { + if (strcmp (list[index], name) == 0) + { + return (index); } + index++; + } - DBG (DBG_error, "name %s not found in list\n", name); + DBG (DBG_error, "name %s not found in list\n", name); - assert (0 == 1); /* bug in backend, core dump */ + assert (0 == 1); /* bug in backend, core dump */ - return (-1); + return (-1); } /* Initialize a scanner entry. Return an allocated scanner with some @@ -227,680 +236,709 @@ get_string_list_index (SANE_String_Const list[], SANE_String_Const name) static Leo_Scanner * leo_init (void) { - Leo_Scanner *dev; + Leo_Scanner *dev; - DBG (DBG_proc, "leo_init: enter\n"); + DBG (DBG_proc, "leo_init: enter\n"); - /* Allocate a new scanner entry. */ - dev = malloc (sizeof (Leo_Scanner)); - if (dev == NULL) { - return NULL; - } + /* Allocate a new scanner entry. */ + dev = malloc (sizeof (Leo_Scanner)); + if (dev == NULL) + { + return NULL; + } - memset (dev, 0, sizeof (Leo_Scanner)); + memset (dev, 0, sizeof (Leo_Scanner)); - /* Allocate the buffer used to transfer the SCSI data. */ - dev->buffer_size = 64 * 1024; - dev->buffer = malloc (dev->buffer_size); - if (dev->buffer == NULL) { - free (dev); - return NULL; - } + /* Allocate the buffer used to transfer the SCSI data. */ + dev->buffer_size = 64 * 1024; + dev->buffer = malloc (dev->buffer_size); + if (dev->buffer == NULL) + { + free (dev); + return NULL; + } - /* Allocate a buffer to store the temporary image. */ - dev->image_size = 64 * 1024; /* enough for 1 line at max res */ - dev->image = malloc (dev->image_size); - if (dev->image == NULL) { - free (dev->buffer); - free (dev); - return NULL; - } + /* Allocate a buffer to store the temporary image. */ + dev->image_size = 64 * 1024; /* enough for 1 line at max res */ + dev->image = malloc (dev->image_size); + if (dev->image == NULL) + { + free (dev->buffer); + free (dev); + return NULL; + } - dev->sfd = -1; + dev->sfd = -1; - DBG (DBG_proc, "leo_init: exit\n"); + DBG (DBG_proc, "leo_init: exit\n"); - return (dev); + return (dev); } /* Closes an open scanner. */ static void leo_close (Leo_Scanner * dev) { - DBG (DBG_proc, "leo_close: enter\n"); + DBG (DBG_proc, "leo_close: enter\n"); - if (dev->sfd != -1) { - sanei_scsi_close (dev->sfd); - dev->sfd = -1; - } + if (dev->sfd != -1) + { + sanei_scsi_close (dev->sfd); + dev->sfd = -1; + } - DBG (DBG_proc, "leo_close: exit\n"); + DBG (DBG_proc, "leo_close: exit\n"); } /* Frees the memory used by a scanner. */ static void leo_free (Leo_Scanner * dev) { - int i; + int i; - DBG (DBG_proc, "leo_free: enter\n"); + DBG (DBG_proc, "leo_free: enter\n"); - if (dev == NULL) - return; + if (dev == NULL) + return; - leo_close (dev); - if (dev->devicename) { - free (dev->devicename); - } - if (dev->buffer) { - free (dev->buffer); - } - if (dev->image) { - free (dev->image); + leo_close (dev); + if (dev->devicename) + { + free (dev->devicename); + } + if (dev->buffer) + { + free (dev->buffer); + } + if (dev->image) + { + free (dev->image); + } + + for (i = 1; i < OPT_NUM_OPTIONS; i++) + { + if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s) + { + free (dev->val[i].s); } + } - for (i = 1; i < OPT_NUM_OPTIONS; i++) { - if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s) { - free (dev->val[i].s); - } - } + free (dev); - free (dev); - - DBG (DBG_proc, "leo_free: exit\n"); + DBG (DBG_proc, "leo_free: exit\n"); } /* Inquiry a device and returns TRUE if is supported. */ static int leo_identify_scanner (Leo_Scanner * dev) { - CDB cdb; - SANE_Status status; - size_t size; - int i; + CDB cdb; + SANE_Status status; + size_t size; + int i; - DBG (DBG_proc, "leo_identify_scanner: enter\n"); + DBG (DBG_proc, "leo_identify_scanner: enter\n"); - size = 5; - MKSCSI_INQUIRY (cdb, size); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, dev->buffer, &size); + size = 5; + MKSCSI_INQUIRY (cdb, size); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, dev->buffer, &size); - if (status) { - DBG (DBG_error, - "leo_identify_scanner: inquiry failed with status %s\n", - sane_strstatus (status)); - return (SANE_FALSE); + if (status) + { + DBG (DBG_error, + "leo_identify_scanner: inquiry failed with status %s\n", + sane_strstatus (status)); + return (SANE_FALSE); + } + + size = dev->buffer[4] + 5; /* total length of the inquiry data */ + + if (size < 36) + { + DBG (DBG_error, + "leo_identify_scanner: not enough data to identify device\n"); + return (SANE_FALSE); + } + + MKSCSI_INQUIRY (cdb, size); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, dev->buffer, &size); + + if (status) + { + DBG (DBG_error, + "leo_identify_scanner: inquiry failed with status %s\n", + sane_strstatus (status)); + return (SANE_FALSE); + } + + dev->scsi_type = dev->buffer[0] & 0x1f; + strncpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08); + dev->scsi_vendor[0x08] = 0; + strncpy (dev->scsi_product, dev->buffer + 0x10, 0x010); + dev->scsi_product[0x10] = 0; + strncpy (dev->scsi_version, dev->buffer + 0x20, 0x04); + dev->scsi_version[0x04] = 0; + + DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n", + dev->scsi_vendor, dev->scsi_product, dev->scsi_version); + + /* Lookup through the supported scanners table to find if this + * backend supports that one. */ + for (i = 0; i < NELEMS (scanners); i++) + { + if (dev->scsi_type == scanners[i].scsi_type && + strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 && + strcmp (dev->scsi_product, scanners[i].scsi_product) == 0) + { + + DBG (DBG_error, "leo_identify_scanner: scanner supported\n"); + + /* Get the full inquiry, since that scanner does not fill + the length correctly. */ + size = 0x30; + MKSCSI_INQUIRY (cdb, size); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, dev->buffer, &size); + if (status != SANE_STATUS_GOOD) + { + return (SANE_FALSE); + } + + hexdump (DBG_info2, "inquiry", dev->buffer, size); + + dev->def = &(scanners[i]); + dev->res_range.min = 1; + dev->res_range.max = B16TOI (&dev->buffer[42]); + + dev->x_resolution_max = B16TOI (&dev->buffer[40]); + dev->y_resolution_max = B16TOI (&dev->buffer[42]); + + + return (SANE_TRUE); } + } - size = dev->buffer[4] + 5; /* total length of the inquiry data */ + DBG (DBG_proc, "leo_identify_scanner: exit, device not supported\n"); - if (size < 36) { - DBG (DBG_error, - "leo_identify_scanner: not enough data to identify device\n"); - return (SANE_FALSE); - } - - MKSCSI_INQUIRY (cdb, size); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, dev->buffer, &size); - - if (status) { - DBG (DBG_error, - "leo_identify_scanner: inquiry failed with status %s\n", - sane_strstatus (status)); - return (SANE_FALSE); - } - - dev->scsi_type = dev->buffer[0] & 0x1f; - strncpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08); - dev->scsi_vendor[0x08] = 0; - strncpy (dev->scsi_product, dev->buffer + 0x10, 0x010); - dev->scsi_product[0x10] = 0; - strncpy (dev->scsi_version, dev->buffer + 0x20, 0x04); - dev->scsi_version[0x04] = 0; - - DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n", - dev->scsi_vendor, dev->scsi_product, dev->scsi_version); - - /* Lookup through the supported scanners table to find if this - * backend supports that one. */ - for (i = 0; i < NELEMS (scanners); i++) { - if (dev->scsi_type == scanners[i].scsi_type && - strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 && - strcmp (dev->scsi_product, scanners[i].scsi_product) == 0) { - - DBG (DBG_error, "leo_identify_scanner: scanner supported\n"); - - /* Get the full inquiry, since that scanner does not fill - the length correctly. */ - size = 0x30; - MKSCSI_INQUIRY (cdb, size); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, dev->buffer, &size); - if (status != SANE_STATUS_GOOD) { - return (SANE_FALSE); - } - - hexdump (DBG_info2, "inquiry", dev->buffer, size); - - dev->def = &(scanners[i]); - dev->res_range.min = 1; - dev->res_range.max = B16TOI (&dev->buffer[42]); - - dev->x_resolution_max = B16TOI (&dev->buffer[40]); - dev->y_resolution_max = B16TOI (&dev->buffer[42]); - - - return (SANE_TRUE); - } - } - - DBG (DBG_proc, "leo_identify_scanner: exit, device not supported\n"); - - return (SANE_FALSE); + return (SANE_FALSE); } /* SCSI sense handler. Callback for SANE. */ static SANE_Status leo_sense_handler (int scsi_fd, unsigned char *result, void *arg) { - int asc, ascq, sensekey; - int len; + int asc, ascq, sensekey; + int len; - DBG (DBG_proc, "leo_sense_handler (scsi_fd = %d)\n", scsi_fd); + DBG (DBG_proc, "leo_sense_handler (scsi_fd = %d)\n", scsi_fd); - arg = arg; /* silence gcc */ + arg = arg; /* silence gcc */ - sensekey = get_RS_sense_key (result); - len = 7 + get_RS_additional_length (result); + sensekey = get_RS_sense_key (result); + len = 7 + get_RS_additional_length (result); - hexdump (DBG_info2, "sense", result, len); + hexdump (DBG_info2, "sense", result, len); - if (get_RS_error_code (result) != 0x70) { - DBG (DBG_error, - "leo_sense_handler: invalid sense key error code (%d)\n", - get_RS_error_code (result)); + if (get_RS_error_code (result) != 0x70) + { + DBG (DBG_error, + "leo_sense_handler: invalid sense key error code (%d)\n", + get_RS_error_code (result)); - return SANE_STATUS_IO_ERROR; - } + return SANE_STATUS_IO_ERROR; + } - if (get_RS_ILI (result) != 0) { - DBG (DBG_sense, "leo_sense_handler: short read\n"); - } + if (get_RS_ILI (result) != 0) + { + DBG (DBG_sense, "leo_sense_handler: short read\n"); + } - if (len < 14) { - DBG (DBG_error, "leo_sense_handler: sense too short, no ASC/ASCQ\n"); + if (len < 14) + { + DBG (DBG_error, "leo_sense_handler: sense too short, no ASC/ASCQ\n"); - return SANE_STATUS_IO_ERROR; - } + return SANE_STATUS_IO_ERROR; + } - asc = get_RS_ASC (result); - ascq = get_RS_ASCQ (result); + asc = get_RS_ASC (result); + ascq = get_RS_ASCQ (result); - DBG (DBG_sense, "leo_sense_handler: sense=%d, ASC/ASCQ=%02x%02x\n", - sensekey, asc, ascq); + DBG (DBG_sense, "leo_sense_handler: sense=%d, ASC/ASCQ=%02x%02x\n", + sensekey, asc, ascq); - switch (sensekey) { - case 0x00: /* no sense */ - case 0x02: /* not ready */ - case 0x03: /* medium error */ - case 0x05: - case 0x06: - break; - } + switch (sensekey) + { + case 0x00: /* no sense */ + case 0x02: /* not ready */ + case 0x03: /* medium error */ + case 0x05: + case 0x06: + break; + } - DBG (DBG_sense, - "leo_sense_handler: unknown error condition. Please report it to the backend maintainer\n"); + DBG (DBG_sense, + "leo_sense_handler: unknown error condition. Please report it to the backend maintainer\n"); - return SANE_STATUS_IO_ERROR; + return SANE_STATUS_IO_ERROR; } /* Set a window. */ static SANE_Status leo_set_window (Leo_Scanner * dev) { - size_t size; - CDB cdb; - unsigned char window[48]; - SANE_Status status; + size_t size; + CDB cdb; + unsigned char window[48]; + SANE_Status status; - DBG (DBG_proc, "leo_set_window: enter\n"); + DBG (DBG_proc, "leo_set_window: enter\n"); - size = sizeof (window); - MKSCSI_SET_WINDOW (cdb, size); + size = sizeof (window); + MKSCSI_SET_WINDOW (cdb, size); - memset (window, 0, size); + memset (window, 0, size); - /* size of the windows descriptor block */ - window[7] = sizeof (window) - 8; - window[1] = sizeof (window) - 2; + /* size of the windows descriptor block */ + window[7] = sizeof (window) - 8; + window[1] = sizeof (window) - 2; - /* X and Y resolution */ - Ito16 (dev->x_resolution, &window[10]); - Ito16 (dev->y_resolution, &window[12]); + /* X and Y resolution */ + Ito16 (dev->x_resolution, &window[10]); + Ito16 (dev->y_resolution, &window[12]); - /* Upper Left (X,Y) */ - Ito32 (dev->x_tl, &window[14]); - Ito32 (dev->y_tl, &window[18]); + /* Upper Left (X,Y) */ + Ito32 (dev->x_tl, &window[14]); + Ito32 (dev->y_tl, &window[18]); - /* Width and length */ - Ito32 (dev->width, &window[22]); - Ito32 (dev->length, &window[26]); + /* Width and length */ + Ito32 (dev->width, &window[22]); + Ito32 (dev->length, &window[26]); - /* Image Composition */ - switch (dev->scan_mode) { - case LEO_BW: - window[33] = 0x00; - break; - case LEO_HALFTONE: - window[33] = 0x01; - break; - case LEO_GRAYSCALE: - window[33] = 0x02; - break; - case LEO_COLOR: - window[33] = 0x05; - break; - } + /* Image Composition */ + switch (dev->scan_mode) + { + case LEO_BW: + window[33] = 0x00; + break; + case LEO_HALFTONE: + window[33] = 0x01; + break; + case LEO_GRAYSCALE: + window[33] = 0x02; + break; + case LEO_COLOR: + window[33] = 0x05; + break; + } - /* Depth */ - window[34] = dev->depth; + /* Depth */ + window[34] = dev->depth; - /* Unknown - invariants */ - window[31] = 0x80; - window[43] = 0x01; + /* Unknown - invariants */ + window[31] = 0x80; + window[43] = 0x01; - hexdump (DBG_info2, "windows", window, sizeof (window)); + hexdump (DBG_info2, "windows", window, sizeof (window)); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - window, sizeof (window), NULL, NULL); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + window, sizeof (window), NULL, NULL); - DBG (DBG_proc, "leo_set_window: exit, status=%d\n", status); + DBG (DBG_proc, "leo_set_window: exit, status=%d\n", status); - return status; + return status; } /* Read the size of the scan. */ static SANE_Status leo_get_scan_size (Leo_Scanner * dev) { - size_t size; - CDB cdb; - SANE_Status status; + size_t size; + CDB cdb; + SANE_Status status; - DBG (DBG_proc, "leo_get_scan_size: enter\n"); + DBG (DBG_proc, "leo_get_scan_size: enter\n"); - size = 0x10; - MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size); - hexdump (DBG_info2, "CDB:", cdb.data, cdb.len); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, dev->buffer, &size); + size = 0x10; + MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size); + hexdump (DBG_info2, "CDB:", cdb.data, cdb.len); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, dev->buffer, &size); - if (size != 0x10) { - DBG (DBG_error, - "leo_get_scan_size: GET DATA BUFFER STATUS returned an invalid size (%d)\n", - size); - return SANE_STATUS_IO_ERROR; - } + if (size != 0x10) + { + DBG (DBG_error, + "leo_get_scan_size: GET DATA BUFFER STATUS returned an invalid size (%d)\n", + size); + return SANE_STATUS_IO_ERROR; + } - hexdump (DBG_info2, "leo_get_scan_size return", dev->buffer, size); + hexdump (DBG_info2, "leo_get_scan_size return", dev->buffer, size); - dev->params.pixels_per_line = B16TOI (&dev->buffer[14]); + dev->params.pixels_per_line = B16TOI (&dev->buffer[14]); - /* The number of lines if the number of lines left plus the number - * of lines already waiting in the buffer. */ - dev->params.lines = B16TOI (&dev->buffer[12]) + - (B24TOI (&dev->buffer[9]) / dev->params.bytes_per_line); + /* The number of lines if the number of lines left plus the number + * of lines already waiting in the buffer. */ + dev->params.lines = B16TOI (&dev->buffer[12]) + + (B24TOI (&dev->buffer[9]) / dev->params.bytes_per_line); - switch (dev->scan_mode) { - case LEO_BW: - case LEO_HALFTONE: - dev->params.pixels_per_line &= ~0x7; - dev->params.bytes_per_line = dev->params.pixels_per_line / 8; - break; - case LEO_GRAYSCALE: - dev->params.bytes_per_line = dev->params.pixels_per_line; - break; - case LEO_COLOR: - dev->params.bytes_per_line = dev->params.pixels_per_line * 3; - break; - } + switch (dev->scan_mode) + { + case LEO_BW: + case LEO_HALFTONE: + dev->params.pixels_per_line &= ~0x7; + dev->params.bytes_per_line = dev->params.pixels_per_line / 8; + break; + case LEO_GRAYSCALE: + dev->params.bytes_per_line = dev->params.pixels_per_line; + break; + case LEO_COLOR: + dev->params.bytes_per_line = dev->params.pixels_per_line * 3; + break; + } - DBG (DBG_proc, "leo_get_scan_size: exit, status=%d\n", status); + DBG (DBG_proc, "leo_get_scan_size: exit, status=%d\n", status); - DBG (DBG_proc, "lines=%d, bpl=%d\n", dev->params.lines, - dev->params.bytes_per_line); + DBG (DBG_proc, "lines=%d, bpl=%d\n", dev->params.lines, + dev->params.bytes_per_line); - return (status); + return (status); } /* Return the number of byte that can be read. */ static SANE_Status get_filled_data_length (Leo_Scanner * dev, size_t * to_read) { - size_t size; - CDB cdb; - SANE_Status status; + size_t size; + CDB cdb; + SANE_Status status; - DBG (DBG_proc, "get_filled_data_length: enter\n"); + DBG (DBG_proc, "get_filled_data_length: enter\n"); - *to_read = 0; + *to_read = 0; - size = 0x10; - MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, dev->buffer, &size); + size = 0x10; + MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, dev->buffer, &size); - if (size != 0x10) { - DBG (DBG_error, - "get_filled_data_length: GET DATA BUFFER STATUS returned an invalid size (%d)\n", - size); - return SANE_STATUS_IO_ERROR; - } + if (size != 0x10) + { + DBG (DBG_error, + "get_filled_data_length: GET DATA BUFFER STATUS returned an invalid size (%d)\n", + size); + return SANE_STATUS_IO_ERROR; + } - hexdump (DBG_info2, "get_filled_data_length return", dev->buffer, size); + hexdump (DBG_info2, "get_filled_data_length return", dev->buffer, size); - *to_read = B24TOI (&dev->buffer[9]); + *to_read = B24TOI (&dev->buffer[9]); - DBG (DBG_info, "get_filled_data_length: to read = %ld\n", - (long) *to_read); + DBG (DBG_info, "get_filled_data_length: to read = %ld\n", (long) *to_read); - DBG (DBG_proc, "get_filled_data_length: exit, status=%d\n", status); + DBG (DBG_proc, "get_filled_data_length: exit, status=%d\n", status); - return (status); + return (status); } /* Start a scan. */ static SANE_Status leo_scan (Leo_Scanner * dev) { - CDB cdb; - SANE_Status status; + CDB cdb; + SANE_Status status; - DBG (DBG_proc, "leo_scan: enter\n"); + DBG (DBG_proc, "leo_scan: enter\n"); - MKSCSI_SCAN (cdb); + MKSCSI_SCAN (cdb); - status = - sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL); - DBG (DBG_proc, "leo_scan: exit, status=%d\n", status); + DBG (DBG_proc, "leo_scan: exit, status=%d\n", status); - return status; + return status; } /* Attach a scanner to this backend. */ static SANE_Status attach_scanner (const char *devicename, Leo_Scanner ** devp) { - Leo_Scanner *dev; - int sfd; + Leo_Scanner *dev; + int sfd; - DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename); + DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename); - if (devp) - *devp = NULL; + if (devp) + *devp = NULL; - /* Check if we know this device name. */ - for (dev = first_dev; dev; dev = dev->next) { - if (strcmp (dev->sane.name, devicename) == 0) { - if (devp) { - *devp = dev; - } - DBG (DBG_info, "device is already known\n"); - return SANE_STATUS_GOOD; - } + /* Check if we know this device name. */ + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devicename) == 0) + { + if (devp) + { + *devp = dev; + } + DBG (DBG_info, "device is already known\n"); + return SANE_STATUS_GOOD; } + } - /* Allocate a new scanner entry. */ - dev = leo_init (); - if (dev == NULL) { - DBG (DBG_error, "ERROR: not enough memory\n"); - return SANE_STATUS_NO_MEM; - } + /* Allocate a new scanner entry. */ + dev = leo_init (); + if (dev == NULL) + { + DBG (DBG_error, "ERROR: not enough memory\n"); + return SANE_STATUS_NO_MEM; + } - DBG (DBG_info, "attach_scanner: opening %s\n", devicename); + DBG (DBG_info, "attach_scanner: opening %s\n", devicename); - if (sanei_scsi_open (devicename, &sfd, leo_sense_handler, dev) != 0) { - DBG (DBG_error, "ERROR: attach_scanner: open failed\n"); - leo_free (dev); - return SANE_STATUS_INVAL; - } + if (sanei_scsi_open (devicename, &sfd, leo_sense_handler, dev) != 0) + { + DBG (DBG_error, "ERROR: attach_scanner: open failed\n"); + leo_free (dev); + return SANE_STATUS_INVAL; + } - /* Fill some scanner specific values. */ - dev->devicename = strdup (devicename); - dev->sfd = sfd; + /* Fill some scanner specific values. */ + dev->devicename = strdup (devicename); + dev->sfd = sfd; - /* Now, check that it is a scanner we support. */ - if (leo_identify_scanner (dev) == SANE_FALSE) { - DBG (DBG_error, - "ERROR: attach_scanner: scanner-identification failed\n"); - leo_free (dev); - return SANE_STATUS_INVAL; - } + /* Now, check that it is a scanner we support. */ + if (leo_identify_scanner (dev) == SANE_FALSE) + { + DBG (DBG_error, + "ERROR: attach_scanner: scanner-identification failed\n"); + leo_free (dev); + return SANE_STATUS_INVAL; + } - leo_close (dev); + leo_close (dev); - /* Set the default options for that scanner. */ - dev->sane.name = dev->devicename; - dev->sane.vendor = dev->def->real_vendor; - dev->sane.model = dev->def->real_product; - dev->sane.type = "flatbed scanner"; + /* Set the default options for that scanner. */ + dev->sane.name = dev->devicename; + dev->sane.vendor = dev->def->real_vendor; + dev->sane.model = dev->def->real_product; + dev->sane.type = "flatbed scanner"; - /* Link the scanner with the others. */ - dev->next = first_dev; - first_dev = dev; + /* Link the scanner with the others. */ + dev->next = first_dev; + first_dev = dev; - if (devp) { - *devp = dev; - } + if (devp) + { + *devp = dev; + } - num_devices++; + num_devices++; - DBG (DBG_proc, "attach_scanner: exit\n"); + DBG (DBG_proc, "attach_scanner: exit\n"); - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } static SANE_Status attach_one (const char *dev) { - attach_scanner (dev, NULL); - return SANE_STATUS_GOOD; + attach_scanner (dev, NULL); + return SANE_STATUS_GOOD; } /* Reset the options for that scanner. */ static void leo_init_options (Leo_Scanner * dev) { - int i; + int i; - /* Pre-initialize the options. */ - memset (dev->opt, 0, sizeof (dev->opt)); - memset (dev->val, 0, sizeof (dev->val)); + /* Pre-initialize the options. */ + memset (dev->opt, 0, sizeof (dev->opt)); + memset (dev->val, 0, sizeof (dev->val)); - for (i = 0; i < OPT_NUM_OPTIONS; ++i) { - dev->opt[i].size = sizeof (SANE_Word); - dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; - } + for (i = 0; i < OPT_NUM_OPTIONS; ++i) + { + dev->opt[i].size = sizeof (SANE_Word); + dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } - /* Number of options. */ - dev->opt[OPT_NUM_OPTS].name = ""; - dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; - dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; - dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; - dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; - dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS; + /* Number of options. */ + dev->opt[OPT_NUM_OPTS].name = ""; + dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; + dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS; - /* Mode group */ - dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan mode"); - dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ - dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; - dev->opt[OPT_MODE_GROUP].cap = 0; - dev->opt[OPT_MODE_GROUP].size = 0; - dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + /* Mode group */ + dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan mode"); + dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_MODE_GROUP].cap = 0; + dev->opt[OPT_MODE_GROUP].size = 0; + dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - /* Scanner supported modes */ - dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; - dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; - dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; - dev->opt[OPT_MODE].type = SANE_TYPE_STRING; - dev->opt[OPT_MODE].size = max_string_size (scan_mode_list); - dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_MODE].constraint.string_list = scan_mode_list; - dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */ + /* Scanner supported modes */ + dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; + dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + dev->opt[OPT_MODE].type = SANE_TYPE_STRING; + dev->opt[OPT_MODE].size = max_string_size (scan_mode_list); + dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_MODE].constraint.string_list = scan_mode_list; + dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */ - /* X and Y resolution */ - dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; - dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; - dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_RESOLUTION].constraint.range = &dev->res_range; - dev->val[OPT_RESOLUTION].w = dev->res_range.max / 2; + /* X and Y resolution */ + dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; + dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_RESOLUTION].constraint.range = &dev->res_range; + dev->val[OPT_RESOLUTION].w = dev->res_range.max / 2; - /* Halftone pattern */ - dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; - dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; - dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; - dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; - dev->opt[OPT_HALFTONE_PATTERN].size = - max_string_size (halftone_pattern_list); - dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_HALFTONE_PATTERN].constraint_type = - SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list = - halftone_pattern_list; - dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]); + /* Halftone pattern */ + dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; + dev->opt[OPT_HALFTONE_PATTERN].size = + max_string_size (halftone_pattern_list); + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_HALFTONE_PATTERN].constraint_type = + SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list = + halftone_pattern_list; + dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]); - /* Geometry group */ - dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); - dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */ - dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; - dev->opt[OPT_GEOMETRY_GROUP].cap = 0; - dev->opt[OPT_GEOMETRY_GROUP].size = 0; - dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + /* Geometry group */ + dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); + dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_GEOMETRY_GROUP].cap = 0; + dev->opt[OPT_GEOMETRY_GROUP].size = 0; + dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - /* Upper left X */ - dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; - dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; - dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; - dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED; - dev->opt[OPT_TL_X].unit = SANE_UNIT_MM; - dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_TL_X].constraint.range = &x_range; - dev->val[OPT_TL_X].w = x_range.min; + /* Upper left X */ + dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; + dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; + dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; + dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED; + dev->opt[OPT_TL_X].unit = SANE_UNIT_MM; + dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_TL_X].constraint.range = &x_range; + dev->val[OPT_TL_X].w = x_range.min; - /* Upper left Y */ - dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; - dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; - dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; - dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; - dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM; - dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_TL_Y].constraint.range = &y_range; - dev->val[OPT_TL_Y].w = y_range.min; + /* Upper left Y */ + dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; + dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; + dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_TL_Y].constraint.range = &y_range; + dev->val[OPT_TL_Y].w = y_range.min; - /* Bottom-right x */ - dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; - dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; - dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; - dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED; - dev->opt[OPT_BR_X].unit = SANE_UNIT_MM; - dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_BR_X].constraint.range = &x_range; - dev->val[OPT_BR_X].w = x_range.max; + /* Bottom-right x */ + dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; + dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; + dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; + dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED; + dev->opt[OPT_BR_X].unit = SANE_UNIT_MM; + dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BR_X].constraint.range = &x_range; + dev->val[OPT_BR_X].w = x_range.max; - /* Bottom-right y */ - dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; - dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; - dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; - dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; - dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM; - dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_BR_Y].constraint.range = &y_range; - dev->val[OPT_BR_Y].w = y_range.max; + /* Bottom-right y */ + dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; + dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; + dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BR_Y].constraint.range = &y_range; + dev->val[OPT_BR_Y].w = y_range.max; - /* Enhancement group */ - dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); - dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ - dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; - dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; - dev->opt[OPT_ENHANCEMENT_GROUP].size = 0; - dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + /* Enhancement group */ + dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); + dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; + dev->opt[OPT_ENHANCEMENT_GROUP].size = 0; + dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - /* custom-gamma table */ - dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA; - dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA; - dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA; - dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL; - dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; - dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE; + /* custom-gamma table */ + dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA; + dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA; + dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA; + dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL; + dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE; - /* red gamma vector */ - dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; - dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; - dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; - dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT; - dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE; - dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word); - dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range; - dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R; + /* red gamma vector */ + dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; + dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; + dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; + dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT; + dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE; + dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word); + dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range; + dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R; - /* green gamma vector */ - dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; - dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; - dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; - dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT; - dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE; - dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word); - dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range; - dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G; + /* green gamma vector */ + dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; + dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; + dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; + dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT; + dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE; + dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word); + dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range; + dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G; - /* blue gamma vector */ - dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; - dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; - dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; - dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT; - dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE; - dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word); - dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range; - dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B; + /* blue gamma vector */ + dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; + dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; + dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; + dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT; + dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE; + dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word); + dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range; + dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B; - /* grayscale gamma vector */ - dev->opt[OPT_GAMMA_VECTOR_GRAY].name = SANE_NAME_GAMMA_VECTOR; - dev->opt[OPT_GAMMA_VECTOR_GRAY].title = SANE_TITLE_GAMMA_VECTOR; - dev->opt[OPT_GAMMA_VECTOR_GRAY].desc = SANE_DESC_GAMMA_VECTOR; - dev->opt[OPT_GAMMA_VECTOR_GRAY].type = SANE_TYPE_INT; - dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_GRAY].unit = SANE_UNIT_NONE; - dev->opt[OPT_GAMMA_VECTOR_GRAY].size = GAMMA_LENGTH * sizeof (SANE_Word); - dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint.range = &gamma_range; - dev->val[OPT_GAMMA_VECTOR_GRAY].wa = dev->gamma_GRAY; + /* grayscale gamma vector */ + dev->opt[OPT_GAMMA_VECTOR_GRAY].name = SANE_NAME_GAMMA_VECTOR; + dev->opt[OPT_GAMMA_VECTOR_GRAY].title = SANE_TITLE_GAMMA_VECTOR; + dev->opt[OPT_GAMMA_VECTOR_GRAY].desc = SANE_DESC_GAMMA_VECTOR; + dev->opt[OPT_GAMMA_VECTOR_GRAY].type = SANE_TYPE_INT; + dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_GRAY].unit = SANE_UNIT_NONE; + dev->opt[OPT_GAMMA_VECTOR_GRAY].size = GAMMA_LENGTH * sizeof (SANE_Word); + dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint.range = &gamma_range; + dev->val[OPT_GAMMA_VECTOR_GRAY].wa = dev->gamma_GRAY; - /* preview */ - dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; - dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; - dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; - dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; - dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; - dev->val[OPT_PREVIEW].w = SANE_FALSE; + /* preview */ + dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; + dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; + dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; + dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; + dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; + dev->val[OPT_PREVIEW].w = SANE_FALSE; - /* Lastly, set the default scan mode. This might change some - * values previously set here. */ - sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, - (SANE_String_Const *) scan_mode_list[0], NULL); + /* Lastly, set the default scan mode. This might change some + * values previously set here. */ + sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, + (SANE_String_Const *) scan_mode_list[0], NULL); } /* @@ -909,137 +947,146 @@ leo_init_options (Leo_Scanner * dev) static SANE_Status leo_wait_scanner (Leo_Scanner * dev) { - SANE_Status status; - int timeout; - CDB cdb; + SANE_Status status; + int timeout; + CDB cdb; - DBG (DBG_proc, "leo_wait_scanner: enter\n"); + DBG (DBG_proc, "leo_wait_scanner: enter\n"); - MKSCSI_TEST_UNIT_READY (cdb); + MKSCSI_TEST_UNIT_READY (cdb); - /* Set the timeout to 60 seconds. */ - timeout = 60; + /* Set the timeout to 60 seconds. */ + timeout = 60; - while (timeout > 0) { + while (timeout > 0) + { - /* test unit ready */ - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, NULL, NULL); + /* test unit ready */ + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, NULL, NULL); - if (status == SANE_STATUS_GOOD) { - return SANE_STATUS_GOOD; - } + if (status == SANE_STATUS_GOOD) + { + return SANE_STATUS_GOOD; + } - sleep (1); - }; + sleep (1); + }; - DBG (DBG_proc, "leo_wait_scanner: scanner not ready\n"); - return (SANE_STATUS_IO_ERROR); + DBG (DBG_proc, "leo_wait_scanner: scanner not ready\n"); + return (SANE_STATUS_IO_ERROR); } /* Read the image from the scanner and fill the temporary buffer with it. */ static SANE_Status leo_fill_image (Leo_Scanner * dev) { - SANE_Status status; - size_t size; - CDB cdb; - unsigned char *image; + SANE_Status status; + size_t size; + CDB cdb; + unsigned char *image; - DBG (DBG_proc, "leo_fill_image: enter\n"); + DBG (DBG_proc, "leo_fill_image: enter\n"); - assert (dev->image_begin == dev->image_end); - assert (dev->real_bytes_left > 0); + assert (dev->image_begin == dev->image_end); + assert (dev->real_bytes_left > 0); - dev->image_begin = 0; - dev->image_end = 0; + dev->image_begin = 0; + dev->image_end = 0; - while (dev->real_bytes_left) { - /* - * Try to read the maximum number of bytes. - */ - size = 0; - while (size == 0) { - status = get_filled_data_length (dev, &size); - if (status) - return (status); - if (size == 0) - usleep (100000); /* sleep 1/10th of second */ - } - - if (size > dev->real_bytes_left) - size = dev->real_bytes_left; - if (size > dev->image_size - dev->image_end) - size = dev->image_size - dev->image_end; - - /* The scanner seems to hang if more than 32KB are read. */ - if (size > 0x7fff) - size = 0x7fff; - - /* Always read a multiple of a line. */ - size = size - (size % dev->params.bytes_per_line); - - if (size == 0) { - /* Probably reached the end of the buffer. - * Check, just in case. */ - assert (dev->image_end != 0); - return (SANE_STATUS_GOOD); - } - - DBG (DBG_info, "leo_fill_image: to read = %ld bytes (bpl=%d)\n", - (long) size, dev->params.bytes_per_line); - - MKSCSI_READ_10 (cdb, 0, 0, size); - - hexdump (DBG_info2, "leo_fill_image: READ_10 CDB", cdb.data, 10); - - image = dev->image + dev->image_end; - - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - NULL, 0, image, &size); - - if (status != SANE_STATUS_GOOD) { - DBG (DBG_error, "leo_fill_image: cannot read from the scanner\n"); - return status; - } - - /* Some format conversion. */ - if (dev->scan_mode == LEO_COLOR) { - - /* Reorder the lines. The scanner gives color by color for - * each line. */ - unsigned char *src = image; - int nb_lines = size / dev->params.bytes_per_line; - int i, j; - - for (i = 0; i < nb_lines; i++) { - - unsigned char *dest = dev->buffer; - - for (j = 0; j < dev->params.pixels_per_line; j++) { - *dest = src[j + 0 * dev->params.pixels_per_line]; - dest++; - *dest = src[j + 1 * dev->params.pixels_per_line]; - dest++; - *dest = src[j + 2 * dev->params.pixels_per_line]; - dest++; - } - - /* Copy the line back. */ - memcpy (src, dev->buffer, dev->params.bytes_per_line); - - src += dev->params.bytes_per_line; - } - } - - dev->image_end += size; - dev->real_bytes_left -= size; - - DBG (DBG_info, "leo_fill_image: real bytes left = %d\n", - dev->real_bytes_left); + while (dev->real_bytes_left) + { + /* + * Try to read the maximum number of bytes. + */ + size = 0; + while (size == 0) + { + status = get_filled_data_length (dev, &size); + if (status) + return (status); + if (size == 0) + usleep (100000); /* sleep 1/10th of second */ } - return (SANE_STATUS_GOOD); /* unreachable */ + if (size > dev->real_bytes_left) + size = dev->real_bytes_left; + if (size > dev->image_size - dev->image_end) + size = dev->image_size - dev->image_end; + + /* The scanner seems to hang if more than 32KB are read. */ + if (size > 0x7fff) + size = 0x7fff; + + /* Always read a multiple of a line. */ + size = size - (size % dev->params.bytes_per_line); + + if (size == 0) + { + /* Probably reached the end of the buffer. + * Check, just in case. */ + assert (dev->image_end != 0); + return (SANE_STATUS_GOOD); + } + + DBG (DBG_info, "leo_fill_image: to read = %ld bytes (bpl=%d)\n", + (long) size, dev->params.bytes_per_line); + + MKSCSI_READ_10 (cdb, 0, 0, size); + + hexdump (DBG_info2, "leo_fill_image: READ_10 CDB", cdb.data, 10); + + image = dev->image + dev->image_end; + + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + NULL, 0, image, &size); + + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "leo_fill_image: cannot read from the scanner\n"); + return status; + } + + /* Some format conversion. */ + if (dev->scan_mode == LEO_COLOR) + { + + /* Reorder the lines. The scanner gives color by color for + * each line. */ + unsigned char *src = image; + int nb_lines = size / dev->params.bytes_per_line; + int i, j; + + for (i = 0; i < nb_lines; i++) + { + + unsigned char *dest = dev->buffer; + + for (j = 0; j < dev->params.pixels_per_line; j++) + { + *dest = src[j + 0 * dev->params.pixels_per_line]; + dest++; + *dest = src[j + 1 * dev->params.pixels_per_line]; + dest++; + *dest = src[j + 2 * dev->params.pixels_per_line]; + dest++; + } + + /* Copy the line back. */ + memcpy (src, dev->buffer, dev->params.bytes_per_line); + + src += dev->params.bytes_per_line; + } + } + + dev->image_end += size; + dev->real_bytes_left -= size; + + DBG (DBG_info, "leo_fill_image: real bytes left = %d\n", + dev->real_bytes_left); + } + + return (SANE_STATUS_GOOD); /* unreachable */ } /* Copy from the raw buffer to the buffer given by the backend. @@ -1050,177 +1097,188 @@ leo_fill_image (Leo_Scanner * dev) static void leo_copy_raw_to_frontend (Leo_Scanner * dev, SANE_Byte * buf, size_t * len) { - size_t size; + size_t size; - size = dev->image_end - dev->image_begin; - if (size > *len) { - size = *len; - } - *len = size; + size = dev->image_end - dev->image_begin; + if (size > *len) + { + size = *len; + } + *len = size; - memcpy (buf, dev->image + dev->image_begin, size); + memcpy (buf, dev->image + dev->image_begin, size); - dev->image_begin += size; + dev->image_begin += size; } /* Stop a scan. */ static SANE_Status do_cancel (Leo_Scanner * dev) { - DBG (DBG_sane_proc, "do_cancel enter\n"); + DBG (DBG_sane_proc, "do_cancel enter\n"); - if (dev->scanning == SANE_TRUE) { + if (dev->scanning == SANE_TRUE) + { - /* Reset the scanner */ - dev->x_tl = 0; - dev->x_tl = 0; - dev->width = 0; - dev->length = 0; - leo_set_window (dev); + /* Reset the scanner */ + dev->x_tl = 0; + dev->x_tl = 0; + dev->width = 0; + dev->length = 0; + leo_set_window (dev); - leo_scan (dev); + leo_scan (dev); - leo_close (dev); - } + leo_close (dev); + } - dev->scanning = SANE_FALSE; + dev->scanning = SANE_FALSE; - DBG (DBG_sane_proc, "do_cancel exit\n"); + DBG (DBG_sane_proc, "do_cancel exit\n"); - return SANE_STATUS_CANCELLED; + return SANE_STATUS_CANCELLED; } /* A default gamma table. */ static const SANE_Word gamma_init[GAMMA_LENGTH] = { - 0x00, 0x06, 0x0A, 0x0D, 0x10, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F, - 0x21, 0x23, 0x25, 0x27, - 0x28, 0x2A, 0x2C, 0x2D, 0x2F, 0x30, 0x32, 0x33, 0x35, 0x36, 0x38, 0x39, - 0x3A, 0x3C, 0x3D, 0x3F, - 0x40, 0x41, 0x43, 0x44, 0x45, 0x46, 0x48, 0x49, 0x4A, 0x4B, 0x4D, 0x4E, - 0x4F, 0x50, 0x51, 0x53, - 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, - 0x61, 0x62, 0x63, 0x64, - 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, - 0x72, 0x73, 0x74, 0x75, - 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7D, 0x7E, 0x7F, 0x80, - 0x81, 0x82, 0x83, 0x84, - 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, - 0x90, 0x91, 0x92, 0x92, - 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, - 0x9E, 0x9F, 0x9F, 0xA0, - 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xA9, 0xAA, - 0xAB, 0xAC, 0xAD, 0xAD, - 0xAE, 0xAF, 0xB0, 0xB1, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7, - 0xB8, 0xB9, 0xB9, 0xBA, - 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC0, 0xC1, 0xC2, 0xC3, 0xC3, - 0xC4, 0xC5, 0xC6, 0xC6, - 0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCF, 0xCF, - 0xD0, 0xD1, 0xD2, 0xD2, - 0xD3, 0xD4, 0xD5, 0xD5, 0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xDA, 0xDA, 0xDB, - 0xDC, 0xDC, 0xDD, 0xDE, - 0xDF, 0xDF, 0xE0, 0xE1, 0xE1, 0xE2, 0xE3, 0xE4, 0xE4, 0xE5, 0xE6, 0xE6, - 0xE7, 0xE8, 0xE8, 0xE9, - 0xEA, 0xEB, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF1, 0xF1, - 0xF2, 0xF3, 0xF4, 0xF4, - 0xF5, 0xF6, 0xF6, 0xF7, 0xF8, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC, 0xFC, - 0xFD, 0xFE, 0xFE, 0xFF + 0x00, 0x06, 0x0A, 0x0D, 0x10, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F, + 0x21, 0x23, 0x25, 0x27, + 0x28, 0x2A, 0x2C, 0x2D, 0x2F, 0x30, 0x32, 0x33, 0x35, 0x36, 0x38, 0x39, + 0x3A, 0x3C, 0x3D, 0x3F, + 0x40, 0x41, 0x43, 0x44, 0x45, 0x46, 0x48, 0x49, 0x4A, 0x4B, 0x4D, 0x4E, + 0x4F, 0x50, 0x51, 0x53, + 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, + 0x61, 0x62, 0x63, 0x64, + 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, + 0x72, 0x73, 0x74, 0x75, + 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7D, 0x7E, 0x7F, 0x80, + 0x81, 0x82, 0x83, 0x84, + 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x92, + 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, + 0x9E, 0x9F, 0x9F, 0xA0, + 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xA9, 0xAA, + 0xAB, 0xAC, 0xAD, 0xAD, + 0xAE, 0xAF, 0xB0, 0xB1, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7, + 0xB8, 0xB9, 0xB9, 0xBA, + 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC0, 0xC1, 0xC2, 0xC3, 0xC3, + 0xC4, 0xC5, 0xC6, 0xC6, + 0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCF, 0xCF, + 0xD0, 0xD1, 0xD2, 0xD2, + 0xD3, 0xD4, 0xD5, 0xD5, 0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xDA, 0xDA, 0xDB, + 0xDC, 0xDC, 0xDD, 0xDE, + 0xDF, 0xDF, 0xE0, 0xE1, 0xE1, 0xE2, 0xE3, 0xE4, 0xE4, 0xE5, 0xE6, 0xE6, + 0xE7, 0xE8, 0xE8, 0xE9, + 0xEA, 0xEB, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF1, 0xF1, + 0xF2, 0xF3, 0xF4, 0xF4, + 0xF5, 0xF6, 0xF6, 0xF7, 0xF8, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC, 0xFC, + 0xFD, 0xFE, 0xFE, 0xFF }; /* Send the gamma */ static SANE_Status leo_send_gamma (Leo_Scanner * dev) { - CDB cdb; - SANE_Status status; - struct + CDB cdb; + SANE_Status status; + struct + { + unsigned char gamma_R[GAMMA_LENGTH]; + unsigned char gamma_G[GAMMA_LENGTH]; /* also gray */ + unsigned char gamma_B[GAMMA_LENGTH]; + } + param; + size_t i; + size_t size; + + DBG (DBG_proc, "leo_send_gamma: enter\n"); + + size = sizeof (param); + assert (size == 3 * GAMMA_LENGTH); + MKSCSI_SEND_10 (cdb, 0x03, 0x01, size); + + if (dev->val[OPT_CUSTOM_GAMMA].w) + { + /* Use the custom gamma. */ + if (dev->scan_mode == LEO_GRAYSCALE) { - unsigned char gamma_R[GAMMA_LENGTH]; - unsigned char gamma_G[GAMMA_LENGTH]; /* also gray */ - unsigned char gamma_B[GAMMA_LENGTH]; + /* Gray */ + for (i = 0; i < GAMMA_LENGTH; i++) + { + param.gamma_R[i] = dev->gamma_GRAY[i]; + param.gamma_G[i] = 0; + param.gamma_B[i] = 0; + } } - param; - size_t i; - size_t size; - - DBG (DBG_proc, "leo_send_gamma: enter\n"); - - size = sizeof (param); - assert (size == 3 * GAMMA_LENGTH); - MKSCSI_SEND_10 (cdb, 0x03, 0x01, size); - - if (dev->val[OPT_CUSTOM_GAMMA].w) { - /* Use the custom gamma. */ - if (dev->scan_mode == LEO_GRAYSCALE) { - /* Gray */ - for (i = 0; i < GAMMA_LENGTH; i++) { - param.gamma_R[i] = dev->gamma_GRAY[i]; - param.gamma_G[i] = 0; - param.gamma_B[i] = 0; - } - } - else { - /* Color */ - for (i = 0; i < GAMMA_LENGTH; i++) { - param.gamma_R[i] = dev->gamma_R[i]; - param.gamma_G[i] = dev->gamma_G[i]; - param.gamma_B[i] = dev->gamma_B[i]; - } - } + else + { + /* Color */ + for (i = 0; i < GAMMA_LENGTH; i++) + { + param.gamma_R[i] = dev->gamma_R[i]; + param.gamma_G[i] = dev->gamma_G[i]; + param.gamma_B[i] = dev->gamma_B[i]; + } } - else { - for (i = 0; i < GAMMA_LENGTH; i++) { - param.gamma_R[i] = gamma_init[i]; - param.gamma_G[i] = gamma_init[i]; - param.gamma_B[i] = gamma_init[i]; - } + } + else + { + for (i = 0; i < GAMMA_LENGTH; i++) + { + param.gamma_R[i] = gamma_init[i]; + param.gamma_G[i] = gamma_init[i]; + param.gamma_B[i] = gamma_init[i]; } + } - hexdump (DBG_info2, "leo_send_gamma:", cdb.data, cdb.len); + hexdump (DBG_info2, "leo_send_gamma:", cdb.data, cdb.len); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - ¶m, size, NULL, NULL); + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + ¶m, size, NULL, NULL); - DBG (DBG_proc, "leo_send_gamma: exit, status=%d\n", status); + DBG (DBG_proc, "leo_send_gamma: exit, status=%d\n", status); - return (status); + return (status); } /* Send the halftone pattern */ static SANE_Status leo_send_halftone_pattern (Leo_Scanner * dev) { - int i; - const halftone_pattern_t *pattern; - SANE_Status status; - size_t size; - CDB cdb; + int i; + const halftone_pattern_t *pattern; + SANE_Status status; + size_t size; + CDB cdb; - DBG (DBG_proc, "leo_send_halftone_pattern: enter\n"); + DBG (DBG_proc, "leo_send_halftone_pattern: enter\n"); - if (dev->scan_mode == LEO_HALFTONE) { + if (dev->scan_mode == LEO_HALFTONE) + { - i = get_string_list_index (halftone_pattern_list, - dev->val[OPT_HALFTONE_PATTERN].s); - pattern = halftone_pattern_val[i]; + i = get_string_list_index (halftone_pattern_list, + dev->val[OPT_HALFTONE_PATTERN].s); + pattern = halftone_pattern_val[i]; - assert (pattern != NULL); + assert (pattern != NULL); - size = sizeof (halftone_pattern_t); - assert (size == 256); - MKSCSI_SEND_10 (cdb, 0x02, 0x0F, size); + size = sizeof (halftone_pattern_t); + assert (size == 256); + MKSCSI_SEND_10 (cdb, 0x02, 0x0F, size); - hexdump (DBG_info2, "leo_send_gamma:", cdb.data, cdb.len); + hexdump (DBG_info2, "leo_send_gamma:", cdb.data, cdb.len); - status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, - pattern, size, NULL, NULL); - } - else { - status = SANE_STATUS_GOOD; - } + status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, + pattern, size, NULL, NULL); + } + else + { + status = SANE_STATUS_GOOD; + } - DBG (DBG_proc, "leo_send_halftone_pattern: exit, status=%d\n", status); + DBG (DBG_proc, "leo_send_halftone_pattern: exit, status=%d\n", status); - return status; + return status; } /*--------------------------------------------------------------------------*/ @@ -1230,667 +1288,734 @@ leo_send_halftone_pattern (Leo_Scanner * dev) SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { - FILE *fp; - char dev_name[PATH_MAX]; - size_t len; + FILE *fp; + char dev_name[PATH_MAX]; + size_t len; - DBG_INIT (); + DBG_INIT (); - DBG (DBG_sane_init, "sane_init\n"); + DBG (DBG_sane_init, "sane_init\n"); - authorize = authorize; /* silence gcc */ + authorize = authorize; /* silence gcc */ - DBG (DBG_error, "This is sane-leo version %d.%d-%d\n", V_MAJOR, - V_MINOR, BUILD); - DBG (DBG_error, "(C) 2002 by Frank Zago\n"); + DBG (DBG_error, "This is sane-leo version %d.%d-%d\n", V_MAJOR, + V_MINOR, BUILD); + DBG (DBG_error, "(C) 2002 by Frank Zago\n"); - if (version_code) { - *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); - } + if (version_code) + { + *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); + } - fp = sanei_config_open (LEO_CONFIG_FILE); - if (!fp) { - /* default to /dev/scanner instead of insisting on config file */ - attach_scanner ("/dev/scanner", 0); - return SANE_STATUS_GOOD; - } + fp = sanei_config_open (LEO_CONFIG_FILE); + if (!fp) + { + /* default to /dev/scanner instead of insisting on config file */ + attach_scanner ("/dev/scanner", 0); + return SANE_STATUS_GOOD; + } - while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { - if (dev_name[0] == '#') /* ignore line comments */ - continue; - len = strlen (dev_name); + while (sanei_config_read (dev_name, sizeof (dev_name), fp)) + { + if (dev_name[0] == '#') /* ignore line comments */ + continue; + len = strlen (dev_name); - if (!len) - continue; /* ignore empty lines */ + if (!len) + continue; /* ignore empty lines */ - sanei_config_attach_matching_devices (dev_name, attach_one); - } + sanei_config_attach_matching_devices (dev_name, attach_one); + } - fclose (fp); + fclose (fp); - DBG (DBG_proc, "sane_init: leave\n"); + DBG (DBG_proc, "sane_init: leave\n"); - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) { - Leo_Scanner *dev; - int i; + Leo_Scanner *dev; + int i; - DBG (DBG_proc, "sane_get_devices: enter\n"); + DBG (DBG_proc, "sane_get_devices: enter\n"); - local_only = local_only; /* silence gcc */ + local_only = local_only; /* silence gcc */ - if (devlist) - free (devlist); + if (devlist) + free (devlist); - devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); - if (!devlist) - return SANE_STATUS_NO_MEM; + devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); + if (!devlist) + return SANE_STATUS_NO_MEM; - i = 0; - for (dev = first_dev; i < num_devices; dev = dev->next) - devlist[i++] = &dev->sane; - devlist[i++] = 0; + i = 0; + for (dev = first_dev; i < num_devices; dev = dev->next) + devlist[i++] = &dev->sane; + devlist[i++] = 0; - *device_list = devlist; + *device_list = devlist; - DBG (DBG_proc, "sane_get_devices: exit\n"); + DBG (DBG_proc, "sane_get_devices: exit\n"); - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } SANE_Status sane_open (SANE_String_Const devicename, SANE_Handle * handle) { - Leo_Scanner *dev; - SANE_Status status; + Leo_Scanner *dev; + SANE_Status status; - DBG (DBG_proc, "sane_open: enter\n"); + DBG (DBG_proc, "sane_open: enter\n"); - /* search for devicename */ - if (devicename[0]) { - DBG (DBG_info, "sane_open: devicename=%s\n", devicename); + /* search for devicename */ + if (devicename[0]) + { + DBG (DBG_info, "sane_open: devicename=%s\n", devicename); - for (dev = first_dev; dev; dev = dev->next) { - if (strcmp (dev->sane.name, devicename) == 0) { - break; - } - } - - if (!dev) { - status = attach_scanner (devicename, &dev); - if (status != SANE_STATUS_GOOD) { - return status; - } - } - } - else { - DBG (DBG_sane_info, - "sane_open: no devicename, opening first device\n"); - dev = first_dev; /* empty devicename -> use first device */ + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devicename) == 0) + { + break; + } } - if (!dev) { - DBG (DBG_error, "No scanner found\n"); - - return SANE_STATUS_INVAL; + if (!dev) + { + status = attach_scanner (devicename, &dev); + if (status != SANE_STATUS_GOOD) + { + return status; + } } + } + else + { + DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n"); + dev = first_dev; /* empty devicename -> use first device */ + } - leo_init_options (dev); + if (!dev) + { + DBG (DBG_error, "No scanner found\n"); - /* Initialize the gamma table. */ - memcpy (dev->gamma_R, gamma_init, dev->opt[OPT_GAMMA_VECTOR_R].size); - memcpy (dev->gamma_G, gamma_init, dev->opt[OPT_GAMMA_VECTOR_G].size); - memcpy (dev->gamma_B, gamma_init, dev->opt[OPT_GAMMA_VECTOR_B].size); - memcpy (dev->gamma_GRAY, gamma_init, - dev->opt[OPT_GAMMA_VECTOR_GRAY].size); + return SANE_STATUS_INVAL; + } - *handle = dev; + leo_init_options (dev); - DBG (DBG_proc, "sane_open: exit\n"); + /* Initialize the gamma table. */ + memcpy (dev->gamma_R, gamma_init, dev->opt[OPT_GAMMA_VECTOR_R].size); + memcpy (dev->gamma_G, gamma_init, dev->opt[OPT_GAMMA_VECTOR_G].size); + memcpy (dev->gamma_B, gamma_init, dev->opt[OPT_GAMMA_VECTOR_B].size); + memcpy (dev->gamma_GRAY, gamma_init, dev->opt[OPT_GAMMA_VECTOR_GRAY].size); - return SANE_STATUS_GOOD; + *handle = dev; + + DBG (DBG_proc, "sane_open: exit\n"); + + return SANE_STATUS_GOOD; } const SANE_Option_Descriptor * sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) { - Leo_Scanner *dev = handle; + Leo_Scanner *dev = handle; - DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option); + DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option); - if ((unsigned) option >= OPT_NUM_OPTIONS) { - return NULL; - } + if ((unsigned) option >= OPT_NUM_OPTIONS) + { + return NULL; + } - DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); + DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); - return dev->opt + option; + return dev->opt + option; } SANE_Status sane_control_option (SANE_Handle handle, SANE_Int option, - SANE_Action action, void *val, SANE_Int * info) + SANE_Action action, void *val, SANE_Int * info) { - Leo_Scanner *dev = handle; - SANE_Status status; - SANE_Word cap; - int i; + Leo_Scanner *dev = handle; + SANE_Status status; + SANE_Word cap; + int i; - DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n", - option, action); + DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n", + option, action); - if (info) { - *info = 0; + if (info) + { + *info = 0; + } + + if (dev->scanning) + { + return SANE_STATUS_DEVICE_BUSY; + } + + if (option < 0 || option >= OPT_NUM_OPTIONS) + { + return SANE_STATUS_INVAL; + } + + cap = dev->opt[option].cap; + if (!SANE_OPTION_IS_ACTIVE (cap)) + { + return SANE_STATUS_INVAL; + } + + if (action == SANE_ACTION_GET_VALUE) + { + + switch (option) + { + /* word options */ + case OPT_NUM_OPTS: + case OPT_RESOLUTION: + case OPT_TL_Y: + case OPT_BR_Y: + case OPT_TL_X: + case OPT_BR_X: + case OPT_CUSTOM_GAMMA: + case OPT_PREVIEW: + *(SANE_Word *) val = dev->val[option].w; + return SANE_STATUS_GOOD; + + /* string options */ + case OPT_MODE: + case OPT_HALFTONE_PATTERN: + strcpy (val, dev->val[option].s); + return SANE_STATUS_GOOD; + + /* Gamma */ + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + case OPT_GAMMA_VECTOR_GRAY: + memcpy (val, dev->val[option].wa, dev->opt[option].size); + return SANE_STATUS_GOOD; + + default: + return SANE_STATUS_INVAL; + } + } + else if (action == SANE_ACTION_SET_VALUE) + { + + if (!SANE_OPTION_IS_SETTABLE (cap)) + { + DBG (DBG_error, "could not set option, not settable\n"); + return SANE_STATUS_INVAL; } - if (dev->scanning) { - return SANE_STATUS_DEVICE_BUSY; + status = sanei_constrain_value (dev->opt + option, val, info); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "could not set option, invalid value\n"); + return status; } - if (option < 0 || option >= OPT_NUM_OPTIONS) { - return SANE_STATUS_INVAL; - } + switch (option) + { - cap = dev->opt[option].cap; - if (!SANE_OPTION_IS_ACTIVE (cap)) { - return SANE_STATUS_INVAL; - } + /* Numeric side-effect options */ + case OPT_TL_Y: + case OPT_BR_Y: + case OPT_TL_X: + case OPT_BR_X: + case OPT_RESOLUTION: + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + dev->val[option].w = *(SANE_Word *) val; + return SANE_STATUS_GOOD; - if (action == SANE_ACTION_GET_VALUE) { + /* Numeric side-effect free options */ + case OPT_PREVIEW: + dev->val[option].w = *(SANE_Word *) val; + return SANE_STATUS_GOOD; - switch (option) { - /* word options */ - case OPT_NUM_OPTS: - case OPT_RESOLUTION: - case OPT_TL_Y: - case OPT_BR_Y: - case OPT_TL_X: - case OPT_BR_X: - case OPT_CUSTOM_GAMMA: - case OPT_PREVIEW: - *(SANE_Word *) val = dev->val[option].w; - return SANE_STATUS_GOOD; + /* String side-effect options */ + case OPT_MODE: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; - /* string options */ - case OPT_MODE: - case OPT_HALFTONE_PATTERN: - strcpy (val, dev->val[option].s); - return SANE_STATUS_GOOD; + free (dev->val[OPT_MODE].s); + dev->val[OPT_MODE].s = (SANE_Char *) strdup (val); - /* Gamma */ - case OPT_GAMMA_VECTOR_R: - case OPT_GAMMA_VECTOR_G: - case OPT_GAMMA_VECTOR_B: - case OPT_GAMMA_VECTOR_GRAY: - memcpy (val, dev->val[option].wa, dev->opt[option].size); - return SANE_STATUS_GOOD; + dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; - default: - return SANE_STATUS_INVAL; + if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0) + { + int i; + + i = get_string_list_index (halftone_pattern_list, + dev->val[OPT_HALFTONE_PATTERN].s); + if (halftone_pattern_val[i] == NULL) + { + dev->scan_mode = LEO_BW; } + else + { + dev->scan_mode = LEO_HALFTONE; + } + dev->depth = 1; + dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + } + else if (strcmp (dev->val[OPT_MODE].s, GRAY_STR) == 0) + { + dev->scan_mode = LEO_GRAYSCALE; + dev->depth = 8; + dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; + if (dev->val[OPT_CUSTOM_GAMMA].w) + { + dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE; + } + } + else if (strcmp (dev->val[OPT_MODE].s, COLOR_STR) == 0) + { + dev->scan_mode = LEO_COLOR; + dev->depth = 8; + dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; + if (dev->val[OPT_CUSTOM_GAMMA].w) + { + dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + + case OPT_HALFTONE_PATTERN: + free (dev->val[option].s); + dev->val[option].s = (SANE_String) strdup (val); + i = get_string_list_index (halftone_pattern_list, + dev->val[OPT_HALFTONE_PATTERN].s); + if (halftone_pattern_val[i] == NULL) + { + dev->scan_mode = LEO_BW; + } + else + { + dev->scan_mode = LEO_HALFTONE; + } + + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + case OPT_GAMMA_VECTOR_GRAY: + memcpy (dev->val[option].wa, val, dev->opt[option].size); + return SANE_STATUS_GOOD; + + case OPT_CUSTOM_GAMMA: + dev->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val; + if (dev->val[OPT_CUSTOM_GAMMA].w) + { + /* use custom_gamma_table */ + if (dev->scan_mode == LEO_GRAYSCALE) + { + dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE; + } + else + { + /* color mode */ + dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + else + { + dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; + } + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS; + } + return SANE_STATUS_GOOD; + + default: + return SANE_STATUS_INVAL; } - else if (action == SANE_ACTION_SET_VALUE) { + } - if (!SANE_OPTION_IS_SETTABLE (cap)) { - DBG (DBG_error, "could not set option, not settable\n"); - return SANE_STATUS_INVAL; - } + DBG (DBG_proc, "sane_control_option: exit, bad\n"); - status = sanei_constrain_value (dev->opt + option, val, info); - if (status != SANE_STATUS_GOOD) { - DBG (DBG_error, "could not set option, invalid value\n"); - return status; - } - - switch (option) { - - /* Numeric side-effect options */ - case OPT_TL_Y: - case OPT_BR_Y: - case OPT_TL_X: - case OPT_BR_X: - case OPT_RESOLUTION: - if (info) { - *info |= SANE_INFO_RELOAD_PARAMS; - } - dev->val[option].w = *(SANE_Word *) val; - return SANE_STATUS_GOOD; - - /* Numeric side-effect free options */ - case OPT_PREVIEW: - dev->val[option].w = *(SANE_Word *) val; - return SANE_STATUS_GOOD; - - /* String side-effect options */ - case OPT_MODE: - if (strcmp (dev->val[option].s, val) == 0) - return SANE_STATUS_GOOD; - - free (dev->val[OPT_MODE].s); - dev->val[OPT_MODE].s = (SANE_Char *) strdup (val); - - dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; - - if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0) { - int i; - - i = get_string_list_index (halftone_pattern_list, - dev->val[OPT_HALFTONE_PATTERN].s); - if (halftone_pattern_val[i] == NULL) { - dev->scan_mode = LEO_BW; - } - else { - dev->scan_mode = LEO_HALFTONE; - } - dev->depth = 1; - dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; - } - else if (strcmp (dev->val[OPT_MODE].s, GRAY_STR) == 0) { - dev->scan_mode = LEO_GRAYSCALE; - dev->depth = 8; - dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; - if (dev->val[OPT_CUSTOM_GAMMA].w) { - dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE; - } - } - else if (strcmp (dev->val[OPT_MODE].s, COLOR_STR) == 0) { - dev->scan_mode = LEO_COLOR; - dev->depth = 8; - dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; - if (dev->val[OPT_CUSTOM_GAMMA].w) { - dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; - } - } - - if (info) { - *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; - } - return SANE_STATUS_GOOD; - - case OPT_HALFTONE_PATTERN: - free (dev->val[option].s); - dev->val[option].s = (SANE_String) strdup (val); - i = get_string_list_index (halftone_pattern_list, - dev->val[OPT_HALFTONE_PATTERN].s); - if (halftone_pattern_val[i] == NULL) { - dev->scan_mode = LEO_BW; - } - else { - dev->scan_mode = LEO_HALFTONE; - } - - return SANE_STATUS_GOOD; - - case OPT_GAMMA_VECTOR_R: - case OPT_GAMMA_VECTOR_G: - case OPT_GAMMA_VECTOR_B: - case OPT_GAMMA_VECTOR_GRAY: - memcpy (dev->val[option].wa, val, dev->opt[option].size); - return SANE_STATUS_GOOD; - - case OPT_CUSTOM_GAMMA: - dev->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val; - if (dev->val[OPT_CUSTOM_GAMMA].w) { - /* use custom_gamma_table */ - if (dev->scan_mode == LEO_GRAYSCALE) { - dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE; - } - else { - /* color mode */ - dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; - } - } - else { - dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; - } - if (info) { - *info |= SANE_INFO_RELOAD_OPTIONS; - } - return SANE_STATUS_GOOD; - - default: - return SANE_STATUS_INVAL; - } - } - - DBG (DBG_proc, "sane_control_option: exit, bad\n"); - - return SANE_STATUS_UNSUPPORTED; + return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) { - Leo_Scanner *dev = handle; + Leo_Scanner *dev = handle; - DBG (DBG_proc, "sane_get_parameters: enter\n"); + DBG (DBG_proc, "sane_get_parameters: enter\n"); - if (!(dev->scanning)) { + if (!(dev->scanning)) + { - /* Setup the parameters for the scan. These values will be re-used - * in the SET WINDOWS command. */ - if (dev->val[OPT_PREVIEW].w == SANE_TRUE) { - dev->x_resolution = 28; - dev->y_resolution = 28; - dev->x_tl = 0; - dev->y_tl = 0; - dev->x_br = mmToIlu (SANE_UNFIX (x_range.max)); - dev->y_br = mmToIlu (SANE_UNFIX (y_range.max)); - } - else { - dev->x_resolution = dev->val[OPT_RESOLUTION].w; - dev->y_resolution = dev->val[OPT_RESOLUTION].w; - dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); - dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); - dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); - dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); - } - - /* Check the corners are OK. */ - if (dev->x_tl > dev->x_br) { - int s; - s = dev->x_tl; - dev->x_tl = dev->x_br; - dev->x_br = s; - } - if (dev->y_tl > dev->y_br) { - int s; - s = dev->y_tl; - dev->y_tl = dev->y_br; - dev->y_br = s; - } - - dev->width = dev->x_br - dev->x_tl; - dev->length = dev->y_br - dev->y_tl; - - /* Prepare the parameters for the caller. */ - memset (&dev->params, 0, sizeof (SANE_Parameters)); - - dev->params.last_frame = SANE_TRUE; - - switch (dev->scan_mode) { - case LEO_BW: - case LEO_HALFTONE: - dev->params.format = SANE_FRAME_GRAY; - dev->params.pixels_per_line = dev->width & ~0x7; - dev->params.bytes_per_line = dev->params.pixels_per_line / 8; - dev->params.depth = 1; - break; - case LEO_GRAYSCALE: - dev->params.format = SANE_FRAME_GRAY; - dev->params.pixels_per_line = dev->width; - dev->params.bytes_per_line = dev->params.pixels_per_line; - dev->params.depth = 8; - break; - case LEO_COLOR: - dev->params.format = SANE_FRAME_RGB; - dev->params.pixels_per_line = dev->width; - dev->params.bytes_per_line = dev->params.pixels_per_line * 3; - dev->params.depth = 8; - break; - } - - dev->params.lines = dev->length; + /* Setup the parameters for the scan. These values will be re-used + * in the SET WINDOWS command. */ + if (dev->val[OPT_PREVIEW].w == SANE_TRUE) + { + dev->x_resolution = 28; + dev->y_resolution = 28; + dev->x_tl = 0; + dev->y_tl = 0; + dev->x_br = mmToIlu (SANE_UNFIX (x_range.max)); + dev->y_br = mmToIlu (SANE_UNFIX (y_range.max)); + } + else + { + dev->x_resolution = dev->val[OPT_RESOLUTION].w; + dev->y_resolution = dev->val[OPT_RESOLUTION].w; + dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); + dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); + dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); + dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); } - /* Return the current values. */ - if (params) { - *params = (dev->params); + /* Check the corners are OK. */ + if (dev->x_tl > dev->x_br) + { + int s; + s = dev->x_tl; + dev->x_tl = dev->x_br; + dev->x_br = s; + } + if (dev->y_tl > dev->y_br) + { + int s; + s = dev->y_tl; + dev->y_tl = dev->y_br; + dev->y_br = s; } - DBG (DBG_proc, "sane_get_parameters: exit\n"); + dev->width = dev->x_br - dev->x_tl; + dev->length = dev->y_br - dev->y_tl; - return SANE_STATUS_GOOD; + /* Prepare the parameters for the caller. */ + memset (&dev->params, 0, sizeof (SANE_Parameters)); + + dev->params.last_frame = SANE_TRUE; + + switch (dev->scan_mode) + { + case LEO_BW: + case LEO_HALFTONE: + dev->params.format = SANE_FRAME_GRAY; + dev->params.pixels_per_line = dev->width & ~0x7; + dev->params.bytes_per_line = dev->params.pixels_per_line / 8; + dev->params.depth = 1; + break; + case LEO_GRAYSCALE: + dev->params.format = SANE_FRAME_GRAY; + dev->params.pixels_per_line = dev->width; + dev->params.bytes_per_line = dev->params.pixels_per_line; + dev->params.depth = 8; + break; + case LEO_COLOR: + dev->params.format = SANE_FRAME_RGB; + dev->params.pixels_per_line = dev->width; + dev->params.bytes_per_line = dev->params.pixels_per_line * 3; + dev->params.depth = 8; + break; + } + + dev->params.lines = dev->length; + } + + /* Return the current values. */ + if (params) + { + *params = (dev->params); + } + + DBG (DBG_proc, "sane_get_parameters: exit\n"); + + return SANE_STATUS_GOOD; } SANE_Status sane_start (SANE_Handle handle) { - Leo_Scanner *dev = handle; - SANE_Status status; + Leo_Scanner *dev = handle; + SANE_Status status; - DBG (DBG_proc, "sane_start: enter\n"); + DBG (DBG_proc, "sane_start: enter\n"); - if (!(dev->scanning)) { + if (!(dev->scanning)) + { - sane_get_parameters (dev, NULL); - - /* Open again the scanner. */ - if (sanei_scsi_open - (dev->devicename, &(dev->sfd), leo_sense_handler, dev) != 0) { - DBG (DBG_error, "ERROR: sane_start: open failed\n"); - return SANE_STATUS_INVAL; - } - - /* The scanner must be ready. */ - status = leo_wait_scanner (dev); - if (status) { - leo_close (dev); - return status; - } - - status = leo_set_window (dev); - if (status) { - leo_close (dev); - return status; - } - - status = leo_send_gamma (dev); - if (status) { - leo_close (dev); - return status; - } - - status = leo_send_halftone_pattern (dev); - if (status) { - leo_close (dev); - return status; - } - - status = leo_scan (dev); - if (status) { - leo_close (dev); - return status; - } - - status = leo_wait_scanner (dev); - if (status) { - leo_close (dev); - return status; - } - - status = leo_get_scan_size (dev); - if (status) { - leo_close (dev); - return status; - } + sane_get_parameters (dev, NULL); + /* Open again the scanner. */ + if (sanei_scsi_open + (dev->devicename, &(dev->sfd), leo_sense_handler, dev) != 0) + { + DBG (DBG_error, "ERROR: sane_start: open failed\n"); + return SANE_STATUS_INVAL; } - dev->image_end = 0; - dev->image_begin = 0; + /* The scanner must be ready. */ + status = leo_wait_scanner (dev); + if (status) + { + leo_close (dev); + return status; + } - dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; - dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines; + status = leo_set_window (dev); + if (status) + { + leo_close (dev); + return status; + } - dev->scanning = SANE_TRUE; + status = leo_send_gamma (dev); + if (status) + { + leo_close (dev); + return status; + } - DBG (DBG_proc, "sane_start: exit\n"); + status = leo_send_halftone_pattern (dev); + if (status) + { + leo_close (dev); + return status; + } - return SANE_STATUS_GOOD; + status = leo_scan (dev); + if (status) + { + leo_close (dev); + return status; + } + + status = leo_wait_scanner (dev); + if (status) + { + leo_close (dev); + return status; + } + + status = leo_get_scan_size (dev); + if (status) + { + leo_close (dev); + return status; + } + + } + + dev->image_end = 0; + dev->image_begin = 0; + + dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; + dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines; + + dev->scanning = SANE_TRUE; + + DBG (DBG_proc, "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) + SANE_Int * len) { - SANE_Status status; - Leo_Scanner *dev = handle; - size_t size; - int buf_offset; /* offset into buf */ + SANE_Status status; + Leo_Scanner *dev = handle; + size_t size; + int buf_offset; /* offset into buf */ - DBG (DBG_proc, "sane_read: enter\n"); + DBG (DBG_proc, "sane_read: enter\n"); - *len = 0; + *len = 0; - if (!(dev->scanning)) { - /* OOPS, not scanning */ - return do_cancel (dev); + if (!(dev->scanning)) + { + /* OOPS, not scanning */ + return do_cancel (dev); + } + + if (dev->bytes_left <= 0) + { + return (SANE_STATUS_EOF); + } + + buf_offset = 0; + + do + { + if (dev->image_begin == dev->image_end) + { + /* Fill image */ + status = leo_fill_image (dev); + if (status != SANE_STATUS_GOOD) + { + return (status); + } } - if (dev->bytes_left <= 0) { - return (SANE_STATUS_EOF); + /* Something must have been read */ + if (dev->image_begin == dev->image_end) + { + DBG (DBG_info, "sane_read: nothing read\n"); + return SANE_STATUS_IO_ERROR; } - buf_offset = 0; - - do { - if (dev->image_begin == dev->image_end) { - /* Fill image */ - status = leo_fill_image (dev); - if (status != SANE_STATUS_GOOD) { - return (status); - } - } - - /* Something must have been read */ - if (dev->image_begin == dev->image_end) { - DBG (DBG_info, "sane_read: nothing read\n"); - return SANE_STATUS_IO_ERROR; - } - - /* Copy the data to the frontend buffer. */ - size = max_len - buf_offset; - if (size > dev->bytes_left) { - size = dev->bytes_left; - } - leo_copy_raw_to_frontend (dev, buf + buf_offset, &size); - - buf_offset += size; - - dev->bytes_left -= size; - *len += size; - + /* Copy the data to the frontend buffer. */ + size = max_len - buf_offset; + if (size > dev->bytes_left) + { + size = dev->bytes_left; } - while ((buf_offset != max_len) && dev->bytes_left); + leo_copy_raw_to_frontend (dev, buf + buf_offset, &size); - DBG (DBG_info, "sane_read: leave, bytes_left=%d\n", dev->bytes_left); + buf_offset += size; - return SANE_STATUS_GOOD; + dev->bytes_left -= size; + *len += size; + + } + while ((buf_offset != max_len) && dev->bytes_left); + + DBG (DBG_info, "sane_read: leave, bytes_left=%d\n", dev->bytes_left); + + return SANE_STATUS_GOOD; } SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) { - SANE_Status status; - Leo_Scanner *dev = handle; + SANE_Status status; + Leo_Scanner *dev = handle; - DBG (DBG_proc, "sane_set_io_mode: enter\n"); + DBG (DBG_proc, "sane_set_io_mode: enter\n"); - handle = handle; /* silence gcc */ - non_blocking = non_blocking; /* silence gcc */ + handle = handle; /* silence gcc */ + non_blocking = non_blocking; /* silence gcc */ - if (!dev->scanning) { - return SANE_STATUS_INVAL; - } + if (!dev->scanning) + { + return SANE_STATUS_INVAL; + } - if (non_blocking == SANE_FALSE) { - status = SANE_STATUS_GOOD; - } - else { - status = SANE_STATUS_UNSUPPORTED; - } + if (non_blocking == SANE_FALSE) + { + status = SANE_STATUS_GOOD; + } + else + { + status = SANE_STATUS_UNSUPPORTED; + } - DBG (DBG_proc, "sane_set_io_mode: exit\n"); + DBG (DBG_proc, "sane_set_io_mode: exit\n"); - return status; + return status; } SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) { - DBG (DBG_proc, "sane_get_select_fd: enter\n"); + DBG (DBG_proc, "sane_get_select_fd: enter\n"); - handle = handle; /* silence gcc */ - fd = fd; /* silence gcc */ + handle = handle; /* silence gcc */ + fd = fd; /* silence gcc */ - DBG (DBG_proc, "sane_get_select_fd: exit\n"); + DBG (DBG_proc, "sane_get_select_fd: exit\n"); - return SANE_STATUS_UNSUPPORTED; + return SANE_STATUS_UNSUPPORTED; } void sane_cancel (SANE_Handle handle) { - Leo_Scanner *dev = handle; + Leo_Scanner *dev = handle; - DBG (DBG_proc, "sane_cancel: enter\n"); + DBG (DBG_proc, "sane_cancel: enter\n"); - do_cancel (dev); + do_cancel (dev); - DBG (DBG_proc, "sane_cancel: exit\n"); + DBG (DBG_proc, "sane_cancel: exit\n"); } void sane_close (SANE_Handle handle) { - Leo_Scanner *dev = handle; - Leo_Scanner *dev_tmp; + Leo_Scanner *dev = handle; + Leo_Scanner *dev_tmp; - DBG (DBG_proc, "sane_close: enter\n"); + DBG (DBG_proc, "sane_close: enter\n"); - do_cancel (dev); - leo_close (dev); + do_cancel (dev); + leo_close (dev); - /* Unlink dev. */ - if (first_dev == dev) { - first_dev = dev->next; + /* Unlink dev. */ + if (first_dev == dev) + { + first_dev = dev->next; + } + else + { + dev_tmp = first_dev; + while (dev_tmp->next && dev_tmp->next != dev) + { + dev_tmp = dev_tmp->next; } - else { - dev_tmp = first_dev; - while (dev_tmp->next && dev_tmp->next != dev) { - dev_tmp = dev_tmp->next; - } - if (dev_tmp->next != NULL) { - dev_tmp->next = dev_tmp->next->next; - } + if (dev_tmp->next != NULL) + { + dev_tmp->next = dev_tmp->next->next; } + } - leo_free (dev); - num_devices--; + leo_free (dev); + num_devices--; - DBG (DBG_proc, "sane_close: exit\n"); + DBG (DBG_proc, "sane_close: exit\n"); } void sane_exit (void) { - DBG (DBG_proc, "sane_exit: enter\n"); + DBG (DBG_proc, "sane_exit: enter\n"); - while (first_dev) { - sane_close (first_dev); - } + while (first_dev) + { + sane_close (first_dev); + } - if (devlist) { - free (devlist); - devlist = NULL; - } + if (devlist) + { + free (devlist); + devlist = NULL; + } - DBG (DBG_proc, "sane_exit: exit\n"); + DBG (DBG_proc, "sane_exit: exit\n"); }