diff options
Diffstat (limited to 'backend/microtek.c')
| -rw-r--r-- | backend/microtek.c | 4187 |
1 files changed, 4187 insertions, 0 deletions
diff --git a/backend/microtek.c b/backend/microtek.c new file mode 100644 index 0000000..ff82df4 --- /dev/null +++ b/backend/microtek.c @@ -0,0 +1,4187 @@ +/*************************************************************************** + * SANE - Scanner Access Now Easy. + + microtek.c + + This file Copyright 2002 Matthew Marjanovic + + This file is part of the SANE package. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + *************************************************************************** + + This file implements a SANE backend for Microtek scanners. + + (feedback to: mtek-bugs@mir.com) + (for latest info: http://www.mir.com/mtek/) + + ***************************************************************************/ + + +#define MICROTEK_MAJOR 0 +#define MICROTEK_MINOR 13 +#define MICROTEK_PATCH 1 + +#include "../include/sane/config.h" + +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <math.h> + +#include "../include/_stdint.h" + +#include "../include/sane/sane.h" +#include "../include/sane/sanei.h" +#include "../include/sane/sanei_config.h" +#include "../include/sane/sanei_scsi.h" +#include "../include/sane/saneopts.h" + +#define BACKEND_NAME microtek +#include "../include/sane/sanei_backend.h" + +#include "microtek.h" + + +#define MICROTEK_CONFIG_FILE "microtek.conf" + +#ifndef PATH_MAX +# define PATH_MAX 1024 +#endif + + +#define SCSI_BUFF_SIZE sanei_scsi_max_request_size + + +#define MIN(a,b) (((a) < (b)) ? (a) : (b)) +#define MAX(a,b) (((a) > (b)) ? (a) : (b)) + +static int num_devices = 0; +static Microtek_Device *first_dev = NULL; /* list of known devices */ +static Microtek_Scanner *first_handle = NULL; /* list of open scanners */ +static const SANE_Device **devlist = NULL; /* sane_get_devices() */ + + +static SANE_Bool inhibit_clever_precal = SANE_FALSE; +static SANE_Bool inhibit_real_calib = SANE_FALSE; + + +#define M_GSS_WAIT 5 /* seconds */ + +#define M_LINEART SANE_VALUE_SCAN_MODE_LINEART +#define M_HALFTONE SANE_VALUE_SCAN_MODE_HALFTONE +#define M_GRAY SANE_VALUE_SCAN_MODE_GRAY +#define M_COLOR SANE_VALUE_SCAN_MODE_COLOR + +#define M_OPAQUE "Opaque/Normal" +#define M_TRANS "Transparency" +#define M_AUTOFEED "AutoFeeder" + +#define M_NONE "None" +#define M_SCALAR "Scalar" +#define M_TABLE "Table" + +static SANE_String_Const gamma_mode_list[4] = { + M_NONE, + M_SCALAR, + M_TABLE, + NULL +}; + + +/* These are for the E6. Does this hold for other models? */ +static SANE_String_Const halftone_mode_list[13] = { + " 1 53-dot screen (53 gray levels)", + " 2 Horiz. screen (65 gray levels)", + " 3 Vert. screen (65 gray levels)", + " 4 Mixed page (33 gray levels)", + " 5 71-dot screen (29 gray levels)", + " 6 60-dot #1 (26 gray levels)", + " 7 60-dot #2 (26 gray levels)", + " 8 Fine detail #1 (17 gray levels)", + " 9 Fine detail #2 (17 gray levels)", + "10 Slant line (17 gray levels)", + "11 Posterizing (10 gray levels)", + "12 High Contrast (5 gray levels)", + NULL +}; + + + +static SANE_Range speed_range = {1, 7, 1}; + +static SANE_Range brightness_range = {-100, 100, 1}; +/*static SANE_Range brightness_range = {0, 255, 1};*/ +/*static SANE_Range exposure_range = {-18, 21, 3};*/ +/*static SANE_Range contrast_range = {-42, 49, 7};*/ +static SANE_Range u8_range = {0, 255, 1}; +static SANE_Range analog_gamma_range = +{ SANE_FIX(0.1), SANE_FIX(4.0), SANE_FIX(0) }; + + + + +#define MAX_MDBG_LENGTH 1024 +static char _mdebug_string[MAX_MDBG_LENGTH]; + +static void MDBG_INIT(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + vsnprintf(_mdebug_string, MAX_MDBG_LENGTH, format, ap); + va_end(ap); +} + +static void MDBG_ADD(const char *format, ...) +{ + int len = strlen(_mdebug_string); + va_list ap; + va_start(ap, format); + vsnprintf(_mdebug_string+len, MAX_MDBG_LENGTH-len, format, ap); + va_end(ap); +} + +static void MDBG_FINISH(int dbglvl) +{ + DBG(dbglvl, "%s\n", _mdebug_string); +} + + + +/********************************************************************/ +/********************************************************************/ +/*** Utility Functions **********************************************/ +/********************************************************************/ +/********************************************************************/ + +static size_t max_string_size (const SANE_String_Const strings[]) +{ + 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; + } + return max_size; +} + + + +/********************************************************************/ +/* Allocate/create a new ring buffer */ +/********************************************************************/ +static ring_buffer * +ring_alloc (size_t initial_size, size_t bpl, size_t ppl) +{ + ring_buffer *rb; + uint8_t *buff; + + if ((rb = (ring_buffer *)malloc(sizeof(*rb))) == NULL) + return NULL; + if ((buff = (uint8_t *)malloc(initial_size * sizeof(*buff))) == NULL) { + free(rb); + return NULL; + } + rb->base = buff; + rb->size = initial_size; + rb->initial_size = initial_size; + + rb->bpl = bpl; + rb->ppl = ppl; + + rb->tail_red = 0; + rb->tail_green = 1; + rb->tail_blue = 2; + rb->head_complete = 0; + + rb->red_extra = 0; + rb->green_extra = 0; + rb->blue_extra = 0; + rb->complete_count = 0; + + return rb; +} + + +/********************************************************************/ +/* Enlarge an existing ring buffer */ +/********************************************************************/ +static SANE_Status +ring_expand (ring_buffer *rb, size_t amount) +{ + uint8_t *buff; + size_t oldsize; + + if (rb == NULL) return SANE_STATUS_INVAL; + buff = (uint8_t *)realloc(rb->base, (rb->size + amount) * sizeof(*buff)); + if (buff == NULL) return SANE_STATUS_NO_MEM; + + rb->base = buff; + oldsize = rb->size; + rb->size += amount; + + DBG(23, "ring_expand: old, new, inc size: %lu, %lu, %lu\n", + (u_long)oldsize, (u_long)rb->size, (u_long)amount); + DBG(23, "ring_expand: old tr: %lu tg: %lu tb: %lu hc: %lu\n", + (u_long)rb->tail_red, (u_long)rb->tail_green, + (u_long)rb->tail_blue, (u_long)rb->head_complete); + /* if necessary, move data and fix up them pointers */ + /* (will break subtly if ring is filled with G or B bytes, + and tail_g or tail_b have rolled over...) */ + if (((rb->complete_count) || + (rb->red_extra) || + (rb->green_extra) || + (rb->blue_extra)) && ((rb->tail_red <= rb->head_complete) || + (rb->tail_green <= rb->head_complete) || + (rb->tail_blue <= rb->head_complete))) { + memmove(rb->base + rb->head_complete + amount, + rb->base + rb->head_complete, + oldsize - rb->head_complete); + if ((rb->tail_red > rb->head_complete) || + ((rb->tail_red == rb->head_complete) && + !(rb->complete_count) && !(rb->red_extra))) + rb->tail_red += amount; + if ((rb->tail_green > rb->head_complete) || + ((rb->tail_green == rb->head_complete) && + !(rb->complete_count) && !(rb->green_extra))) + rb->tail_green += amount; + if ((rb->tail_blue > rb->head_complete) || + ((rb->tail_blue == rb->head_complete) && + !(rb->complete_count) && !(rb->blue_extra))) + rb->tail_blue += amount; + rb->head_complete += amount; + } + DBG(23, "ring_expand: new tr: %lu tg: %lu tb: %lu hc: %lu\n", + (u_long)rb->tail_red, (u_long)rb->tail_green, + (u_long)rb->tail_blue, (u_long)rb->head_complete); + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Deallocate a ring buffer */ +/********************************************************************/ +static void +ring_free (ring_buffer *rb) +{ + free(rb->base); + free(rb); +} + + + +/********************************************************************/ +/********************************************************************/ +/*** Basic SCSI Commands ********************************************/ +/********************************************************************/ +/********************************************************************/ + + +/********************************************************************/ +/* parse sense from scsi error */ +/* (even though microtek sense codes are non-standard and */ +/* typically misinterpreted/munged by the low-level scsi driver) */ +/********************************************************************/ +static SANE_Status +sense_handler (int scsi_fd, u_char *sense, void *arg) +{ + int *sense_flags = (int *)arg; + SANE_Status stat; + + DBG(10, "SENSE! fd = %d\n", scsi_fd); + DBG(10, "sense = %02x %02x %02x %02x.\n", + sense[0], sense[1], sense[2], sense[3]); + switch(sense[0]) { + case 0x00: + return SANE_STATUS_GOOD; + case 0x81: /* COMMAND/DATA ERROR */ + stat = SANE_STATUS_GOOD; + if (sense[1] & 0x01) { + if ((sense_flags != NULL) && (*sense_flags & MS_SENSE_IGNORE)) + DBG(10, "sense: ERR_SCSICMD -- ignored\n"); + else { + DBG(10, "sense: ERR_SCSICMD\n"); + stat = SANE_STATUS_IO_ERROR; + } + } + if (sense[1] & 0x02) { + DBG(10, "sense: ERR_TOOMANY\n"); + stat = SANE_STATUS_IO_ERROR; + } + return stat; + case 0x82 : /* SCANNER HARDWARE ERROR */ + if (sense[1] & 0x01) DBG(10, "sense: ERR_CPURAMFAIL\n"); + if (sense[1] & 0x02) DBG(10, "sense: ERR_SYSRAMFAIL\n"); + if (sense[1] & 0x04) DBG(10, "sense: ERR_IMGRAMFAIL\n"); + if (sense[1] & 0x10) DBG(10, "sense: ERR_CALIBRATE\n"); + if (sense[1] & 0x20) DBG(10, "sense: ERR_LAMPFAIL\n"); + if (sense[1] & 0x40) DBG(10, "sense: ERR_MOTORFAIL\n"); + if (sense[1] & 0x80) DBG(10, "sense: ERR_FEEDERFAIL\n"); + if (sense[2] & 0x01) DBG(10, "sense: ERR_POWERFAIL\n"); + if (sense[2] & 0x02) DBG(10, "sense: ERR_ILAMPFAIL\n"); + if (sense[2] & 0x04) DBG(10, "sense: ERR_IMOTORFAIL\n"); + if (sense[2] & 0x08) DBG(10, "sense: ERR_PAPERFAIL\n"); + if (sense[2] & 0x10) DBG(10, "sense: ERR_FILTERFAIL\n"); + return SANE_STATUS_IO_ERROR; + case 0x83 : /* OPERATION ERROR */ + if (sense[1] & 0x01) DBG(10, "sense: ERR_ILLGRAIN\n"); + if (sense[1] & 0x02) DBG(10, "sense: ERR_ILLRES\n"); + if (sense[1] & 0x04) DBG(10, "sense: ERR_ILLCOORD\n"); + if (sense[1] & 0x10) DBG(10, "sense: ERR_ILLCNTR\n"); + if (sense[1] & 0x20) DBG(10, "sense: ERR_ILLLENGTH\n"); + if (sense[1] & 0x40) DBG(10, "sense: ERR_ILLADJUST\n"); + if (sense[1] & 0x80) DBG(10, "sense: ERR_ILLEXPOSE\n"); + if (sense[2] & 0x01) DBG(10, "sense: ERR_ILLFILTER\n"); + if (sense[2] & 0x02) DBG(10, "sense: ERR_NOPAPER\n"); + if (sense[2] & 0x04) DBG(10, "sense: ERR_ILLTABLE\n"); + if (sense[2] & 0x08) DBG(10, "sense: ERR_ILLOFFSET\n"); + if (sense[2] & 0x10) DBG(10, "sense: ERR_ILLBPP\n"); + return SANE_STATUS_IO_ERROR; + default : + DBG(10, "sense: unknown error\n"); + return SANE_STATUS_IO_ERROR; + } + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* wait (via polling) until scanner seems "ready" */ +/********************************************************************/ +static SANE_Status +wait_ready(Microtek_Scanner *ms) +{ + uint8_t comm[6] = { 0, 0, 0, 0, 0, 0 }; + SANE_Status status; + int retry = 0; + + DBG(23, ".wait_ready %d...\n", ms->sfd); + while ((status = sanei_scsi_cmd(ms->sfd, comm, 6, 0, 0)) + != SANE_STATUS_GOOD) { + DBG(23, "wait_ready failed (%d)\n", retry); + if (retry > 5) return SANE_STATUS_IO_ERROR; /* XXXXXXXX */ + retry++; + sleep(3); + } + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* send scan region coordinates */ +/********************************************************************/ +static SANE_Status +scanning_frame(Microtek_Scanner *ms) +{ + uint8_t *data, comm[15] = { 0x04, 0, 0, 0, 0x09, 0 }; + int x1, y1, x2, y2; + + DBG(23, ".scanning_frame...\n"); + + x1 = ms->x1; + x2 = ms->x2; + y1 = ms->y1; + y2 = ms->y2; + /* E6 weirdness (other models too?) */ + if (ms->unit_type == MS_UNIT_18INCH) { + x1 /= 2; + x2 /= 2; + y1 /= 2; + y2 /= 2; + } + + DBG(23, ".scanning_frame: in- %d,%d %d,%d\n", + ms->x1, ms->y1, ms->x2, ms->y2); + DBG(23, ".scanning_frame: out- %d,%d %d,%d\n", x1, y1, x2, y2); + data = comm + 6; + data[0] = + ((ms->unit_type == MS_UNIT_PIXELS) ? 0x08 : 0 ) | + ((ms->mode == MS_MODE_HALFTONE) ? 0x01 : 0 ); + data[1] = x1 & 0xFF; + data[2] = (x1 >> 8) & 0xFF; + data[3] = y1 & 0xFF; + data[4] = (y1 >> 8) & 0xFF; + data[5] = x2 & 0xFF; + data[6] = (x2 >> 8) & 0xFF; + data[7] = y2 & 0xFF; + data[8] = (y2 >> 8) & 0xFF; + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "SF: "); + for (i=0;i<6+0x09;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("SF: "); + for (i=0;i<6+0x09;i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 6 + 0x09, 0, 0); +} + + + +/********************************************************************/ +/* send "mode_select" */ +/********************************************************************/ +static SANE_Status +mode_select(Microtek_Scanner *ms) +{ + uint8_t *data, comm[19] = { 0x15, 0, 0, 0, 0, 0 }; + + DBG(23, ".mode_select %d...\n", ms->sfd); + data = comm + 6; + data[0] = + 0x81 | + ((ms->unit_type == MS_UNIT_18INCH) ? 0 : 0x08) | + ((ms->res_type == MS_RES_5PER) ? 0 : 0x02); + data[1] = ms->resolution_code; + data[2] = ms->exposure; + data[3] = ms->contrast; + data[4] = ms->pattern; + data[5] = ms->velocity; + data[6] = ms->shadow; + data[7] = ms->highlight; + DBG(23, ".mode_select: pap_len: %d\n", ms->paper_length); + data[8] = ms->paper_length & 0xFF; + data[9] = (ms->paper_length >> 8) & 0xFF; + data[10] = ms->midtone; + /* set command/data length */ + comm[4] = (ms->midtone_support) ? 0x0B : 0x0A; + + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "MSL: "); + for (i=0;i<6+comm[4];i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("MSL: "); + for (i=0;i<6+comm[4];i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 6 + comm[4], 0, 0); +} + + + +/********************************************************************/ +/* send "mode_select_1" */ +/********************************************************************/ +static SANE_Status +mode_select_1(Microtek_Scanner *ms) +{ + uint8_t *data, comm[16] = { 0x16, 0, 0, 0, 0x0A, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + DBG(23, ".mode_select_1 %d...\n", ms->sfd); + data = comm + 6; + data[1] = ms->bright_r; + data[3] = ((ms->allow_calibrate) ? 0 : 0x02); /* | 0x01; */ + + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "MSL1: "); + for (i=0;i<6+0x0A;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("MSL1: "); + for (i=0;i<6+0x0A;i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 6 + 0x0A, 0, 0); +} + + + +/********************************************************************/ +/* record mode_sense results in the mode_sense buffer */ +/* (this is to tell if something catastrophic has happened */ +/* to the scanner in-between scans) */ +/********************************************************************/ +static SANE_Status +save_mode_sense(Microtek_Scanner *ms) +{ + uint8_t data[20], comm[6] = { 0x1A, 0, 0, 0, 0, 0}; + size_t lenp; + SANE_Status status; + int i; + + DBG(23, ".save_mode_sense %d...\n", ms->sfd); + if (ms->onepass) comm[4] = 0x13; + else if (ms->midtone_support) comm[4] = 0x0B; + else comm[4] = 0x0A; + lenp = comm[4]; + + status = sanei_scsi_cmd(ms->sfd, comm, 6, data, &lenp); + for (i=0; i<10; i++) ms->mode_sense_cache[i] = data[i]; + + if (DBG_LEVEL >= 192) { + unsigned int i; +#if 0 + fprintf(stderr, "SMS: "); + for (i=0;i<lenp;i++) fprintf(stderr, "%2x ", data[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("SMS: "); + for (i=0;i<lenp;i++) MDBG_ADD("%2x ", data[i]); + MDBG_FINISH(192); + } + + return status; +} + + +/********************************************************************/ +/* read mode_sense and compare to what we saved before */ +/********************************************************************/ +static SANE_Status +compare_mode_sense(Microtek_Scanner *ms, int *match) +{ + uint8_t data[20], comm[6] = { 0x1A, 0, 0, 0, 0, 0}; + size_t lenp; + SANE_Status status; + int i; + + DBG(23, ".compare_mode_sense %d...\n", ms->sfd); + if (ms->onepass) comm[4] = 0x13; + else if (ms->midtone_support) comm[4] = 0x0B; + else comm[4] = 0x0A; + lenp = comm[4]; + + status = sanei_scsi_cmd(ms->sfd, comm, 6, data, &lenp); + *match = 1; + for (i=0; i<10; i++) + *match = *match && (ms->mode_sense_cache[i] == data[i]); + + if (DBG_LEVEL >= 192) { + unsigned int i; +#if 0 + fprintf(stderr, "CMS: "); + for (i=0;i<lenp;i++) fprintf(stderr, "%2x(%2x) ", + data[i], + ms->mode_sense_cache[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("CMS: "); + for (i=0;i<lenp;i++) MDBG_ADD("%2x(%2x) ", + data[i], + ms->mode_sense_cache[i]); + MDBG_FINISH(192); + } + + return status; +} + +/********************************************************************/ +/* send mode_sense_1, and upset every scsi driver known to mankind */ +/********************************************************************/ +#if 0 +static SANE_Status +mode_sense_1(Microtek_Scanner *ms) +{ + uint8_t *data, comm[36] = { 0x19, 0, 0, 0, 0x1E, 0 }; + + DBG(23, ".mode_sense_1...\n"); + data = comm + 6; + memset(data, 0, 30); + data[1] = ms->bright_r; + data[2] = ms->bright_g; + data[3] = ms->bright_b; + if (DBG_LEVEL >= 192) { + int i; + fprintf(stderr, "MS1: "); + for (i=0;i<6+0x1E;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); + } + return sanei_scsi_cmd(ms->sfd, comm, 6 + 0x1E, 0, 0); +} +#endif + + + +/********************************************************************/ +/* send "accessory" command */ +/********************************************************************/ +static SANE_Status +accessory(Microtek_Scanner *ms) +{ + uint8_t comm[6] = { 0x10, 0, 0, 0, 0, 0 }; + + DBG(23, ".accessory...\n"); + comm[4] = + ((ms->useADF) ? 0x41 : 0x40) | + ((ms->prescan) ? 0x18 : 0x10) | + ((ms->transparency) ? 0x24 : 0x20) | + ((ms->allowbacktrack) ? 0x82 : 0x80); + + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "AC: "); + for (i=0;i<6;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("AC: "); + for (i=0;i<6;i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 6, 0, 0); +} + + + +/********************************************************************/ +/* start the scanner a-scannin' */ +/********************************************************************/ +static SANE_Status +start_scan(Microtek_Scanner *ms) +{ + uint8_t comm[6] = { 0x1B, 0, 0, 0, 0, 0 }; + + DBG(23, ".start_scan...\n"); + comm[4] = + 0x01 | /* "start" */ + ((ms->expandedresolution) ? 0x80 : 0) | + ((ms->multibit) ? 0x40 : 0) | + ((ms->onepasscolor) ? 0x20 : 0) | + ((ms->reversecolors) ? 0x04 : 0) | + ((ms->fastprescan) ? 0x02 : 0) | + ((ms->filter == MS_FILT_RED) ? 0x08 : 0) | + ((ms->filter == MS_FILT_GREEN) ? 0x10 : 0) | + ((ms->filter == MS_FILT_BLUE) ? 0x18 : 0) ; + + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "SS: "); + for (i=0;i<6;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("SS: "); + for (i=0;i<6;i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 6, 0, 0); +} + + + +/********************************************************************/ +/* stop the scanner a-scannin' */ +/********************************************************************/ +static SANE_Status +stop_scan(Microtek_Scanner *ms) +{ + uint8_t comm[6] = { 0x1B, 0, 0, 0, 0, 0 }; + + DBG(23, ".stop_scan...\n"); + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "SPS:"); + for (i=0;i<6;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("SPS:"); + for (i=0;i<6;i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 6, 0, 0); +} + + + +/********************************************************************/ +/* get scan status */ +/********************************************************************/ +static SANE_Status +get_scan_status(Microtek_Scanner *ms, + SANE_Int *busy, + SANE_Int *bytes_per_line, + SANE_Int *lines) +{ + uint8_t data[6], comm[6] = { 0x0F, 0, 0, 0, 0x06, 0 }; + SANE_Status status; + size_t lenp; + int retry = 0; + + DBG(23, ".get_scan_status %d...\n", ms->sfd); + + do { + lenp = 6; + /* do some retry stuff in here, too */ + status = sanei_scsi_cmd(ms->sfd, comm, 6, data, &lenp); + if (status != SANE_STATUS_GOOD) { + DBG(20, "get_scan_status: scsi error\n"); + return status; + } + *busy = data[0]; + *bytes_per_line = (data[1]) + (data[2] << 8); + *lines = (data[3]) + (data[4] << 8) + (data[5] << 16); + + DBG(20, "get_scan_status(%lu): %d, %d, %d -> #%d\n", + (u_long) lenp, *busy, *bytes_per_line, *lines, retry); + DBG(20, "> %2x %2x %2x %2x %2x %2x\n", + data[0], data[1], data[2], data[3], data[4], data[5]); + if (*busy != 0) { + retry++; + DBG(23, "get_scan_status: busy, retry in %d...\n", + M_GSS_WAIT * retry); + sleep(M_GSS_WAIT * retry); + } + } while ((*busy != 0) && (retry < 4)); + + if (*busy == 0) return status; + else return SANE_STATUS_IO_ERROR; +} + + + +/********************************************************************/ +/* get scanlines from scanner */ +/********************************************************************/ +static SANE_Status +read_scan_data(Microtek_Scanner *ms, + int lines, + uint8_t *buffer, + size_t *bufsize) +{ + uint8_t comm[6] = { 0x08, 0, 0, 0, 0, 0 }; + + DBG(23, ".read_scan_data...\n"); + comm[2] = (lines >> 16) & 0xFF; + comm[3] = (lines >> 8) & 0xFF; + comm[4] = (lines) & 0xFF; + + return sanei_scsi_cmd(ms->sfd, comm, 6, buffer, bufsize); +} + + + +/********************************************************************/ +/* download color LUT to scanner (if it takes one) */ +/********************************************************************/ +static SANE_Status +download_gamma(Microtek_Scanner *ms) +{ + uint8_t *data, *comm; /* commbytes[10] = { 0x55, 0, 0x27, 0, 0, + 0, 0, 0, 0, 0 };*/ + int i, pl; + int commsize; + int bit_depth = 8; /* hard-code for now, should match bpp XXXXXXX */ + int max_entry; + SANE_Status status; + + DBG(23, ".download_gamma...\n"); + /* skip if scanner doesn't take 'em */ + if (!(ms->gamma_entries)) { + DBG(23, ".download_gamma: no entries; skipping\n"); + return SANE_STATUS_GOOD; + } + if ((ms->gamma_entry_size != 1) && (ms->gamma_entry_size != 2)) { + DBG(23, ".download_gamma: entry size %d?!?!?\n", ms->gamma_entry_size); + return SANE_STATUS_INVAL; /* XXXXXXXxx */ + } + + max_entry = (1 << bit_depth) - 1; + + DBG(23, ".download_gamma: %d entries of %d bytes, max %d\n", + ms->gamma_entries, ms->gamma_entry_size, max_entry); + commsize = 10 + (ms->gamma_entries * ms->gamma_entry_size); + comm = calloc(commsize, sizeof(uint8_t)); + if (comm == NULL) { + DBG(23, ".download_gamma: couldn't allocate %d bytes for comm buffer!\n", + commsize); + return SANE_STATUS_NO_MEM; + } + data = comm + 10; + + comm[0] = 0x55; + comm[1] = 0; + comm[2] = 0x27; + comm[3] = 0; + comm[4] = 0; + comm[5] = 0; + comm[6] = 0; + comm[7] = ((ms->gamma_entries * ms->gamma_entry_size) >> 8) & 0xFF; + comm[8] = (ms->gamma_entries * ms->gamma_entry_size) & 0xFF; + comm[9] = (ms->gamma_entry_size == 2) ? 1 : 0; + + if (!(strcmp(ms->val[OPT_CUSTOM_GAMMA].s, M_TABLE))) { + /***** Gamma by TABLE *****/ + int table_shift = (ms->gamma_bit_depth - bit_depth); + + DBG(23, ".download_gamma: by table (%d bpe, %d shift)\n", + ms->gamma_bit_depth, table_shift); + + if (ms->val[OPT_GAMMA_BIND].w == SANE_TRUE) { + for (i=0; i<ms->gamma_entries; i++) { + int val = ms->gray_lut[i] >> table_shift; + switch (ms->gamma_entry_size) { + case 1: + data[i] = (uint8_t) val; + break; + case 2: + data[i*2] = val & 0xFF; + data[(i*2)+1] = (val>>8) & 0xFF; + break; + } + } + status = sanei_scsi_cmd(ms->sfd, comm, commsize, 0, 0); + } else { + pl = 1; + do { + SANE_Int *pl_lut; + switch (pl) { + case 1: pl_lut = ms->red_lut; break; + case 2: pl_lut = ms->green_lut; break; + case 3: pl_lut = ms->blue_lut; break; + default: + DBG(23, ".download_gamma: uh, exceeded pl bound!\n"); + free(comm); + return SANE_STATUS_INVAL; /* XXXXXXXxx */ + break; + } + for (i=0; i<ms->gamma_entries; i++) { + int val = pl_lut[i] >> table_shift; + switch (ms->gamma_entry_size) { + case 1: + data[i] = (uint8_t) val; + break; + case 2: + data[i*2] = val & 0xFF; + data[(i*2)+1] = (val>>8) & 0xFF; + break; + } + } + /* XXXXXXX */ + comm[9] = (comm[9] & 0x3F) | (pl << 6); + status = sanei_scsi_cmd(ms->sfd, comm, commsize, 0, 0); + pl++; + } while ((pl < 4) && (status == SANE_STATUS_GOOD)); + } + } else if (!(strcmp(ms->val[OPT_CUSTOM_GAMMA].s, M_SCALAR))) { + /***** Gamma by SCALAR *****/ + DBG(23, ".download_gamma: by scalar\n"); + if (ms->val[OPT_GAMMA_BIND].w == SANE_TRUE) { + double gamma = SANE_UNFIX(ms->val[OPT_ANALOG_GAMMA].w); + for (i=0; i<ms->gamma_entries; i++) { + int val = (max_entry * + pow((double) i / ((double) ms->gamma_entries - 1.0), + 1.0 / gamma)); + switch (ms->gamma_entry_size) { + case 1: + data[i] = (uint8_t) val; + break; + case 2: + data[i*2] = val & 0xFF; + data[(i*2)+1] = (val>>8) & 0xFF; + break; + } + } + status = sanei_scsi_cmd(ms->sfd, comm, commsize, 0, 0); + } else { + double gamma; + pl = 1; + do { + switch (pl) { + case 1: gamma = SANE_UNFIX(ms->val[OPT_ANALOG_GAMMA_R].w); break; + case 2: gamma = SANE_UNFIX(ms->val[OPT_ANALOG_GAMMA_G].w); break; + case 3: gamma = SANE_UNFIX(ms->val[OPT_ANALOG_GAMMA_B].w); break; + default: gamma = 1.0; break; /* should never happen */ + } + for (i=0; i<ms->gamma_entries; i++) { + int val = (max_entry * + pow((double) i / ((double) ms->gamma_entries - 1.0), + 1.0 / gamma)); + switch (ms->gamma_entry_size) { + case 1: + data[i] = (uint8_t) val; + break; + case 2: + data[i*2] = val & 0xFF; + data[(i*2)+1] = (val>>8) & 0xFF; + break; + } + } + comm[9] = (comm[9] & 0x3F) | (pl << 6); + status = sanei_scsi_cmd(ms->sfd, comm, commsize, 0, 0); + pl++; + } while ((pl < 4) && (status == SANE_STATUS_GOOD)); + } + } else { + /***** No custom Gamma *****/ + DBG(23, ".download_gamma: by default\n"); + for (i=0; i<ms->gamma_entries; i++) { + /* int val = (((double) max_entry * (double) i / + ((double) ms->gamma_entries - 1.0)) + 0.5); ROUNDING????*/ + int val = + (double) max_entry * (double) i / + ((double) ms->gamma_entries - 1.0); + switch (ms->gamma_entry_size) { + case 1: + data[i] = (uint8_t) val; + break; + case 2: + data[i*2] = val & 0xFF; + data[(i*2)+1] = (val >> 8) & 0xFF; + break; + } + } + status = sanei_scsi_cmd(ms->sfd, comm, commsize, 0, 0); + } + free(comm); + return status; +} + + +/********************************************************************/ +/* magic command to start calibration */ +/********************************************************************/ +static SANE_Status +start_calibration(Microtek_Scanner *ms) +{ + uint8_t comm[8] = { 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x0a }; + + DBG(23, ".start_calibrate...\n"); + if (DBG_LEVEL >= 192) { + int i; +#if 0 + fprintf(stderr, "STCal:"); + for (i=0;i<8;i++) fprintf(stderr, "%2x ", comm[i]); + fprintf(stderr, "\n"); +#endif + MDBG_INIT("STCal:"); + for (i=0;i<8;i++) MDBG_ADD("%2x ", comm[i]); + MDBG_FINISH(192); + } + return sanei_scsi_cmd(ms->sfd, comm, 8, 0, 0); +} + + + +/********************************************************************/ +/* magic command to download calibration values */ +/********************************************************************/ +static SANE_Status +download_calibration(Microtek_Scanner *ms, uint8_t *comm, + uint8_t letter, int linewidth) +{ + DBG(23, ".download_calibration... %c %d\n", letter, linewidth); + + comm[0] = 0x0c; + comm[1] = 0x00; + comm[2] = 0x00; + comm[3] = (linewidth >> 8) & 0xFF; + comm[4] = linewidth & 0xFF; + comm[5] = 0x00; + + comm[6] = 0x00; + switch (letter) { + case 'R': comm[7] = 0x40; break; + case 'G': comm[7] = 0x80; break; + case 'B': comm[7] = 0xc0; break; + default: /* XXXXXXX */ break; + } + + return sanei_scsi_cmd(ms->sfd, comm, 6 + linewidth, 0, 0); +} + + + +/********************************************************************/ +/********************************************************************/ +/* */ +/* Myriad of internal functions */ +/* */ +/********************************************************************/ +/********************************************************************/ + + + +/********************************************************************/ +/* Initialize the options registry */ +/********************************************************************/ +static SANE_Status +init_options(Microtek_Scanner *ms) +{ + int i; + SANE_Option_Descriptor *sod = ms->sod; + Option_Value *val = ms->val; + + DBG(15, "init_options...\n"); + + memset(ms->sod, 0, sizeof(ms->sod)); + memset(ms->val, 0, sizeof(ms->val)); + /* default: software selectable word options... */ + for (i=0; i<NUM_OPTIONS; i++) { + sod[i].size = sizeof(SANE_Word); + sod[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + sod[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS; + sod[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + sod[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + sod[OPT_NUM_OPTS].type = SANE_TYPE_INT; + sod[OPT_NUM_OPTS].unit = SANE_UNIT_NONE; + sod[OPT_NUM_OPTS].size = sizeof (SANE_Word); + sod[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + sod[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE; + + /* The Scan Mode Group */ + sod[OPT_MODE_GROUP].name = ""; + sod[OPT_MODE_GROUP].title = "Scan Mode"; + sod[OPT_MODE_GROUP].desc = ""; + sod[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + sod[OPT_MODE_GROUP].cap = 0; + sod[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + sod[OPT_MODE].name = SANE_NAME_SCAN_MODE; + sod[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + sod[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + sod[OPT_MODE].type = SANE_TYPE_STRING; + sod[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + { + SANE_String_Const *mode_list; + mode_list = (SANE_String_Const *) malloc(5 * sizeof(SANE_String_Const)); + if (mode_list == NULL) return SANE_STATUS_NO_MEM; + i = 0; + if (ms->dev->info.modes & MI_MODES_COLOR) mode_list[i++] = M_COLOR; + if (ms->dev->info.modes & MI_MODES_GRAY) mode_list[i++] = M_GRAY; + if (ms->dev->info.modes & MI_MODES_HALFTONE) mode_list[i++] = M_HALFTONE; + if (ms->dev->info.modes & MI_MODES_LINEART) mode_list[i++] = M_LINEART; + mode_list[i] = NULL; + sod[OPT_MODE].constraint.string_list = mode_list; + sod[OPT_MODE].size = max_string_size(mode_list); + val[OPT_MODE].s = strdup(mode_list[0]); + } + + sod[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + sod[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + sod[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + sod[OPT_RESOLUTION].type = SANE_TYPE_FIXED; + sod[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + sod[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE; + { + SANE_Int maxres = ms->dev->info.base_resolution; + + ms->res_range.max = SANE_FIX(maxres); + ms->exp_res_range.max = SANE_FIX(2 * maxres); + if (ms->dev->info.res_step & MI_RESSTEP_1PER) { + DBG(23, "init_options: quant yes\n"); + ms->res_range.min = SANE_FIX( maxres / 100 ); + ms->res_range.quant = ms->res_range.min; + ms->exp_res_range.min = SANE_FIX(2 * maxres / 100); + ms->exp_res_range.quant = ms->exp_res_range.min; + } else { + /* XXXXXXXXXXX */ + DBG(23, "init_options: quant no\n"); + ms->res_range.quant = SANE_FIX( 0 ); + } + sod[OPT_RESOLUTION].constraint.range = &(ms->res_range); + } + val[OPT_RESOLUTION].w = SANE_FIX(100); + + sod[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; + sod[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; + sod[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; + sod[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; + sod[OPT_HALFTONE_PATTERN].size = max_string_size(halftone_mode_list); + sod[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + sod[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST; + sod[OPT_HALFTONE_PATTERN].constraint.string_list = halftone_mode_list; + val[OPT_HALFTONE_PATTERN].s = strdup(halftone_mode_list[0]); + + sod[OPT_NEGATIVE].name = SANE_NAME_NEGATIVE; + sod[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE; + sod[OPT_NEGATIVE].desc = SANE_DESC_NEGATIVE; + sod[OPT_NEGATIVE].type = SANE_TYPE_BOOL; + sod[OPT_NEGATIVE].cap |= + (ms->dev->info.modes & MI_MODES_NEGATIVE) ? 0 : SANE_CAP_INACTIVE; + val[OPT_NEGATIVE].w = SANE_FALSE; + + sod[OPT_SPEED].name = SANE_NAME_SCAN_SPEED; + sod[OPT_SPEED].title = SANE_TITLE_SCAN_SPEED; + /* sod[OPT_SPEED].desc = SANE_DESC_SCAN_SPEED;*/ + sod[OPT_SPEED].desc = "Scan speed throttle -- higher values are *slower*."; + sod[OPT_SPEED].type = SANE_TYPE_INT; + sod[OPT_SPEED].cap |= SANE_CAP_ADVANCED; + sod[OPT_SPEED].unit = SANE_UNIT_NONE; + sod[OPT_SPEED].size = sizeof(SANE_Word); + sod[OPT_SPEED].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_SPEED].constraint.range = &speed_range; + val[OPT_SPEED].w = 1; + + sod[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; + sod[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; + sod[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; + sod[OPT_SOURCE].type = SANE_TYPE_STRING; + sod[OPT_SOURCE].unit = SANE_UNIT_NONE; + sod[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + { + SANE_String_Const *source_list; + source_list = (SANE_String_Const *) malloc(4 * sizeof(SANE_String_Const)); + if (source_list == NULL) return SANE_STATUS_NO_MEM; + i = 0; + source_list[i++] = M_OPAQUE; + if (ms->dev->info.source_options & MI_SRC_HAS_TRANS) + source_list[i++] = M_TRANS; + if (ms->dev->info.source_options & MI_SRC_HAS_FEED) + source_list[i++] = M_AUTOFEED; + source_list[i] = NULL; + sod[OPT_SOURCE].constraint.string_list = source_list; + sod[OPT_SOURCE].size = max_string_size(source_list); + if (i < 2) + sod[OPT_SOURCE].cap |= SANE_CAP_INACTIVE; + val[OPT_SOURCE].s = strdup(source_list[0]); + } + + sod[OPT_PREVIEW].name = SANE_NAME_PREVIEW; + sod[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; + sod[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; + sod[OPT_PREVIEW].type = SANE_TYPE_BOOL; + sod[OPT_PREVIEW].unit = SANE_UNIT_NONE; + sod[OPT_PREVIEW].size = sizeof(SANE_Word); + val[OPT_PREVIEW].w = SANE_FALSE; + + + sod[OPT_GEOMETRY_GROUP].name = ""; + sod[OPT_GEOMETRY_GROUP].title = "Geometry"; + sod[OPT_GEOMETRY_GROUP].desc = ""; + sod[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + sod[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED; + sod[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + + sod[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; + sod[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; + sod[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; + sod[OPT_TL_X].type = SANE_TYPE_FIXED; + sod[OPT_TL_X].unit = SANE_UNIT_MM; + sod[OPT_TL_X].size = sizeof(SANE_Word); + sod[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + + sod[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; + sod[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + sod[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + sod[OPT_TL_Y].type = SANE_TYPE_FIXED; + sod[OPT_TL_Y].unit = SANE_UNIT_MM; + sod[OPT_TL_Y].size = sizeof(SANE_Word); + sod[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + + sod[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; + sod[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; + sod[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; + sod[OPT_BR_X].type = SANE_TYPE_FIXED; + sod[OPT_BR_X].unit = SANE_UNIT_MM; + sod[OPT_BR_X].size = sizeof(SANE_Word); + sod[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + + sod[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; + sod[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + sod[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + sod[OPT_BR_Y].type = SANE_TYPE_FIXED; + sod[OPT_BR_Y].unit = SANE_UNIT_MM; + sod[OPT_BR_Y].size = sizeof(SANE_Word); + sod[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + + sod[OPT_TL_X].constraint.range = + sod[OPT_BR_X].constraint.range = &(ms->dev->info.doc_x_range); + sod[OPT_TL_Y].constraint.range = + sod[OPT_BR_Y].constraint.range = &(ms->dev->info.doc_y_range); + + /* set default scan region to be maximum size */ + val[OPT_TL_X].w = sod[OPT_TL_X].constraint.range->min; + val[OPT_TL_Y].w = sod[OPT_TL_Y].constraint.range->min; + val[OPT_BR_X].w = sod[OPT_BR_X].constraint.range->max; + val[OPT_BR_Y].w = sod[OPT_BR_Y].constraint.range->max; + + sod[OPT_ENHANCEMENT_GROUP].name = ""; + sod[OPT_ENHANCEMENT_GROUP].title = "Enhancement"; + sod[OPT_ENHANCEMENT_GROUP].desc = ""; + sod[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; + sod[OPT_ENHANCEMENT_GROUP].cap = 0; + sod[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + sod[OPT_EXPOSURE].name = "exposure"; + sod[OPT_EXPOSURE].title = "Exposure"; + sod[OPT_EXPOSURE].desc = "Analog exposure control"; + sod[OPT_EXPOSURE].type = SANE_TYPE_INT; + sod[OPT_EXPOSURE].unit = SANE_UNIT_PERCENT; + sod[OPT_EXPOSURE].size = sizeof(SANE_Word); + sod[OPT_EXPOSURE].constraint_type = SANE_CONSTRAINT_RANGE; + ms->exposure_range.min = ms->dev->info.min_exposure; + ms->exposure_range.max = ms->dev->info.max_exposure; + ms->exposure_range.quant = 3; + sod[OPT_EXPOSURE].constraint.range = &(ms->exposure_range); + val[OPT_EXPOSURE].w = 0; + + sod[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; + sod[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; + sod[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + sod[OPT_BRIGHTNESS].type = SANE_TYPE_INT; + sod[OPT_BRIGHTNESS].unit = SANE_UNIT_PERCENT; + sod[OPT_BRIGHTNESS].size = sizeof(SANE_Word); + sod[OPT_BRIGHTNESS].cap |= + ((ms->dev->info.extra_cap & MI_EXCAP_OFF_CTL) ? 0: SANE_CAP_INACTIVE); + sod[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_BRIGHTNESS].constraint.range = &brightness_range; + val[OPT_BRIGHTNESS].w = 0; + + sod[OPT_CONTRAST].name = SANE_NAME_CONTRAST; + sod[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; + sod[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; + sod[OPT_CONTRAST].type = SANE_TYPE_INT; + sod[OPT_CONTRAST].unit = SANE_UNIT_PERCENT; + sod[OPT_CONTRAST].size = sizeof(SANE_Word); + sod[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + ms->contrast_range.min = ms->dev->info.min_contrast; + ms->contrast_range.max = ms->dev->info.max_contrast; + ms->contrast_range.quant = 7; + sod[OPT_CONTRAST].constraint.range = &(ms->contrast_range); + val[OPT_CONTRAST].w = 0; + + + sod[OPT_HIGHLIGHT].name = SANE_NAME_WHITE_LEVEL; + sod[OPT_HIGHLIGHT].title = SANE_TITLE_WHITE_LEVEL; + sod[OPT_HIGHLIGHT].desc = SANE_DESC_WHITE_LEVEL; + sod[OPT_HIGHLIGHT].type = SANE_TYPE_INT; + sod[OPT_HIGHLIGHT].unit = SANE_UNIT_NONE; + sod[OPT_HIGHLIGHT].size = sizeof(SANE_Word); + sod[OPT_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_HIGHLIGHT].constraint.range = &u8_range; + val[OPT_HIGHLIGHT].w = 255; + + sod[OPT_SHADOW].name = SANE_NAME_BLACK_LEVEL; + sod[OPT_SHADOW].title = SANE_TITLE_BLACK_LEVEL; + sod[OPT_SHADOW].desc = SANE_DESC_BLACK_LEVEL; + sod[OPT_SHADOW].type = SANE_TYPE_INT; + sod[OPT_SHADOW].unit = SANE_UNIT_NONE; + sod[OPT_SHADOW].size = sizeof(SANE_Word); + sod[OPT_SHADOW].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_SHADOW].constraint.range = &u8_range; + val[OPT_SHADOW].w = 0; + + if (ms->dev->info.enhance_cap & MI_ENH_CAP_SHADOW) { + sod[OPT_HIGHLIGHT].cap |= SANE_CAP_ADVANCED; + sod[OPT_SHADOW].cap |= SANE_CAP_ADVANCED; + } else { + sod[OPT_HIGHLIGHT].cap |= SANE_CAP_INACTIVE; + sod[OPT_SHADOW].cap |= SANE_CAP_INACTIVE; + } + + sod[OPT_MIDTONE].name = "midtone"; + sod[OPT_MIDTONE].title = "Midtone Level"; + sod[OPT_MIDTONE].desc = "Midtone Level"; + sod[OPT_MIDTONE].type = SANE_TYPE_INT; + sod[OPT_MIDTONE].unit = SANE_UNIT_NONE; + sod[OPT_MIDTONE].size = sizeof(SANE_Word); + sod[OPT_MIDTONE].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_MIDTONE].constraint.range = &u8_range; + val[OPT_MIDTONE].w = 128; + if (ms->midtone_support) { + sod[OPT_MIDTONE].cap |= SANE_CAP_ADVANCED; + } else { + sod[OPT_MIDTONE].cap |= SANE_CAP_INACTIVE; + } + /* XXXXXXXX is this supported by all scanners?? + if ((strcmp(M_COLOR, val[OPT_MODE].s)) && + (strcmp(M_GRAY, val[OPT_MODE].s))) { + sod[OPT_HIGHLIGHT].cap |= SANE_CAP_INACTIVE; + sod[OPT_SHADOW].cap |= SANE_CAP_INACTIVE; + sod[OPT_MIDTONE].cap |= SANE_CAP_INACTIVE; + } + */ + + sod[OPT_GAMMA_GROUP].name = ""; + sod[OPT_GAMMA_GROUP].title = "Gamma Control"; + sod[OPT_GAMMA_GROUP].desc = ""; + sod[OPT_GAMMA_GROUP].type = SANE_TYPE_GROUP; + if (!(ms->gamma_entries)) + sod[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + sod[OPT_CUSTOM_GAMMA].name = "gamma-mode"; + sod[OPT_CUSTOM_GAMMA].title = "Gamma Control Mode"; + sod[OPT_CUSTOM_GAMMA].desc = "How to specify gamma correction, if at all"; + sod[OPT_CUSTOM_GAMMA].type = SANE_TYPE_STRING; + sod[OPT_CUSTOM_GAMMA].size = max_string_size(gamma_mode_list); + sod[OPT_CUSTOM_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST; + sod[OPT_CUSTOM_GAMMA].constraint.string_list = gamma_mode_list; + if (!(ms->gamma_entries)) + sod[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + val[OPT_CUSTOM_GAMMA].s = strdup(gamma_mode_list[0]); + + sod[OPT_GAMMA_BIND].name = SANE_NAME_ANALOG_GAMMA_BIND; + sod[OPT_GAMMA_BIND].title = SANE_TITLE_ANALOG_GAMMA_BIND; + sod[OPT_GAMMA_BIND].desc = SANE_DESC_ANALOG_GAMMA_BIND; + sod[OPT_GAMMA_BIND].type = SANE_TYPE_BOOL; + sod[OPT_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + val[OPT_GAMMA_BIND].w = SANE_TRUE; + + sod[OPT_ANALOG_GAMMA].name = SANE_NAME_ANALOG_GAMMA; + sod[OPT_ANALOG_GAMMA].title = SANE_TITLE_ANALOG_GAMMA; + sod[OPT_ANALOG_GAMMA].desc = SANE_DESC_ANALOG_GAMMA; + sod[OPT_ANALOG_GAMMA].type = SANE_TYPE_FIXED; + sod[OPT_ANALOG_GAMMA].unit = SANE_UNIT_NONE; + sod[OPT_ANALOG_GAMMA].size = sizeof(SANE_Word); + sod[OPT_ANALOG_GAMMA].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_ANALOG_GAMMA].constraint.range = &analog_gamma_range; + val[OPT_ANALOG_GAMMA].w = SANE_FIX(1.0); + + sod[OPT_ANALOG_GAMMA_R].name = SANE_NAME_ANALOG_GAMMA_R; + sod[OPT_ANALOG_GAMMA_R].title = SANE_TITLE_ANALOG_GAMMA_R; + sod[OPT_ANALOG_GAMMA_R].desc = SANE_DESC_ANALOG_GAMMA_R; + sod[OPT_ANALOG_GAMMA_R].type = SANE_TYPE_FIXED; + sod[OPT_ANALOG_GAMMA_R].unit = SANE_UNIT_NONE; + sod[OPT_ANALOG_GAMMA_R].size = sizeof(SANE_Word); + sod[OPT_ANALOG_GAMMA_R].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_R].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_ANALOG_GAMMA_R].constraint.range = &analog_gamma_range; + val[OPT_ANALOG_GAMMA_R].w = SANE_FIX(1.0); + + sod[OPT_ANALOG_GAMMA_G].name = SANE_NAME_ANALOG_GAMMA_G; + sod[OPT_ANALOG_GAMMA_G].title = SANE_TITLE_ANALOG_GAMMA_G; + sod[OPT_ANALOG_GAMMA_G].desc = SANE_DESC_ANALOG_GAMMA_G; + sod[OPT_ANALOG_GAMMA_G].type = SANE_TYPE_FIXED; + sod[OPT_ANALOG_GAMMA_G].unit = SANE_UNIT_NONE; + sod[OPT_ANALOG_GAMMA_G].size = sizeof(SANE_Word); + sod[OPT_ANALOG_GAMMA_G].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_G].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_ANALOG_GAMMA_G].constraint.range = &analog_gamma_range; + val[OPT_ANALOG_GAMMA_G].w = SANE_FIX(1.0); + + sod[OPT_ANALOG_GAMMA_B].name = SANE_NAME_ANALOG_GAMMA_B; + sod[OPT_ANALOG_GAMMA_B].title = SANE_TITLE_ANALOG_GAMMA_B; + sod[OPT_ANALOG_GAMMA_B].desc = SANE_DESC_ANALOG_GAMMA_B; + sod[OPT_ANALOG_GAMMA_B].type = SANE_TYPE_FIXED; + sod[OPT_ANALOG_GAMMA_B].unit = SANE_UNIT_NONE; + sod[OPT_ANALOG_GAMMA_B].size = sizeof(SANE_Word); + sod[OPT_ANALOG_GAMMA_B].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_B].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_ANALOG_GAMMA_B].constraint.range = &analog_gamma_range; + val[OPT_ANALOG_GAMMA_B].w = SANE_FIX(1.0); + + sod[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR; + sod[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR; + sod[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR; + sod[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT; + sod[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE; + sod[OPT_GAMMA_VECTOR].size = ms->gamma_entries * sizeof(SANE_Word); + sod[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_GAMMA_VECTOR].constraint.range = &(ms->gamma_entry_range); + val[OPT_GAMMA_VECTOR].wa = ms->gray_lut; + + sod[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; + sod[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; + sod[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; + sod[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT; + sod[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE; + sod[OPT_GAMMA_VECTOR_R].size = ms->gamma_entries * sizeof(SANE_Word); + sod[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_GAMMA_VECTOR_R].constraint.range = &(ms->gamma_entry_range); + val[OPT_GAMMA_VECTOR_R].wa = ms->red_lut; + + sod[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; + sod[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; + sod[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; + sod[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT; + sod[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE; + sod[OPT_GAMMA_VECTOR_G].size = ms->gamma_entries * sizeof(SANE_Word); + sod[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_GAMMA_VECTOR_G].constraint.range = &(ms->gamma_entry_range); + val[OPT_GAMMA_VECTOR_G].wa = ms->green_lut; + + sod[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; + sod[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; + sod[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; + sod[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT; + sod[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE; + sod[OPT_GAMMA_VECTOR_B].size = ms->gamma_entries * sizeof(SANE_Word); + sod[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE; + sod[OPT_GAMMA_VECTOR_B].constraint.range = &(ms->gamma_entry_range); + val[OPT_GAMMA_VECTOR_B].wa = ms->blue_lut; + + sod[OPT_EXP_RES].name = "exp_res"; + sod[OPT_EXP_RES].title = "Expanded Resolution"; + sod[OPT_EXP_RES].desc = "Enable double-resolution scans"; + sod[OPT_EXP_RES].type = SANE_TYPE_BOOL; + sod[OPT_EXP_RES].cap |= SANE_CAP_ADVANCED; + if (!(ms->dev->info.expanded_resolution)) + sod[OPT_EXP_RES].cap |= SANE_CAP_INACTIVE; + val[OPT_EXP_RES].w = SANE_FALSE; + + sod[OPT_CALIB_ONCE].name = "calib_once"; + sod[OPT_CALIB_ONCE].title = "Calibrate Only Once"; + sod[OPT_CALIB_ONCE].desc = "Avoid CCD calibration on every scan" \ + "(toggle off/on to cause calibration on next scan)"; + sod[OPT_CALIB_ONCE].type = SANE_TYPE_BOOL; + sod[OPT_CALIB_ONCE].cap |= SANE_CAP_ADVANCED; + if (!(ms->do_real_calib)) { + sod[OPT_CALIB_ONCE].cap |= SANE_CAP_INACTIVE; + val[OPT_CALIB_ONCE].w = SANE_FALSE; + } else + val[OPT_CALIB_ONCE].w = SANE_TRUE; + + /* + sod[OPT_].name = SANE_NAME_; + sod[OPT_].title = SANE_TITLE_; + sod[OPT_].desc = SANE_DESC_; + sod[OPT_].type = SANE_TYPE_; + sod[OPT_].unit = SANE_UNIT_NONE; + sod[OPT_].size = sizeof(SANE_Word); + sod[OPT_].cap = 0; + sod[OPT_].constraint_type = SANE_CONSTRAINT_NONE; + sod[OPT_].constraint = ; + val[OPT_].w = ; + */ + + DBG(15, "init_options: done.\n"); + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Parse an INQUIRY information block, as returned by scanner */ +/********************************************************************/ +static SANE_Status +parse_inquiry(Microtek_Info *mi, unsigned char *result) +{ +#if 0 + unsigned char result[0x60] = { + 0x06,0x31,0x23,0x01,0x5b,0x00,0x00,0x00,0x41,0x47,0x46,0x41,0x20,0x20,0x20,0x20, + 0x53,0x74,0x75,0x64,0x69,0x6f,0x53,0x63,0x61,0x6e,0x20,0x49,0x49,0x20,0x20,0x20, + 0x32,0x2e,0x33,0x30,0x53,0x43,0x53,0x49,0x20,0x46,0x2f,0x57,0x56,0x33,0x2e,0x31, + 0x20,0x43,0x54,0x4c,0x35,0x33,0x38,0x30,0x03,0x4f,0x8c,0xc5,0x00,0xee,0x5b,0x43, + 0x01,0x01,0x02,0x00,0x00,0x03,0x00,0x01,0x00,0x4a,0x01,0x04,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff + }; +#endif + DBG(15, "parse_inquiry...\n"); + strncpy(mi->vendor_id, (char *)&result[8], 8); + strncpy(mi->model_name, (char *)&result[16], 16); + strncpy(mi->revision_num, (char *)&result[32], 4); + strncpy(mi->vendor_string, (char *)&result[36], 20); + mi->vendor_id[8] = 0; + mi->model_name[16] = 0; + mi->revision_num[4] = 0; + mi->vendor_string[20] = 0; + + mi->device_type = (SANE_Byte)(result[0] & 0x1f); + mi->SCSI_firmware_ver_major = (SANE_Byte)((result[1] & 0xf0) >> 4); + mi->SCSI_firmware_ver_minor = (SANE_Byte)(result[1] & 0x0f); + mi->scanner_firmware_ver_major = (SANE_Byte)((result[2] & 0xf0) >> 4); + mi->scanner_firmware_ver_minor = (SANE_Byte)(result[2] & 0x0f); + mi->response_data_format = (SANE_Byte)(result[3]); + + mi->res_step = (SANE_Byte)(result[56] & 0x03); + mi->modes = (SANE_Byte)(result[57]); + mi->pattern_count = (SANE_Int)(result[58] & 0x7f); + mi->pattern_dwnld = (SANE_Byte)(result[58] & 0x80) > 0; + mi->feed_type = (SANE_Byte)(result[59] & 0x0F); + mi->compress_type = (SANE_Byte)(result[59] & 0x30); + mi->unit_type = (SANE_Byte)(result[59] & 0xC0); + + mi->doc_size_code = (SANE_Byte)result[60]; + /* we'll compute the max sizes after we know base resolution... */ + + /* why are these things set in two places (and probably wrong anyway)? */ + mi->cont_settings = (SANE_Int)((result[61] & 0xf0) >> 4); + if ((SANE_Int)(result[72])) + mi->cont_settings = (SANE_Int)(result[72]); + mi->min_contrast = -42; + mi->max_contrast = (mi->cont_settings * 7) - 49; + + mi->exp_settings = (SANE_Int)(result[61] & 0x0f); + if ((SANE_Int)(result[73])) + mi->exp_settings = (SANE_Int)(result[73]); + mi->min_exposure = -18; + mi->max_exposure = (mi->exp_settings * 3) - 21; +#if 0 + mi->contrast_vals = (SANE_Int)(result[72]); + mi->min_contrast = -42; + mi->max_contrast = 49; + if (mi->contrast_vals) + mi->max_contrast = (mi->contrast_vals * 7) - 49; + + mi->exposure_vals = (SANE_Int)(result[73]); + mi->min_exposure = -18; + mi->max_exposure = 21; + if (mi->exposure_vals) + mi->max_exposure = (mi->exposure_vals * 3) - 21; +#endif + + mi->model_code = (SANE_Byte)(result[62]); + switch (mi->model_code) { + case 0x16: /* the other ScanMaker 600ZS */ + case 0x50: /* ScanMaker II/IIXE */ + case 0x54: /* ScanMaker IISP */ + case 0x55: /* ScanMaker IIER */ + case 0x58: /* ScanMaker IIG */ + case 0x5a: /* Agfa StudioScan (untested!) */ + case 0x5f: /* ScanMaker E3 */ + case 0x56: /* ScanMaker A3t */ + case 0x64: /* ScanMaker E2 (,Vobis RealScan) */ + case 0x65: /* Color PageWiz */ + case 0xC8: /* ScanMaker 600ZS */ + mi->base_resolution = 300; + break; + case 0x5b: /* Agfa StudioScan II/IIsi (untested!) */ + mi->base_resolution = 400; + break; + case 0x57: /* ScanMaker IIHR */ + case 0x59: /* ScanMaker III */ + case 0x5c: /* Agfa Arcus II */ + case 0x5e: /* Agfa StudioStar */ + case 0x63: /* ScanMaker E6 */ + case 0x66: /* ScanMaker E6 (new)*/ + mi->base_resolution = 600; + break; + case 0x51: /* ScanMaker 45t */ + case 0x5d: /* Agfa DuoScan */ + mi->base_resolution = 1000; + break; + case 0x52: /* ScanMaker 35t */ + mi->base_resolution = 1828; + break; + case 0x62: /* ScanMaker 35t+, Polaroid 35/LE */ + mi->base_resolution = 1950; + break; + default: + mi->base_resolution = 300; + DBG(15, "parse_inquiry: Unknown base resolution for 0x%x!\n", + mi->model_code); + break; + } + + /* Our max_x,y is in pixels. `Some scanners think in 1/8", though.' */ + /* max pixel is, of course, total - 1 */ + switch (mi->doc_size_code) { + case 0x00: + mi->max_x = 8.5 * mi->base_resolution - 1; + mi->max_y = 14.0 * mi->base_resolution - 1; + break; + case 0x01: + mi->max_x = 8.5 * mi->base_resolution - 1; + mi->max_y = 11.0 * mi->base_resolution - 1; + break; + case 0x02: + mi->max_x = 8.5 * mi->base_resolution - 1; + mi->max_y = 11.69 * mi->base_resolution - 1; + break; + case 0x03: + mi->max_x = 8.5 * mi->base_resolution - 1; + mi->max_y = 13.0 * mi->base_resolution - 1; + break; + case 0x04: + mi->max_x = 8.0 * mi->base_resolution - 1; + mi->max_y = 10.0 * mi->base_resolution - 1; + break; + case 0x05: + mi->max_x = 8.3 * mi->base_resolution - 1; + mi->max_y = 14.0 * mi->base_resolution - 1; + break; + case 0x06: + mi->max_x = 8.3 * mi->base_resolution - 1; + mi->max_y = 13.5 * mi->base_resolution - 1; + break; + case 0x07: + mi->max_x = 8.0 * mi->base_resolution - 1; + mi->max_y = 14.0 * mi->base_resolution - 1; + break; + case 0x80: + /* Slide format, size is mm */ + mi->max_x = (35.0 / MM_PER_INCH) * mi->base_resolution - 1; + mi->max_y = (35.0 / MM_PER_INCH) * mi->base_resolution - 1; + break; + case 0x81: + mi->max_x = 5.0 * mi->base_resolution - 1; + mi->max_y = 5.0 * mi->base_resolution - 1; + break; + case 0x82: + /* Slide format, size is mm */ + mi->max_x = (36.0 / MM_PER_INCH) * mi->base_resolution - 1; + mi->max_y = (36.0 / MM_PER_INCH) * mi->base_resolution - 1; + break; + default: + /* Undefined document format code */ + mi->max_x = mi->max_y = 0; + DBG(15, "parse_inquiry: Unknown doc_size_code! 0x%x\n", + mi->doc_size_code); + } + + /* create the proper range constraints, given the doc size */ + { + /* we need base resolution in dots-per-millimeter... */ + float base_res_dpmm = (float) mi->base_resolution / MM_PER_INCH; + mi->doc_x_range.min = SANE_FIX(0); + mi->doc_x_range.max = SANE_FIX((float)mi->max_x / base_res_dpmm); + mi->doc_x_range.quant = SANE_FIX(0); + mi->doc_y_range.min = SANE_FIX(0); + mi->doc_y_range.max = SANE_FIX((float)mi->max_y / base_res_dpmm); + mi->doc_y_range.quant = SANE_FIX(0); + } + + mi->source_options = (SANE_Byte)(result[63]); + + mi->expanded_resolution = (result[64] & 0x01); + /* my E6 reports exp-res capability incorrectly */ + if ((mi->model_code == 0x66) || (mi->model_code == 0x63)) { + mi->expanded_resolution = 0xFF; + DBG(4, "parse_inquiry: E6 falsely denies expanded resolution.\n"); + } + /* the StudioScan II(si) does the expanded-mode aspect correction + within the scanner... (do others too?) */ + if (mi->model_code == 0x5b) { + DBG(4, "parse_inquiry: does expanded-mode expansion internally.\n"); + mi->does_expansion = 1; + } else + mi->does_expansion = 0; + + mi->enhance_cap = (result[65] & 0x03); + + /* + switch (result[66] & 0x0F) { + case 0x00: mi->max_lookup_size = 0; break; + case 0x01: mi->max_lookup_size = 256; break; + case 0x03: mi->max_lookup_size = 1024; break; + case 0x05: mi->max_lookup_size = 4096; break; + case 0x09: mi->max_lookup_size = 65536; break; + default: + mi->max_lookup_size = 0; + DBG(15, "parse_inquiry: Unknown gamma LUT size! 0x%x\n", + result[66]); + } + */ + + /* This is not how the vague documentation specifies this register. + We're going to take it literally here -- i.e. if the bit is + set, the scanner supports the value, otherwise it doesn't. + (The docs say all lower values are always supported. This is + not the case for the StudioScan IIsi, at least, which only + specifies 0x02==1024-byte table, and only supports that, too.) + + All-in-all, it doesn't matter, since we take the largest + allowed LUT size anyway. + */ + if (result[66] & 0x08) + mi->max_lookup_size = 65536; + else if (result[66] & 0x04) + mi->max_lookup_size = 4096; + else if (result[66] & 0x02) + mi->max_lookup_size = 1024; + else if (result[66] & 0x01) + mi->max_lookup_size = 256; + else + mi->max_lookup_size = 0; + + /* my E6 reports incorrectly */ + if ((mi->model_code == 0x66) || (mi->model_code == 0x63)) { + mi->max_lookup_size = 1024; + DBG(4, "parse_inquiry: E6 falsely denies 1024-byte LUT.\n"); + } + + /* + switch (result[66] >> 5) { + case 0x00: mi->max_gamma_val = 255; mi->gamma_size = 1; break; + case 0x01: mi->max_gamma_val = 1023; mi->gamma_size = 2; break; + case 0x02: mi->max_gamma_val = 4095; mi->gamma_size = 2; break; + case 0x03: mi->max_gamma_val = 65535; mi->gamma_size = 2; break; + default: + mi->max_gamma_val = 0; mi->gamma_size = 0; + DBG(15, "parse_inquiry: Unknown gamma max val! 0x%x\n", + result[66]); + } + */ + switch (result[66] >> 5) { + case 0x00: mi->max_gamma_bit_depth = 8; mi->gamma_size = 1; break; + case 0x01: mi->max_gamma_bit_depth = 10; mi->gamma_size = 2; break; + case 0x02: mi->max_gamma_bit_depth = 12; mi->gamma_size = 2; break; + case 0x03: mi->max_gamma_bit_depth = 16; mi->gamma_size = 2; break; + default: + mi->max_gamma_bit_depth = 0; mi->gamma_size = 0; + DBG(15, "parse_inquiry: Unknown gamma max val! 0x%x\n", + result[66]); + } + + mi->fast_color_preview = (SANE_Byte)(result[67] & 0x01); + mi->xfer_format_select = (SANE_Byte)(result[68] & 0x01); + mi->color_sequence = (SANE_Byte)(result[69] & 0x7f); + mi->does_3pass = (SANE_Byte)(!(result[69] & 0x80)); + mi->does_mode1 = (SANE_Byte)(result[71] & 0x01); + + mi->bit_formats = (SANE_Byte)(result[74] & 0x0F); + mi->extra_cap = (SANE_Byte)(result[75] & 0x07); + + /* XXXXXX a quick hack to disable any [pre/real]cal stuff for + anything but an E6... */ + if (!((mi->model_code == 0x66) || (mi->model_code == 0x63))) { + mi->extra_cap &= ~MI_EXCAP_DIS_RECAL; + DBG(4, "parse_inquiry: Not an E6 -- pretend recal cannot be disabled.\n"); + } + + /* The E2 lies... */ + if (mi->model_code == 0x64) { + DBG(4, "parse_inquiry: The E2 lies about it's 3-pass heritage.\n"); + mi->does_3pass = 1; + mi->modes &= ~MI_MODES_ONEPASS; + } + + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* Dump all we know about scanner to stderr */ +/********************************************************************/ +static SANE_Status +dump_inquiry(Microtek_Info *mi, unsigned char *result) +{ + int i; + + DBG(15, "dump_inquiry...\n"); + DBG(1, " === SANE/Microtek backend v%d.%d.%d ===\n", + MICROTEK_MAJOR, MICROTEK_MINOR, MICROTEK_PATCH); + DBG(1, "========== Scanner Inquiry Block ========mm\n"); + for (i=0; i<96; ) { + if (!(i % 16)) MDBG_INIT(""); + MDBG_ADD("%02x ", (int)result[i++]); + if (!(i % 16)) MDBG_FINISH(1); + } + DBG(1, "========== Scanner Inquiry Report ==========\n"); + DBG(1, "===== Scanner ID...\n"); + DBG(1, "Device Type Code: 0x%02x\n", mi->device_type); + DBG(1, "Model Code: 0x%02x\n", mi->model_code); + DBG(1, "Vendor Name: '%s' Model Name: '%s'\n", + mi->vendor_id, mi->model_name); + DBG(1, "Vendor Specific String: '%s'\n", mi->vendor_string); + DBG(1, "Firmware Rev: '%s'\n", mi->revision_num); + DBG(1, + "SCSI F/W version: %1d.%1d Scanner F/W version: %1d.%1d\n", + mi->SCSI_firmware_ver_major, mi->SCSI_firmware_ver_minor, + mi->scanner_firmware_ver_major, mi->scanner_firmware_ver_minor); + DBG(1, "Response data format: 0x%02x\n", mi->response_data_format); + + DBG(1, "===== Imaging Capabilities...\n"); + DBG(1, "Modes: %s%s%s%s%s%s%s\n", + (mi->modes & MI_MODES_LINEART) ? "Lineart " : "", + (mi->modes & MI_MODES_HALFTONE) ? "Halftone " : "", + (mi->modes & MI_MODES_GRAY) ? "Gray " : "", + (mi->modes & MI_MODES_COLOR) ? "Color " : "", + (mi->modes & MI_MODES_TRANSMSV) ? "(X-msv) " : "", + (mi->modes & MI_MODES_ONEPASS) ? "(OnePass) " : "", + (mi->modes & MI_MODES_NEGATIVE) ? "(Negative) " : ""); + DBG(1, + "Resolution Step Sizes: %s%s Expanded Resolution Support? %s%s\n", + (mi->res_step & MI_RESSTEP_1PER) ? "1% " : "", + (mi->res_step & MI_RESSTEP_5PER) ? "5%" : "", + (mi->expanded_resolution) ? "yes" : "no", + (mi->expanded_resolution == 0xFF) ? "(but says no)" : ""); + DBG(1, "Supported Bits Per Sample: %s8 %s%s%s\n", + (mi->bit_formats & MI_FMT_CAP_4BPP) ? "4 " : "", + (mi->bit_formats & MI_FMT_CAP_10BPP) ? "10 " : "", + (mi->bit_formats & MI_FMT_CAP_12BPP) ? "12 " : "", + (mi->bit_formats & MI_FMT_CAP_16BPP) ? "16 " : ""); + DBG(1, "Max. document size code: 0x%02x\n", + mi->doc_size_code); + DBG(1, "Max. document size: %d x %d pixels\n", + mi->max_x, mi->max_y); + DBG(1, "Frame units: %s%s\n", + (mi->unit_type & MI_UNIT_PIXELS) ? "pixels " : "", + (mi->unit_type & MI_UNIT_8TH_INCH) ? "1/8\"'s " : ""); + DBG(1, "# of built-in halftones: %d Downloadable patterns? %s\n", + mi->pattern_count, (mi->pattern_dwnld) ? "Yes" : "No"); + + DBG(1, "Data Compression: %s%s\n", + (mi->compress_type & MI_COMPRSS_HUFF) ? "huffman " : "", + (mi->compress_type & MI_COMPRSS_RD) ? "read-data " : ""); + DBG(1, "Contrast Settings: %d Exposure Settings: %d\n", + mi->cont_settings, mi->exp_settings); + DBG(1, "Adjustable Shadow/Highlight? %s Adjustable Midtone? %s\n", + (mi->enhance_cap & MI_ENH_CAP_SHADOW) ? "yes" : "no ", + (mi->enhance_cap & MI_ENH_CAP_MIDTONE) ? "yes" : "no "); + DBG(1, "Digital brightness/offset? %s\n", + (mi->extra_cap & MI_EXCAP_OFF_CTL) ? "yes" : "no"); + /* + fprintf(stderr, + "Gamma Table Size: %d entries of %d bytes (max. value: %d)\n", + mi->max_lookup_size, mi->gamma_size, mi->max_gamma_val); + */ + DBG(1, + "Gamma Table Size: %d entries of %d bytes (max. depth: %d)\n", + mi->max_lookup_size, mi->gamma_size, mi->max_gamma_bit_depth); + + DBG(1, "===== Source Options...\n"); + DBG(1, "Feed type: %s%s ADF support? %s\n", + (mi->feed_type & MI_FEED_FLATBED) ? "flatbed " : "", + (mi->feed_type & MI_FEED_EDGEFEED) ? "edge-feed " : "", + (mi->feed_type & MI_FEED_AUTOSUPP) ? "yes" : "no"); + DBG(1, "Document Feeder Support? %s Feeder Backtracking? %s\n", + (mi->source_options & MI_SRC_FEED_SUPP) ? "yes" : "no ", + (mi->source_options & MI_SRC_FEED_BT) ? "yes" : "no "); + DBG(1, "Feeder Installed? %s Feeder Ready? %s\n", + (mi->source_options & MI_SRC_HAS_FEED) ? "yes" : "no ", + (mi->source_options & MI_SRC_FEED_RDY) ? "yes" : "no "); + DBG(1, "Transparency Adapter Installed? %s\n", + (mi->source_options & MI_SRC_HAS_TRANS) ? "yes" : "no "); + /* GET_TRANS GET_FEED XXXXXXXXX */ + /* mt_SWslct ???? XXXXXXXXXXX */ + /*#define DOC_ON_FLATBED 0x00 + #define DOC_IN_FEEDER 0x01 + #define TRANSPARENCY 0x10 + */ + DBG(1, "Fast Color Prescan? %s\n", + (mi->fast_color_preview) ? "yes" : "no"); + DBG(1, "Selectable Transfer Format? %s\n", + (mi->xfer_format_select) ? "yes" : "no"); + MDBG_INIT("Color Transfer Sequence: "); + switch (mi->color_sequence) { + case MI_COLSEQ_PLANE: + MDBG_ADD("plane-by-plane (3-pass)"); break; + case MI_COLSEQ_PIXEL: + MDBG_ADD("pixel-by-pixel RGB"); break; + case MI_COLSEQ_RGB: + MDBG_ADD("line-by-line, R-G-B sequence"); break; + case MI_COLSEQ_NONRGB: + MDBG_ADD("line-by-line, non-sequential with headers"); break; + case MI_COLSEQ_2PIXEL: + MDBG_ADD("2pixel-by-2pixel RRGGBB"); break; + default: + MDBG_ADD("UNKNOWN CODE (0x%02x)", mi->color_sequence); + } + MDBG_FINISH(1); + /* if (mi->modes & MI_MODES_ONEPASS) XXXXXXXXXXX */ + DBG(1, "Three pass scan support? %s\n", + (mi->does_3pass ? "yes" : "no")); + DBG(1, "ModeSelect-1 and ModeSense-1 Support? %s\n", + (mi->does_mode1) ? "yes" : "no"); + DBG(1, "Can Disable Linearization Table? %s\n", + (mi->extra_cap & MI_EXCAP_DIS_LNTBL) ? "yes" : "no"); + DBG(1, "Can Disable Start-of-Scan Recalibration? %s\n", + (mi->extra_cap & MI_EXCAP_DIS_RECAL) ? "yes" : "no"); + + DBG(1, "Internal expanded expansion? %s\n", + mi->does_expansion ? "yes" : "no"); + /* + fprintf(stderr, "cntr_vals = %d, min_cntr = %d, max_cntr = %d\n", + cntr_vals, min_cntr, max_cntr); + fprintf(stderr, "exp_vals = %d, min_exp = %d, max_exp = %d\n", + exp_vals, min_exp, max_exp); + */ + DBG(1, "====== End of Scanner Inquiry Report =======\n"); + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Dump all we know about some unknown scanner to stderr */ +/********************************************************************/ +static SANE_Status +dump_suspect_inquiry(unsigned char *result) +{ + int i; + char vendor_id[64], model_name[64], revision_num[16]; + SANE_Byte device_type, model_code; + SANE_Byte SCSI_firmware_ver_major, SCSI_firmware_ver_minor; + SANE_Byte scanner_firmware_ver_major, scanner_firmware_ver_minor; + SANE_Byte response_data_format; + + DBG(15, "dump_suspect_inquiry...\n"); + DBG(1, " === SANE/Microtek backend v%d.%d.%d ===\n", + MICROTEK_MAJOR, MICROTEK_MINOR, MICROTEK_PATCH); + DBG(1, "========== Scanner Inquiry Block ========mm\n"); + for (i=0; i<96; ) { + if (!(i % 16)) MDBG_INIT(""); + MDBG_ADD("%02x ", (int)result[i++]); + if (!(i % 16)) MDBG_FINISH(1); + } +#if 0 + for (i=0; i<96; i++) { + if (!(i % 16) && (i)) fprintf(stderr, "\n"); + fprintf(stderr, "%02x ", (int)result[i]); + } + fprintf(stderr, "\n\n"); +#endif + strncpy(vendor_id, (char *)&result[8], 8); + strncpy(model_name, (char *)&result[16], 16); + strncpy(revision_num, (char *)&result[32], 4); + vendor_id[8] = 0; + model_name[16] = 0; + revision_num[5] = 0; + device_type = (SANE_Byte)(result[0] & 0x1f); + SCSI_firmware_ver_major = (SANE_Byte)((result[1] & 0xf0) >> 4); + SCSI_firmware_ver_minor = (SANE_Byte)(result[1] & 0x0f); + scanner_firmware_ver_major = (SANE_Byte)((result[2] & 0xf0) >> 4); + scanner_firmware_ver_minor = (SANE_Byte)(result[2] & 0x0f); + response_data_format = (SANE_Byte)(result[3]); + model_code = (SANE_Byte)(result[62]); + + DBG(1, "========== Scanner Inquiry Report ==========\n"); + DBG(1, "===== Scanner ID...\n"); + DBG(1, "Device Type Code: 0x%02x\n", device_type); + DBG(1, "Model Code: 0x%02x\n", model_code); + DBG(1, "Vendor Name: '%s' Model Name: '%s'\n", + vendor_id, model_name); + DBG(1, "Firmware Rev: '%s'\n", revision_num); + DBG(1, + "SCSI F/W version: %1d.%1d Scanner F/W version: %1d.%1d\n", + SCSI_firmware_ver_major, SCSI_firmware_ver_minor, + scanner_firmware_ver_major, scanner_firmware_ver_minor); + DBG(1, "Response data format: 0x%02x\n", response_data_format); + DBG(1, "====== End of Scanner Inquiry Report =======\n"); + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Determine if device is a Microtek Scanner (from INQUIRY info) */ +/********************************************************************/ +static SANE_Status +id_microtek(uint8_t *result, char **model_string) +{ + SANE_Byte device_type, response_data_format; + int forcewarn = 0; + + DBG(15, "id_microtek...\n"); + /* check device type first... */ + device_type = (SANE_Byte)(result[0] & 0x1f); + if (device_type != 0x06) { + DBG(15, "id_microtek: not even a scanner: dev_type = %d\n", + device_type); + return SANE_STATUS_INVAL; + } + if (!(strncmp("MICROTEK", (char *)&(result[8]), 8)) || + !(strncmp("MII SC31", (char *)&(result[8]), 8)) || /* the IISP */ + !(strncmp("MII SC21", (char *)&(result[8]), 8)) || /* the 600ZS */ + !(strncmp("MII SC23", (char *)&(result[8]), 8)) || /* the other 600ZS */ + !(strncmp("MII SC25", (char *)&(result[8]), 8)) || /* some other 600GS */ + !(strncmp("AGFA ", (char *)&(result[8]), 8)) || /* Arcus II */ + !(strncmp("Microtek", (char *)&(result[8]), 8)) || /* some 35t+'s */ + !(strncmp("Polaroid", (char *)&(result[8]), 8)) || /* SprintScan 35LE */ + !(strncmp(" ", (char *)&(result[8]), 8)) ) { + switch (result[62]) { + case 0x16 : + *model_string = "ScanMaker 600ZS"; break; + case 0x50 : + *model_string = "ScanMaker II/IIXE"; break; + case 0x51 : + *model_string = "ScanMaker 45t"; break; + case 0x52 : + *model_string = "ScanMaker 35t"; break; + case 0x54 : + *model_string = "ScanMaker IISP"; break; + case 0x55 : + *model_string = "ScanMaker IIER"; break; + case 0x56 : + *model_string = "ScanMaker A3t"; break; + case 0x57 : + *model_string = "ScanMaker IIHR"; break; + case 0x58 : + *model_string = "ScanMaker IIG"; break; + case 0x59 : + *model_string = "ScanMaker III"; break; + case 0x5A : + *model_string = "Agfa StudioScan"; break; + case 0x5B : + *model_string = "Agfa StudioScan II"; break; + case 0x5C : + *model_string = "Agfa Arcus II"; break; + case 0x5f : + *model_string = "ScanMaker E3"; break; + case 0x62 : + if (!(strncmp("Polaroid", (char *)&(result[8]), 8))) + *model_string = "Polaroid SprintScan 35/LE"; + else + *model_string = "ScanMaker 35t+"; + break; + case 0x63 : + case 0x66 : + *model_string = "ScanMaker E6"; break; + case 0x64 : /* and "Vobis RealScan" */ + *model_string = "ScanMaker E2"; break; + case 0x65: + *model_string = "Color PageWiz"; break; + case 0xC8: + *model_string = "ScanMaker 600ZS"; break; + /* the follow are listed in the docs, but are otherwise a mystery... */ + case 0x5D: + *model_string = "Agfa DuoScan"; forcewarn = 1; break; + case 0x5E: + *model_string = "SS3"; forcewarn = 1; break; + case 0x60: + *model_string = "HR1"; forcewarn = 1; break; + case 0x61: + *model_string = "45T+"; forcewarn = 1; break; + case 0x67: + *model_string = "TR3"; forcewarn = 1; break; + default : + /* this might be a newer scanner, which uses the SCSI II command set. */ + /* that's unfortunate, but we'll warn the user anyway.... */ + response_data_format = (SANE_Byte)(result[3]); + if (response_data_format == 0x02) { + DBG(15, "id_microtek: (uses new SCSI II command set)\n"); + if (DBG_LEVEL >= 15) { + DBG(1, "\n"); + DBG(1, "\n"); + DBG(1, "\n"); + DBG(1, "========== Congratulations! ==========\n"); + DBG(1, "You appear to be the proud owner of a \n"); + DBG(1, "brand-new Microtek scanner, which uses\n"); + DBG(1, "a new SCSI II command set. \n"); + DBG(1, "\n"); + DBG(1, "Try the `microtek2' backend instead. \n"); + DBG(1, "\n"); + DBG(1, "\n"); + DBG(1, "\n"); + } + } + return SANE_STATUS_INVAL; + } + if (forcewarn) { + /* force debugging on, to encourage user to send in a report */ +#ifndef NDEBUG + DBG_LEVEL = 1; +#endif + DBG(1, "\n"); + DBG(1, "\n"); + DBG(1, "\n"); + DBG(1, "========== Congratulations! ==========\n"); + DBG(1, "Your scanner appears to be supported \n"); + DBG(1, "by the microtek backend. However, it \n"); + DBG(1, "has never been tried before, and some \n"); + DBG(1, "parameters are bound to be wrong. \n"); + DBG(1, "\n"); + DBG(1, "Please send the scanner inquiry log in\n"); + DBG(1, "its entirety to mtek-bugs@mir.com and \n"); + DBG(1, "include a description of the scanner, \n"); + DBG(1, "including the base optical resolution.\n"); + DBG(1, "\n"); + DBG(1, "You'll find complete instructions for \n"); + DBG(1, "submitting an error/debug log in the \n"); + DBG(1, "'sane-microtek' man-page. \n"); + DBG(1, "\n"); + DBG(1, "\n"); + DBG(1, "\n"); + } + return SANE_STATUS_GOOD; + } + DBG(15, "id_microtek: not microtek: %d, %d, %d\n", + strncmp("MICROTEK", (char *)&(result[8]), 8), + strncmp(" ", (char *)&(result[8]), 8), + result[62]); + return SANE_STATUS_INVAL; +} + + + +/********************************************************************/ +/* Try to attach a device as a Microtek scanner */ +/********************************************************************/ +static SANE_Status +attach_scanner(const char *devicename, Microtek_Device **devp) +{ + Microtek_Device *dev; + int sfd; + size_t size; + unsigned char result[0x60]; + SANE_Status status; + char *model_string; + uint8_t inquiry[] = { 0x12, 0, 0, 0, 0x60, 0 }; + + DBG(15,"attach_scanner: %s\n", devicename); + /* check if device is already known... */ + for (dev = first_dev; dev; dev = dev->next) { + if (strcmp(dev->sane.name, devicename) == 0) { + if (devp) *devp = dev; + return SANE_STATUS_GOOD; + } + } + + /* open scsi device... */ + DBG(20, "attach_scanner: opening %s\n", devicename); + if (sanei_scsi_open(devicename, &sfd, sense_handler, NULL) != 0) { + DBG(20, "attach_scanner: open failed\n"); + return SANE_STATUS_INVAL; + } + + /* say hello... */ + DBG(20, "attach_scanner: sending INQUIRY\n"); + size = sizeof(result); + status = sanei_scsi_cmd(sfd, inquiry, sizeof(inquiry), result, &size); + sanei_scsi_close (sfd); + if (status != SANE_STATUS_GOOD || size != 0x60) { + DBG(20, "attach_scanner: inquiry failed (%s)\n", sane_strstatus (status)); + return status; + } + + if (id_microtek(result, &model_string) != SANE_STATUS_GOOD) { + DBG(15, "attach_scanner: device doesn't look like a Microtek scanner."); + if (DBG_LEVEL >= 5) dump_suspect_inquiry(result); + return SANE_STATUS_INVAL; + } + + dev=malloc(sizeof(*dev)); + if (!dev) return SANE_STATUS_NO_MEM; + memset(dev, 0, sizeof(*dev)); + + parse_inquiry(&(dev->info), result); + if (DBG_LEVEL > 0) dump_inquiry(&(dev->info), result); + + /* initialize dev structure */ + dev->sane.name = strdup(devicename); + dev->sane.vendor = "Microtek"; + dev->sane.model = strdup(model_string); + dev->sane.type = "flatbed scanner"; + + /* link into device list... */ + ++num_devices; + dev->next = first_dev; + first_dev = dev; + if (devp) *devp = dev; + + DBG(15, "attach_scanner: happy.\n"); + + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Attach a scanner (convenience wrapper for find_scanners...) */ +/********************************************************************/ +static SANE_Status +attach_one (const char *dev) +{ + attach_scanner (dev, 0); + return SANE_STATUS_GOOD; +} + + + + +/********************************************************************/ +/* End a scan, and clean up afterwards */ +/********************************************************************/ +static SANE_Status end_scan(Microtek_Scanner *s, SANE_Status ostat) +{ + SANE_Status status; + + DBG(15, "end_scan...\n"); + if (s->scanning) { + s->scanning = SANE_FALSE; + /* stop the scanner */ + if (s->scan_started) { + status = stop_scan(s); + if (status != SANE_STATUS_GOOD) + DBG(23, "end_scan: OY! on stop_scan\n"); + s->scan_started = SANE_FALSE; + } + /* close the SCSI device */ + if (s->sfd != -1) { + sanei_scsi_close(s->sfd); + s->sfd = -1; + } + /* free the buffers we malloc'ed */ + if (s->scsi_buffer != NULL) { + free(s->scsi_buffer); + s->scsi_buffer = NULL; + } + if (s->rb != NULL) { + ring_free(s->rb); + s->rb = NULL; + } + } + /* if this -was- pass 3, or cancel, then we must be done */ + if ((s->this_pass == 3) || (s->cancel)) + s->this_pass = 0; + return ostat; +} + + + +/********************************************************************/ +/********************************************************************/ +/***** Scan-time operations *****/ +/********************************************************************/ +/********************************************************************/ + + +/* number of lines of calibration data returned by scanner */ +#define STRIPS 12 /* well, that's what it seems to be for the E6 */ + + +/* simple comparison for the qsort below */ + +static int comparo(const void *a, const void *b) +{ + return (*(const int *)a - *(const int *)b); +} + + +/* extract values from scanlines and sort */ + +static void sort_values(int *result, uint8_t *scanline[], int pix) +{ + int i; + for (i=0; i<STRIPS; i++) result[i] = (scanline[i])[pix]; + qsort(result, STRIPS, sizeof(result[0]), comparo); +} + + +/********************************************************************/ +/* Calculate the calibration data. */ +/* This seems to be, for each pixel of each R/G/B ccd, the average */ +/* of the STRIPS# values read by the scanner, presumably off some */ +/* blank spot under the cover. */ +/* The raw scanner data does indeed resemble the intensity profile */ +/* of a lamp. */ +/* The sort is used to calc the median, which is used to remove */ +/* outliers in the data; maybe from dust under the cover? */ +/********************************************************************/ + + +static void calc_calibration(uint8_t *caldata, uint8_t *scanline[], + int pixels) +{ + int i,j; + int sorted[STRIPS]; + + DBG(23, ".calc_calibration...\n"); + for (i=0; i<pixels; i++) { + int q1, q3; + int bot, top; + int sum = 0; + int count = 0; + + sort_values(sorted, scanline, i); + q1 = sorted[STRIPS / 4]; /* first quartile */ + q3 = sorted[STRIPS * 3 / 4]; /* third quartile */ + bot = q1 - 3 * (q3 - q1) / 2; /* quick'n'easy bounds */ + top = q3 + 3 * (q3 - q1) / 2; + + for (j=0; j<STRIPS; j++) { + if ((sorted[j] >= bot) && (sorted[j] <= top)) { + sum += sorted[j]; + count++; + } + } + if (count) + caldata[i] = (sum + (count / 2)) / count; + else { + DBG(23, "zero: i=%d b/t=%d/%d ", i, bot, top); + if (DBG_LEVEL >= 23) { + MDBG_INIT(""); + for (j=0; j<STRIPS; j++) MDBG_ADD(" %3d", sorted[j]); + MDBG_FINISH(23); + } + caldata[i] = 0; + } + } +} + + + +/********************************************************************/ +/* Calibrate scanner CCD, the "real" way. */ +/* This stuff is not documented in the command set, but this is */ +/* what Microtek's TWAIN driver seems to do, more or less, on an */ +/* E6 at least. What other scanners will do this??? */ +/********************************************************************/ + + +static SANE_Status do_real_calibrate(Microtek_Scanner *s) +{ + SANE_Status status, statusA; + SANE_Int busy, linewidth, lines; + size_t buffsize; + uint8_t *input, *scanline[STRIPS], *combuff; + uint8_t letter; + int i, spot; + int nmax, ntoget, nleft; + + DBG(10, "do_real_calibrate...\n"); + + /* tell scanner to read it's little chart */ + if ((status = start_calibration(s)) != SANE_STATUS_GOOD) return status; + if ((status = get_scan_status(s, &busy, &linewidth, &lines)) + != SANE_STATUS_GOOD) { + DBG(23, "do_real_cal: get_scan_status failed!\n"); + return status; + } + /* make room for data in and data out */ + input = calloc(STRIPS * 3 * linewidth, sizeof(input[0])); + combuff = calloc(linewidth + 6, sizeof(combuff[0])); + if ((input == NULL) || (combuff == NULL)) { + DBG(23, "do_real_cal: bad calloc %p %p\n", input, combuff); + free(input); + free(combuff); + return SANE_STATUS_NO_MEM; + } + /* read STRIPS lines of R, G, B ccd data */ + nmax = SCSI_BUFF_SIZE / (3 * linewidth); + DBG(23, "do_real_cal: getting data (max=%d)\n", nmax); + for (nleft = STRIPS, spot=0; + nleft > 0; + nleft -= ntoget, spot += buffsize) { + ntoget = (nleft > nmax) ? nmax : nleft; + buffsize = ntoget * 3 * linewidth; + DBG(23, "...nleft %d toget %d size %lu spot %d input+spot %p\n", + nleft, ntoget, (u_long) buffsize, spot, input+spot); + if ((statusA = read_scan_data(s, ntoget, input+spot, &buffsize)) + != SANE_STATUS_GOOD) { + DBG(23, "...read scan failed\n"); + break; + } + } + status = stop_scan(s); + if ((statusA != SANE_STATUS_GOOD) || (status != SANE_STATUS_GOOD)) { + free(input); + free(combuff); + return ((statusA != SANE_STATUS_GOOD) ? statusA : status); + } + /* calculate calibration data for each element and download */ + for (letter = 'R'; letter != 'X'; ) { + DBG(23, "do_real_calibrate: working on %c\n", letter); + for (spot=0, i=0; spot < linewidth * STRIPS * 3; spot += linewidth) { + if (input[spot+1] == letter) { + DBG(23, " found %d (at %d)\n", i, spot); + if (i >= STRIPS) { + DBG(23, "WHOA!!! %i have already been found!\n", i); + break; + } + scanline[i] = &(input[spot+2]); + i++; + } + } + calc_calibration(combuff + 8, scanline, linewidth - 2); + if ((status = download_calibration(s, combuff, letter, linewidth)) + != SANE_STATUS_GOOD) { + DBG(23, "...download_calibration failed\n"); + free(input); + free(combuff); + return status; + } + switch (letter) { + case 'R': letter = 'G'; break; + case 'G': letter = 'B'; break; + case 'B': + default: letter = 'X'; break; + } + } + /* clean up */ + free(input); + free(combuff); + return SANE_STATUS_GOOD; +} + + + + +/********************************************************************/ +/* Cause scanner to calibrate, but don't really scan anything */ +/* (i.e. do everything but read data) */ +/********************************************************************/ +static SANE_Status do_precalibrate(SANE_Handle handle) +{ + Microtek_Scanner *s = handle; + SANE_Status status, statusA; + SANE_Int busy, linewidth, lines; + + DBG(10, "do_precalibrate...\n"); + + if ((status = wait_ready(s)) != SANE_STATUS_GOOD) return status; + { + SANE_Int y1 = s->y1; + SANE_Int y2 = s->y2; + /* some small range, but large enough to cause the scanner + to think it'll scan *something*... */ + s->y1 = 0; + s->y2 = + (s->resolution > s->dev->info.base_resolution) ? + 4 : 4 * s->dev->info.base_resolution / s->resolution; + status = scanning_frame(s); + s->y1 = y1; + s->y2 = y2; + if (status != SANE_STATUS_GOOD) return status; + } + + if (s->dev->info.source_options & + (MI_SRC_FEED_BT | MI_SRC_HAS_TRANS | + MI_SRC_FEED_SUPP | MI_SRC_HAS_FEED)) { /* ZZZZZZZZZZZ */ + if ((status = accessory(s)) != SANE_STATUS_GOOD) return status; + } + if ((status = mode_select(s)) != SANE_STATUS_GOOD) return status; + /* why would we even try if this were not true?... */ + /*if (s->dev->info.extra_cap & MI_EXCAP_DIS_RECAL) */ + { + SANE_Bool allow_calibrate = s->allow_calibrate; + s->allow_calibrate = SANE_TRUE; + status = mode_select_1(s); + s->allow_calibrate = allow_calibrate; + if (status != SANE_STATUS_GOOD) return status; + } + + if ((status = wait_ready(s)) != SANE_STATUS_GOOD) return status; + if ((status = start_scan(s)) != SANE_STATUS_GOOD) return status; + if ((statusA = get_scan_status(s, &busy, + &linewidth, &lines)) != SANE_STATUS_GOOD) { + DBG(10, "do_precalibrate: get_scan_status fails\n"); + } + if ((status = stop_scan(s)) != SANE_STATUS_GOOD) return status; + if ((status = wait_ready(s)) != SANE_STATUS_GOOD) return status; + DBG(10, "do_precalibrate done.\n"); + if (statusA != SANE_STATUS_GOOD) + return statusA; + else + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Calibrate scanner, if necessary; record results */ +/********************************************************************/ +static SANE_Status finagle_precal(SANE_Handle handle) +{ + Microtek_Scanner *s = handle; + SANE_Status status; + int match; + + /* try to check if scanner has been reset */ + /* if so, calibrate it + (either for real, or via a fake scan, with calibration */ + /* (but only bother if you *could* disable calibration) */ + DBG(23, "finagle_precal...\n"); + if ((s->do_clever_precal) || (s->do_real_calib)) { + if ((status = compare_mode_sense(s, &match)) != SANE_STATUS_GOOD) + return status; + if (((s->do_real_calib) && (!s->calib_once)) || /* user want recal */ + (!match) || /* or, possible reset */ + ((s->mode == MS_MODE_COLOR) && /* or, other weirdness */ + (s->precal_record < MS_PRECAL_COLOR)) || + ((s->mode == MS_MODE_COLOR) && + (s->expandedresolution) && + (s->precal_record < MS_PRECAL_EXP_COLOR))) { + DBG(23, "finagle_precal: must precalibrate!\n"); + s->precal_record = MS_PRECAL_NONE; + if (s->do_real_calib) { /* do a real calibration if allowed */ + if ((status = do_real_calibrate(s)) != SANE_STATUS_GOOD) + return status; + } else if (s->do_clever_precal) {/* otherwise do the fake-scan version */ + if ((status = do_precalibrate(s)) != SANE_STATUS_GOOD) + return status; + } + if (s->mode == MS_MODE_COLOR) { + if (s->expandedresolution) + s->precal_record = MS_PRECAL_EXP_COLOR; + else + s->precal_record = MS_PRECAL_COLOR; + } else + s->precal_record = MS_PRECAL_GRAY; + } else + DBG(23, "finagle_precal: no precalibrate necessary.\n"); + } + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* Set pass-dependent parameters (for 3-pass color scans) */ +/********************************************************************/ +static void +set_pass_parameters (SANE_Handle handle) +{ + Microtek_Scanner *s = handle; + + if (s->threepasscolor) { + s->this_pass += 1; + DBG(23, "set_pass_parameters: three-pass, on %d\n", s->this_pass); + switch (s->this_pass) { + case 1: + s->filter = MS_FILT_RED; + s->params.format = SANE_FRAME_RED; + s->params.last_frame = SANE_FALSE; + break; + case 2: + s->filter = MS_FILT_GREEN; + s->params.format = SANE_FRAME_GREEN; + s->params.last_frame = SANE_FALSE; + break; + case 3: + s->filter = MS_FILT_BLUE; + s->params.format = SANE_FRAME_BLUE; + s->params.last_frame = SANE_TRUE; + break; + default: + s->filter = MS_FILT_CLEAR; + DBG(23, "set_pass_parameters: What?!? pass %d = filter?\n", + s->this_pass); + break; + } + } else + s->this_pass = 0; +} + + + +/********************************************************************/ +/********************************************************************/ +/***** Packing functions *****/ +/***** ...process raw scanner bytes, and shove into *****/ +/***** the ring buffer *****/ +/********************************************************************/ +/********************************************************************/ + + +/********************************************************************/ +/* Process flat (byte-by-byte) data */ +/********************************************************************/ +static SANE_Status pack_flat_data(Microtek_Scanner *s, size_t nlines) +{ + SANE_Status status; + ring_buffer *rb = s->rb; + size_t nbytes = nlines * rb->bpl; + + size_t start = (rb->head_complete + rb->complete_count) % rb->size; + size_t max_xfer = + (start < rb->head_complete) ? + (rb->head_complete - start) : + (rb->size - start + rb->head_complete); + size_t length = MIN(nbytes, max_xfer); + + if (nbytes > max_xfer) { + DBG(23, "pack_flat: must expand ring, %lu + %lu\n", + (u_long)rb->size, (u_long)(nbytes - max_xfer)); + status = ring_expand(rb, (nbytes - max_xfer)); + if (status != SANE_STATUS_GOOD) return status; + } + + if (s->doexpansion) { + unsigned int line, bit; + SANE_Byte *sb, *db, byte; + + size_t pos; + + sb = s->scsi_buffer; + db = rb->base; + pos = start; + + if (!(s->multibit)) { + for (line=0; line<nlines; line++) { + size_t i; + double x1, x2, n1, n2; + for (i = 0, x1 = 0.0, x2 = s->exp_aspect, n1 = 0.0, n2 = floor(x2); + i < rb->bpl; + i++) { + byte = 0; + for (bit=0; + bit < 8; + bit++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) { + /* #define getbit(byte, index) (((byte)>>(index))&1) */ + byte |= + (( + (x2 == n2) ? + (((sb[(int)n1 / 8])>>(7 - ((int)n1) % 8))&1) : + (((double)(((sb[(int)n1/8])>>(7-(int)n1%8))&1) * (n2 - x1) + + (double)(((sb[(int)n2/8])>>(7-(int)n2%8))&1) * (x2 - n2) + ) / s->exp_aspect) + ) > 0.5) << (7 - bit); + } + db[pos] = byte; + if (++pos >= rb->size) pos = 0; + } + sb += s->pixel_bpl; + } + } else { /* multibit scan (8 is assumed!) */ + for (line=0; line<nlines; line++) { + double x1, x2, n1, n2; + int i; + for (i = 0, x1 = 0.0, x2 = s->exp_aspect, n1 = 0.0, n2 = floor(x2); + i < s->dest_ppl; + i++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) { + db[pos] = + (x2 == n2) ? + sb[(int)n1] : + (int)(((double)sb[(int)n1] * (n2 - x1) + + (double)sb[(int)n2] * (x2 - n2)) / s->exp_aspect); + if (++pos >= rb->size) pos = 0; + } + sb += s->pixel_bpl; + } + } + } else { + /* adjust for rollover!!! */ + if ((start + length) < rb->size) { + memcpy(rb->base + start, s->scsi_buffer, length); + } else { + size_t chunk1 = rb->size - start; + size_t chunk2 = length - chunk1; + memcpy(rb->base + start, s->scsi_buffer, chunk1); + memcpy(rb->base, s->scsi_buffer + chunk1, chunk2); + } + } + rb->complete_count += length; + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Process sequential R-G-B scan lines (who uses this??? ) */ +/********************************************************************/ +static SANE_Status +pack_seqrgb_data (Microtek_Scanner *s, size_t nlines) +{ + ring_buffer *rb = s->rb; + unsigned int seg; + SANE_Byte *db = rb->base; + SANE_Byte *sb = s->scsi_buffer; + size_t completed; + size_t spot; + SANE_Byte id; + + { + size_t ar, ag, ab; /* allowed additions */ + size_t dr, dg, db; /* additions which will occur */ + SANE_Status status; + + dr = dg = db = nlines * rb->bpl; + ar = rb->size - (rb->complete_count + rb->red_extra * 3); + ag = rb->size - (rb->complete_count + rb->green_extra * 3); + ab = rb->size - (rb->complete_count + rb->blue_extra * 3); + DBG(23, "pack_seq: dr/ar: %lu/%lu dg/ag: %lu/%lu db/ab: %lu/%lu\n", + (u_long)dr, (u_long)ar, + (u_long)dg, (u_long)ag, + (u_long)db, (u_long)ab); + if ((dr > ar) || + (dg > ag) || + (db > ab)) { + size_t increase = 0; + if (dr > ar) increase = (dr - ar); + if (dg > ag) increase = MAX(increase, (dg - ag)); + if (db > ab) increase = MAX(increase, (db - ab)); + DBG(23, "pack_seq: must expand ring, %lu + %lu\n", + (u_long)rb->size, (u_long)increase); + status = ring_expand(rb, increase); + if (status != SANE_STATUS_GOOD) return status; + } + } + + for (seg = 0, id = 0; seg < nlines * 3; seg++, id = (id+1)%3) { + switch (id) { + case 0: spot = rb->tail_red; break; + case 1: spot = rb->tail_green; break; + case 2: spot = rb->tail_blue; break; + default: + DBG(18, "pack_seq: missing scanline RGB header!\n"); + return SANE_STATUS_IO_ERROR; + } + + if (s->doexpansion) { + int i; + double x1, x2, n1, n2; + for (i = 0, x1 = 0.0, x2 = s->exp_aspect, n1 = 0.0, n2 = floor(x2); + i < s->dest_ppl; + i++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) { + db[spot] = + (x2 == n2) ? + sb[(int)n1] : + (int)(((double)sb[(int)n1] * (n2 - x1) + + (double)sb[(int)n2] * (x2 - n2)) / s->exp_aspect); + if ((spot += 3) >= rb->size) spot -= rb->size; + } + sb += s->ppl; + } else { + size_t i; + for (i=0; i < rb->ppl; i++) { + db[spot] = *sb; + sb++; + if ((spot += 3) >= rb->size) spot -= rb->size; + } + } + + switch (id) { + case 0: rb->tail_red = spot; rb->red_extra += rb->ppl; break; + case 1: rb->tail_green = spot; rb->green_extra += rb->ppl; break; + case 2: rb->tail_blue = spot; rb->blue_extra += rb->ppl; break; + } + } + + completed = MIN(rb->red_extra, MIN(rb->green_extra, rb->blue_extra)); + rb->complete_count += completed * 3; /* 3 complete bytes per pixel! */ + rb->red_extra -= completed; + rb->green_extra -= completed; + rb->blue_extra -= completed; + + DBG(18, "pack_seq: extra r: %lu g: %lu b: %lu\n", + (u_long)rb->red_extra, + (u_long)rb->green_extra, + (u_long)rb->blue_extra); + DBG(18, "pack_seq: completed: %lu complete: %lu\n", + (u_long)completed, (u_long)rb->complete_count); + + return SANE_STATUS_GOOD; +} + + +/********************************************************************/ +/* Process non-sequential R,G, and B scan-lines */ +/********************************************************************/ +static SANE_Status +pack_goofyrgb_data(Microtek_Scanner *s, size_t nlines) +{ + ring_buffer *rb = s->rb; + unsigned int seg; /* , i;*/ + SANE_Byte *db; + SANE_Byte *sb = s->scsi_buffer; + size_t completed; + size_t spot; + SANE_Byte id; + + /* prescan to decide if ring should be expanded */ + { + size_t ar, ag, ab; /* allowed additions */ + size_t dr, dg, db; /* additions which will occur */ + SANE_Status status; + SANE_Byte *pt; + + for (dr = dg = db = 0, seg = 0, pt = s->scsi_buffer + 1; + seg < nlines * 3; + seg++, pt += s->ppl + 2) { + switch (*pt) { + case 'R': dr += rb->bpl; break; + case 'G': dg += rb->bpl; break; + case 'B': db += rb->bpl; break; + } + } + ar = rb->size - (rb->complete_count + rb->red_extra * 3); + ag = rb->size - (rb->complete_count + rb->green_extra * 3); + ab = rb->size - (rb->complete_count + rb->blue_extra * 3); + DBG(23, "pack_goofy: dr/ar: %lu/%lu dg/ag: %lu/%lu db/ab: %lu/%lu\n", + (u_long)dr, (u_long)ar, + (u_long)dg, (u_long)ag, + (u_long)db, (u_long)ab); + /* >, or >= ???????? */ + if ((dr > ar) || + (dg > ag) || + (db > ab)) { + size_t increase = 0; + if (dr > ar) increase = (dr - ar); + if (dg > ag) increase = MAX(increase, (dg - ag)); + if (db > ab) increase = MAX(increase, (db - ab)); + DBG(23, "pack_goofy: must expand ring, %lu + %lu\n", + (u_long)rb->size, (u_long)increase); + status = ring_expand(rb, increase); + if (status != SANE_STATUS_GOOD) return status; + } + } + + db = rb->base; + for (seg = 0; seg < nlines * 3; seg++) { + sb++; /* skip first byte in line (two byte header) */ + id = *sb; + switch (id) { + case 'R': spot = rb->tail_red; break; + case 'G': spot = rb->tail_green; break; + case 'B': spot = rb->tail_blue; break; + default: + DBG(18, "pack_goofy: missing scanline RGB header!\n"); + return SANE_STATUS_IO_ERROR; + } + sb++; /* skip the other header byte */ + + if (s->doexpansion) { + int i; + double x1, x2, n1, n2; + for (i = 0, x1 = 0.0, x2 = s->exp_aspect, n1 = 0.0, n2 = floor(x2); + i < s->dest_ppl; + i++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) { + db[spot] = + (x2 == n2) ? + sb[(int)n1] : + (int)(((double)sb[(int)n1] * (n2 - x1) + + (double)sb[(int)n2] * (x2 - n2)) / s->exp_aspect); + if ((spot += 3) >= rb->size) spot -= rb->size; + } + sb += s->ppl; + } else { + unsigned int i; + for (i=0; i < rb->ppl; i++) { + db[spot] = *sb; + sb++; + if ((spot += 3) >= rb->size) spot -= rb->size; + } + } + switch (id) { + case 'R': rb->tail_red = spot; rb->red_extra += rb->ppl; break; + case 'G': rb->tail_green = spot; rb->green_extra += rb->ppl; break; + case 'B': rb->tail_blue = spot; rb->blue_extra += rb->ppl; break; + } + } + + completed = MIN(rb->red_extra, MIN(rb->green_extra, rb->blue_extra)); + rb->complete_count += completed * 3; /* 3 complete bytes per pixel! */ + rb->red_extra -= completed; + rb->green_extra -= completed; + rb->blue_extra -= completed; + + DBG(18, "pack_goofy: extra r: %lu g: %lu b: %lu\n", + (u_long)rb->red_extra, + (u_long)rb->green_extra, + (u_long)rb->blue_extra); + DBG(18, "pack_goofy: completed: %lu complete: %lu\n", + (u_long)completed, (u_long)rb->complete_count); + + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* Process R1R2-G1G2-B1B2 double pixels (AGFA StudioStar) */ +/********************************************************************/ + +static SANE_Status +pack_seq2r2g2b_data(Microtek_Scanner *s, size_t nlines) +{ + SANE_Status status; + ring_buffer *rb = s->rb; + size_t nbytes = nlines * rb->bpl; + + size_t start = (rb->head_complete + rb->complete_count) % rb->size; + size_t max_xfer = + (start < rb->head_complete) ? + (rb->head_complete - start) : + (rb->size - start + rb->head_complete); + size_t length = MIN(nbytes, max_xfer); + + if (nbytes > max_xfer) { + DBG(23, "pack_2r2g2b: must expand ring, %lu + %lu\n", + (u_long)rb->size, (u_long)(nbytes - max_xfer)); + status = ring_expand(rb, (nbytes - max_xfer)); + if (status != SANE_STATUS_GOOD) return status; + } + { + unsigned int line; + int p; + size_t pos = start; + SANE_Byte *sb = s->scsi_buffer; + SANE_Byte *db = rb->base; + + for (line = 0; line < nlines; line++) { + for (p = 0; p < s->dest_ppl; p += 2){ + /* first pixel */ + db[pos] = sb[0]; + if (++pos >= rb->size) pos = 0; /* watch out for ringbuff end? */ + db[pos] = sb[2]; + if (++pos >= rb->size) pos = 0; + db[pos] = sb[4]; + if (++pos >= rb->size) pos = 0; + /* second pixel */ + db[pos] = sb[1]; + if (++pos >= rb->size) pos = 0; + db[pos] = sb[3]; + if (++pos >= rb->size) pos = 0; + db[pos] = sb[5]; + if (++pos >= rb->size) pos = 0; + sb += 6; + } + } + } + rb->complete_count += length; + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/********************************************************************/ +/***** the basic scanning chunks for sane_read() *****/ +/********************************************************************/ +/********************************************************************/ + + +/********************************************************************/ +/* Request bytes from scanner (and put in scsi_buffer) */ +/********************************************************************/ +static SANE_Status +read_from_scanner (Microtek_Scanner *s, int *nlines) +{ + SANE_Status status; + SANE_Int busy, linewidth, remaining; + size_t buffsize; + + DBG(23, "read_from_scanner...\n"); + if (s->unscanned_lines > 0) { + status = get_scan_status(s, &busy, &linewidth, &remaining); + if (status != SANE_STATUS_GOOD) { + DBG(18, "read_from_scanner: bad get_scan_status!\n"); + return status; + } + DBG(18, "read_from_scanner: gss busy, linewidth, remaining: %d, %d, %d\n", + busy, linewidth, remaining); + } else { + DBG(18, "read_from_scanner: no gss/no unscanned\n"); + remaining = 0; + } + + *nlines = MIN(remaining, s->max_scsi_lines); + DBG(18, "sane_read: max_scsi: %d, rem: %d, nlines: %d\n", + s->max_scsi_lines, remaining, *nlines); + + /* grab them bytes! (only if the scanner still has bytes to give...) */ + if (*nlines > 0) { + buffsize = *nlines * (s->pixel_bpl + s->header_bpl);/* == "* linewidth" */ + status = read_scan_data(s, *nlines, s->scsi_buffer, &buffsize); + if (status != SANE_STATUS_GOOD) { + DBG(18, "sane_read: bad read_scan_data!\n"); + return status; + } + s->unscanned_lines -= *nlines; + DBG(18, "sane_read: buffsize: %lu, unscanned: %d\n", + (u_long) buffsize, s->unscanned_lines); + } + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* Process scanner bytes, and shove in ring_buffer */ +/********************************************************************/ +static SANE_Status +pack_into_ring(Microtek_Scanner *s, int nlines) +{ + SANE_Status status; + + DBG(23, "pack_into_ring...\n"); + switch (s->line_format) { + case MS_LNFMT_FLAT: + status = pack_flat_data(s, nlines); break; + case MS_LNFMT_SEQ_RGB: + status = pack_seqrgb_data(s, nlines); break; + case MS_LNFMT_GOOFY_RGB: + status = pack_goofyrgb_data(s, nlines); break; + case MS_LNFMT_SEQ_2R2G2B: + status = pack_seq2r2g2b_data(s, nlines); break; + default: + status = SANE_STATUS_JAMMED; + } + return status; +} + + + +/********************************************************************/ +/* Pack processed image bytes into frontend destination buffer */ +/********************************************************************/ +static SANE_Int +pack_into_dest(SANE_Byte *dest_buffer, size_t dest_length, ring_buffer *rb) +{ + size_t ret_length = MIN(rb->complete_count, dest_length); + + DBG(23, "pack_into_dest...\n"); + DBG(23, "pack_into_dest: rl: %lu sz: %lu hc: %lu\n", + (u_long)ret_length, (u_long)rb->size, (u_long)rb->head_complete); + /* adjust for rollover!!! */ + if ((rb->head_complete + ret_length) < rb->size) { + memcpy(dest_buffer, rb->base + rb->head_complete, ret_length); + rb->head_complete += ret_length; + } else { + size_t chunk1 = rb->size - rb->head_complete; + size_t chunk2 = ret_length - chunk1; + memcpy(dest_buffer, rb->base + rb->head_complete, chunk1); + memcpy(dest_buffer + chunk1, rb->base, chunk2); + rb->head_complete = chunk2; + } + rb->complete_count -= ret_length; + return ret_length; +} + + + +/********************************************************************/ +/********************************************************************/ +/****** "Registered" SANE API Functions *****************************/ +/********************************************************************/ +/********************************************************************/ + + +/********************************************************************/ +/* sane_init() */ +/********************************************************************/ +SANE_Status +sane_init(SANE_Int *version_code, SANE_Auth_Callback authorize) +{ + char dev_name[PATH_MAX]; + size_t len; + FILE *fp; + + authorize = authorize; + DBG_INIT(); + DBG(1, "sane_init: MICROTEK says hello! (v%d.%d.%d)\n", + MICROTEK_MAJOR, MICROTEK_MINOR, MICROTEK_PATCH); + /* return the SANE version we got compiled under */ + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); + + /* parse config file */ + fp = sanei_config_open (MICROTEK_CONFIG_FILE); + if (!fp) { + /* default to /dev/scanner instead of insisting on config file */ + DBG(1, "sane_init: missing config file '%s'\n", MICROTEK_CONFIG_FILE); + attach_scanner("/dev/scanner", 0); + return SANE_STATUS_GOOD; + } + while (sanei_config_read(dev_name, sizeof (dev_name), fp)) { + DBG(23, "sane_init: config-> %s\n", dev_name); + if (dev_name[0] == '#') continue; /* ignore comments */ + if (!(strncmp("noprecal", dev_name, 8))) { + DBG(23, + "sane_init: Clever Precalibration will be forcibly disabled...\n"); + inhibit_clever_precal = SANE_TRUE; + continue; + } + if (!(strncmp("norealcal", dev_name, 9))) { + DBG(23, + "sane_init: Real calibration will be forcibly disabled...\n"); + inhibit_real_calib = SANE_TRUE; + continue; + } + len = strlen (dev_name); + if (!len) continue; /* ignore empty lines */ + sanei_config_attach_matching_devices (dev_name, attach_one); + } + fclose (fp); + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* sane_get_devices */ +/********************************************************************/ +SANE_Status +sane_get_devices(const SANE_Device ***device_list, + SANE_Bool local_only) +{ + Microtek_Device *dev; + int i; + + local_only = local_only; + DBG(10, "sane_get_devices\n"); + /* we keep an internal copy */ + if (devlist) + free(devlist); /* hmm, free it if we want a new one, I guess. YYYYY*/ + + devlist = malloc((num_devices + 1) * sizeof(devlist[0])); + if (!devlist) return SANE_STATUS_NO_MEM; + + for (i=0, dev=first_dev; i < num_devices; dev = dev->next) + devlist[i++] = &dev->sane; + devlist[i++] = 0; + + *device_list = devlist; + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* sane_open */ +/********************************************************************/ +SANE_Status +sane_open(SANE_String_Const devicename, + SANE_Handle *handle) +{ + Microtek_Scanner *scanner; + Microtek_Device *dev; + SANE_Status status; + + DBG(10, "sane_open\n"); + /* find device... */ + DBG(23, "sane_open: find device...\n"); + if (devicename[0]) { + for (dev = first_dev; dev; dev = dev->next) { + if (strcmp(dev->sane.name, devicename) == 0) + break; + } + if (!dev) { /* not in list, try manually... */ + status = attach_scanner(devicename, &dev); + if (status != SANE_STATUS_GOOD) return status; + } + } else { /* no device specified, so use first */ + dev = first_dev; + } + if (!dev) return SANE_STATUS_INVAL; + + /* create a scanner... */ + DBG(23, "sane_open: create scanner...\n"); + scanner = malloc(sizeof(*scanner)); + if (!scanner) return SANE_STATUS_NO_MEM; + memset(scanner, 0, sizeof(*scanner)); + + /* initialize scanner dependent stuff */ + DBG(23, "sane_open: initialize scanner dependent stuff...\n"); + /* ZZZZZZZZZZZZZZ */ + scanner->unit_type = + (dev->info.unit_type & MI_UNIT_PIXELS) ? MS_UNIT_PIXELS : MS_UNIT_18INCH; + scanner->res_type = + (dev->info.res_step & MI_RESSTEP_1PER) ? MS_RES_1PER : MS_RES_5PER; + scanner->midtone_support = + (dev->info.enhance_cap & MI_ENH_CAP_MIDTONE) ? SANE_TRUE : SANE_FALSE; + scanner->paper_length = + (scanner->unit_type == MS_UNIT_PIXELS) ? + dev->info.max_y : + (SANE_Int)((double)dev->info.max_y * 8.0 / + (double)dev->info.base_resolution); + /* + (SANE_Int)(SANE_UNFIX(dev->info.max_y) * dev->info.base_resolution) : + (SANE_Int)(SANE_UNFIX(dev->info.max_y) * 8); + ZZZZZZZ */ + scanner->bright_r = 0; + scanner->bright_g = 0; + scanner->bright_b = 0; + + /* calibration shenanigans */ + if ((dev->info.extra_cap & MI_EXCAP_DIS_RECAL) && + (!(inhibit_real_calib))) { + DBG(23, "sane_open: Real calibration enabled.\n"); + scanner->allow_calibrate = SANE_FALSE; + scanner->do_real_calib = SANE_TRUE; + scanner->do_clever_precal = SANE_FALSE; + } else if ((dev->info.extra_cap & MI_EXCAP_DIS_RECAL) && + (!(inhibit_clever_precal))) { + DBG(23, "sane_open: Clever precalibration enabled.\n"); + scanner->allow_calibrate = SANE_FALSE; + scanner->do_real_calib = SANE_FALSE; + scanner->do_clever_precal = SANE_TRUE; + } else { + DBG(23, "sane_open: All calibration routines disabled.\n"); + scanner->allow_calibrate = SANE_TRUE; + scanner->do_real_calib = SANE_FALSE; + scanner->do_clever_precal = SANE_FALSE; + } + + scanner->onepass = (dev->info.modes & MI_MODES_ONEPASS); + scanner->allowbacktrack = SANE_TRUE; /* ??? XXXXXXX */ + scanner->reversecolors = SANE_FALSE; + scanner->fastprescan = SANE_FALSE; + scanner->bits_per_color = 8; + + /* init gamma tables */ + if (dev->info.max_lookup_size) { + int j, v, max_entry; + DBG(23, "sane_open: init gamma tables...\n"); + scanner->gamma_entries = dev->info.max_lookup_size; + scanner->gamma_entry_size = dev->info.gamma_size; + scanner->gamma_bit_depth = dev->info.max_gamma_bit_depth; + max_entry = (1 << scanner->gamma_bit_depth) - 1; + scanner->gamma_entry_range.min = 0; + scanner->gamma_entry_range.max = max_entry; + scanner->gamma_entry_range.quant = 1; + + scanner->gray_lut = calloc(scanner->gamma_entries, + sizeof(scanner->gray_lut[0])); + scanner->red_lut = calloc(scanner->gamma_entries, + sizeof(scanner->red_lut[0])); + scanner->green_lut = calloc(scanner->gamma_entries, + sizeof(scanner->green_lut[0])); + scanner->blue_lut = calloc(scanner->gamma_entries, + sizeof(scanner->blue_lut[0])); + if ((scanner->gray_lut == NULL) || + (scanner->red_lut == NULL) || + (scanner->green_lut == NULL) || + (scanner->blue_lut == NULL)) { + DBG(23, "sane_open: unable to allocate space for %d-entry LUT's;\n", + scanner->gamma_entries); + DBG(23, " so, gamma tables now DISABLED.\n"); + free(scanner->gray_lut); + free(scanner->red_lut); + free(scanner->green_lut); + free(scanner->blue_lut); + } + for (j=0; j<scanner->gamma_entries; j += scanner->gamma_entry_size) { + v = (SANE_Int) + ((double) j * (double) max_entry / + ((double) scanner->gamma_entries - 1.0) + 0.5); + scanner->gray_lut[j] = v; + scanner->red_lut[j] = v; + scanner->green_lut[j] = v; + scanner->blue_lut[j] = v; + } + } else { + DBG(23, "sane_open: NO gamma tables. (max size = %lu)\n", + (u_long)dev->info.max_lookup_size); + scanner->gamma_entries = 0; + scanner->gray_lut = NULL; + scanner->red_lut = NULL; + scanner->green_lut = NULL; + scanner->blue_lut = NULL; + } + + DBG(23, "sane_open: init pass-time variables...\n"); + scanner->scanning = SANE_FALSE; + scanner->this_pass = 0; + scanner->sfd = -1; + scanner->dev = dev; + scanner->sense_flags = 0; + scanner->scan_started = SANE_FALSE; + scanner->woe = SANE_FALSE; + scanner->cancel = SANE_FALSE; + + DBG(23, "sane_open: init clever cache...\n"); + /* clear out that clever cache, so it doesn't match anything */ + { + int j; + for (j=0; j<10; j++) + scanner->mode_sense_cache[j] = 0; + scanner->precal_record = MS_PRECAL_NONE; + } + + DBG(23, "sane_open: initialize options: \n"); + if ((status = init_options(scanner)) != SANE_STATUS_GOOD) return status; + + scanner->next = first_handle; + first_handle = scanner; + *handle = scanner; + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* sane_close */ +/********************************************************************/ +void +sane_close (SANE_Handle handle) +{ + Microtek_Scanner *ms = handle; + + DBG(10, "sane_close...\n"); + /* free malloc'ed stuff (strdup counts too!) */ + free((void *) ms->sod[OPT_MODE].constraint.string_list); + free((void *) ms->sod[OPT_SOURCE].constraint.string_list); + free(ms->val[OPT_MODE].s); + free(ms->val[OPT_HALFTONE_PATTERN].s); + free(ms->val[OPT_SOURCE].s); + free(ms->val[OPT_CUSTOM_GAMMA].s); + free(ms->gray_lut); + free(ms->red_lut); + free(ms->green_lut); + free(ms->blue_lut); + /* remove Scanner from linked list */ + if (first_handle == ms) + first_handle = ms->next; + else { + Microtek_Scanner *ts = first_handle; + while ((ts != NULL) && (ts->next != ms)) ts = ts->next; + ts->next = ts->next->next; /* == ms->next */ + } + /* finally, say goodbye to the Scanner */ + free(ms); +} + + + +/********************************************************************/ +/* sane_get_option_descriptor */ +/********************************************************************/ +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, + SANE_Int option) +{ + Microtek_Scanner *scanner = handle; + + DBG(96, "sane_get_option_descriptor (%d)...\n", option); + if ((unsigned)option >= NUM_OPTIONS) return NULL; + return &(scanner->sod[option]); +} + + + +/********************************************************************/ +/* sane_control_option */ +/********************************************************************/ +SANE_Status +sane_control_option (SANE_Handle handle, + SANE_Int option, + SANE_Action action, + void *value, + SANE_Int *info) +{ + Microtek_Scanner *scanner = handle; + SANE_Option_Descriptor *sod; + Option_Value *val; + SANE_Status status; + + DBG(96, "sane_control_option (opt=%d,act=%d,val=%p,info=%p)\n", + option, action, value, (void*) info); + + sod = scanner->sod; + val = scanner->val; + + /* no changes while in mid-pass! */ + if (scanner->scanning) return SANE_STATUS_DEVICE_BUSY; + /* and... no changes while in middle of three-pass series! */ + if (scanner->this_pass != 0) return SANE_STATUS_DEVICE_BUSY; + + if ( ((option >= NUM_OPTIONS) || (option < 0)) || + (!SANE_OPTION_IS_ACTIVE(scanner->sod[option].cap)) ) + return SANE_STATUS_INVAL; + + if (info) *info = 0; + + /* choose by action */ + switch (action) { + + case SANE_ACTION_GET_VALUE: + switch (option) { + /* word options... */ + case OPT_RESOLUTION: + case OPT_SPEED: + case OPT_BACKTRACK: + case OPT_NEGATIVE: + case OPT_PREVIEW: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + case OPT_EXPOSURE: + case OPT_BRIGHTNESS: + case OPT_CONTRAST: + case OPT_HIGHLIGHT: + case OPT_SHADOW: + case OPT_MIDTONE: + case OPT_GAMMA_BIND: + case OPT_ANALOG_GAMMA: + case OPT_ANALOG_GAMMA_R: + case OPT_ANALOG_GAMMA_G: + case OPT_ANALOG_GAMMA_B: + case OPT_EXP_RES: + case OPT_CALIB_ONCE: + *(SANE_Word *)value = val[option].w; + return SANE_STATUS_GOOD; + /* word-array options... */ + /* case OPT_HALFTONE_PATTERN:*/ + case OPT_GAMMA_VECTOR: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + memcpy(value, val[option].wa, sod[option].size); + return SANE_STATUS_GOOD; + /* string options... */ + case OPT_MODE: + case OPT_HALFTONE_PATTERN: + case OPT_CUSTOM_GAMMA: + case OPT_SOURCE: + strcpy(value, val[option].s); + return SANE_STATUS_GOOD; + /* others.... */ + case OPT_NUM_OPTS: + *(SANE_Word *) value = NUM_OPTIONS; + return SANE_STATUS_GOOD; + default: + return SANE_STATUS_INVAL; + } + break; + + case SANE_ACTION_SET_VALUE: { + status = sanei_constrain_value(sod + option, value, info); + if (status != SANE_STATUS_GOOD) + return status; + + switch (option) { + /* set word options... */ + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + case OPT_RESOLUTION: + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + case OPT_SPEED: + case OPT_PREVIEW: + case OPT_BACKTRACK: + case OPT_NEGATIVE: + case OPT_EXPOSURE: + case OPT_BRIGHTNESS: + case OPT_CONTRAST: + case OPT_ANALOG_GAMMA: + case OPT_ANALOG_GAMMA_R: + case OPT_ANALOG_GAMMA_G: + case OPT_ANALOG_GAMMA_B: + val[option].w = *(SANE_Word *)value; + return SANE_STATUS_GOOD; + + case OPT_HIGHLIGHT: + case OPT_SHADOW: + case OPT_MIDTONE: + val[option].w = *(SANE_Word *)value; + /* we need to (silently) make sure shadow <= midtone <= highlight */ + if (scanner->midtone_support) { + if (val[OPT_SHADOW].w > val[OPT_MIDTONE].w) { + if (option == OPT_SHADOW) + val[OPT_SHADOW].w = val[OPT_MIDTONE].w; + else + val[OPT_MIDTONE].w = val[OPT_SHADOW].w; + } + if (val[OPT_HIGHLIGHT].w < val[OPT_MIDTONE].w) { + if (option == OPT_HIGHLIGHT) + val[OPT_HIGHLIGHT].w = val[OPT_MIDTONE].w; + else + val[OPT_MIDTONE].w = val[OPT_HIGHLIGHT].w; + } + } else { + if (val[OPT_SHADOW].w > val[OPT_HIGHLIGHT].w) { + if (option == OPT_SHADOW) + val[OPT_SHADOW].w = val[OPT_HIGHLIGHT].w; + else + val[OPT_HIGHLIGHT].w = val[OPT_SHADOW].w; + } + } + return SANE_STATUS_GOOD; + + case OPT_EXP_RES: + if (val[option].w != *(SANE_Word *) value) { + val[option].w = *(SANE_Word *)value; + if (info) *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + if (val[OPT_EXP_RES].w) { + sod[OPT_RESOLUTION].constraint.range = &(scanner->exp_res_range); + val[OPT_RESOLUTION].w *= 2; + } else { + sod[OPT_RESOLUTION].constraint.range = &(scanner->res_range); + val[OPT_RESOLUTION].w /= 2; + } + } + return SANE_STATUS_GOOD; + + case OPT_CALIB_ONCE: + val[option].w = *(SANE_Word *)value; + /* toggling off and on should force a recalibration... */ + if (!(val[option].w)) scanner->precal_record = MS_PRECAL_NONE; + return SANE_STATUS_GOOD; + + case OPT_GAMMA_BIND: + case OPT_CUSTOM_GAMMA: + if (option == OPT_GAMMA_BIND) { + if (val[option].w != *(SANE_Word *) value) + if (info) *info |= SANE_INFO_RELOAD_OPTIONS; + val[option].w = *(SANE_Word *) value; + } else if (option == OPT_CUSTOM_GAMMA) { + if (val[option].s) { + if (strcmp(value, val[option].s)) + if (info) *info |= SANE_INFO_RELOAD_OPTIONS; + free(val[option].s); + } + val[option].s = strdup(value); + } + if ( !(strcmp(val[OPT_CUSTOM_GAMMA].s, M_NONE)) || + !(strcmp(val[OPT_CUSTOM_GAMMA].s, M_SCALAR)) ) { + sod[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } + if ( !(strcmp(val[OPT_CUSTOM_GAMMA].s, M_NONE)) || + !(strcmp(val[OPT_CUSTOM_GAMMA].s, M_TABLE)) ) { + sod[OPT_ANALOG_GAMMA].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_R].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_G].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_B].cap |= SANE_CAP_INACTIVE; + } + if (!(strcmp(val[OPT_CUSTOM_GAMMA].s, M_SCALAR))) { + if (val[OPT_GAMMA_BIND].w == SANE_TRUE) { + sod[OPT_ANALOG_GAMMA].cap &= ~SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_R].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_G].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_B].cap |= SANE_CAP_INACTIVE; + } else { + sod[OPT_ANALOG_GAMMA].cap |= SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_R].cap &= ~SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_G].cap &= ~SANE_CAP_INACTIVE; + sod[OPT_ANALOG_GAMMA_B].cap &= ~SANE_CAP_INACTIVE; + } + } + if (!(strcmp(val[OPT_CUSTOM_GAMMA].s, M_TABLE))) { + if (val[OPT_GAMMA_BIND].w == SANE_TRUE) { + sod[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } else { + sod[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + sod[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + if (!(strcmp(val[OPT_CUSTOM_GAMMA].s, M_NONE))) + sod[OPT_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + else if (!(strcmp(val[OPT_MODE].s, M_COLOR))) + sod[OPT_GAMMA_BIND].cap &= ~SANE_CAP_INACTIVE; + return SANE_STATUS_GOOD; + + + case OPT_MODE: + if (val[option].s) { + if (strcmp(val[option].s, value)) + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + free(val[option].s); + } + val[option].s = strdup(value); + if (strcmp(val[option].s, M_HALFTONE)) { + sod[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + } else { + sod[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + } + if (strcmp(val[option].s, M_COLOR)) { /* not color */ + /*val[OPT_GAMMA_BIND].w = SANE_TRUE;*/ + DBG(23, "FLIP ma LID! bind is %d\n", val[OPT_GAMMA_BIND].w); + { + SANE_Bool Trueness = SANE_TRUE; + SANE_Status status; + status = sane_control_option(handle, + OPT_GAMMA_BIND, + SANE_ACTION_SET_VALUE, + &Trueness, + NULL); + DBG(23, "stat is: %d\n", status); + } + DBG(23, "LID be FLIPPED! bind is %d\n", val[OPT_GAMMA_BIND].w); + sod[OPT_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + /* sod[OPT_FORCE_3PASS].cap |= SANE_CAP_INACTIVE;*/ + } else { + sod[OPT_GAMMA_BIND].cap &= ~SANE_CAP_INACTIVE; + /* if (scanner->dev->info.modes & MI_MODES_ONEPASS) + sod[OPT_FORCE_3PASS].cap &= ~SANE_CAP_INACTIVE;*/ + } + return SANE_STATUS_GOOD; + + case OPT_HALFTONE_PATTERN: + case OPT_SOURCE: + if (val[option].s) free(val[option].s); + val[option].s = strdup(value); + return SANE_STATUS_GOOD; + case OPT_GAMMA_VECTOR: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + memcpy(val[option].wa, value, sod[option].size); + return SANE_STATUS_GOOD; + default: + return SANE_STATUS_INVAL; + } + } + break; + + case SANE_ACTION_SET_AUTO: + return SANE_STATUS_UNSUPPORTED; /* We are DUMB. */ + } + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* sane_get_parameters */ +/********************************************************************/ +SANE_Status +sane_get_parameters (SANE_Handle handle, + SANE_Parameters *params) +{ + Microtek_Scanner *s = handle; + + DBG(23, "sane_get_parameters...\n"); + + if (!s->scanning) { + /* decipher scan mode */ + if (!(strcmp(s->val[OPT_MODE].s, M_LINEART))) + s->mode = MS_MODE_LINEART; + else if (!(strcmp(s->val[OPT_MODE].s, M_HALFTONE))) + s->mode = MS_MODE_HALFTONE; + else if (!(strcmp(s->val[OPT_MODE].s, M_GRAY))) + s->mode = MS_MODE_GRAY; + else if (!(strcmp(s->val[OPT_MODE].s, M_COLOR))) + s->mode = MS_MODE_COLOR; + + if (s->mode == MS_MODE_COLOR) { + if (s->onepass) { + /* regular one-pass */ + DBG(23, "sane_get_parameters: regular 1-pass color\n"); + s->threepasscolor = SANE_FALSE; + s->onepasscolor = SANE_TRUE; + s->color_seq = s->dev->info.color_sequence; + } else { /* 3-pass scanner */ + DBG(23, "sane_get_parameters: regular 3-pass color\n"); + s->threepasscolor = SANE_TRUE; + s->onepasscolor = SANE_FALSE; + s->color_seq = s->dev->info.color_sequence; + } + } else { /* not color! */ + DBG(23, "sane_get_parameters: non-color\n"); + s->threepasscolor = SANE_FALSE; + s->onepasscolor = SANE_FALSE; + s->color_seq = s->dev->info.color_sequence; + } + + s->transparency = !(strcmp(s->val[OPT_SOURCE].s, M_TRANS)); + s->useADF = !(strcmp(s->val[OPT_SOURCE].s, M_AUTOFEED)); + /* disallow exp. res. during preview scan XXXXXXXXXXX */ + /*s->expandedresolution = + (s->val[OPT_EXP_RES].w) && !(s->val[OPT_PREVIEW].w);*/ + s->expandedresolution = (s->val[OPT_EXP_RES].w); + s->doexpansion = (s->expandedresolution && !(s->dev->info.does_expansion)); + + if (s->res_type == MS_RES_1PER) { + s->resolution = (SANE_Int)(SANE_UNFIX(s->val[OPT_RESOLUTION].w)); + s->resolution_code = + 0xFF & ((s->resolution * 100) / + s->dev->info.base_resolution / + (s->expandedresolution ? 2 : 1)); + DBG(23, "sane_get_parameters: res_code = %d (%2x)\n", + s->resolution_code, s->resolution_code); + } else { + DBG(23, "sane_get_parameters: 5 percent!!!\n"); + /* XXXXXXXXXXXXX */ + } + + s->calib_once = s->val[OPT_CALIB_ONCE].w; + + s->reversecolors = s->val[OPT_NEGATIVE].w; + s->prescan = s->val[OPT_PREVIEW].w; + s->exposure = (s->val[OPT_EXPOSURE].w / 3) + 7; + s->contrast = (s->val[OPT_CONTRAST].w / 7) + 7; + s->velocity = s->val[OPT_SPEED].w; + s->shadow = s->val[OPT_SHADOW].w; + s->highlight = s->val[OPT_HIGHLIGHT].w; + s->midtone = s->val[OPT_MIDTONE].w; + if (SANE_OPTION_IS_ACTIVE(s->sod[OPT_BRIGHTNESS].cap)) { +#if 1 /* this is _not_ what the docs specify! */ + if (s->val[OPT_BRIGHTNESS].w >= 0) + s->bright_r = (SANE_Byte) (s->val[OPT_BRIGHTNESS].w); + else + s->bright_r = (SANE_Byte) (0x80 | (- s->val[OPT_BRIGHTNESS].w)); +#else + s->bright_r = (SANE_Byte) (s->val[OPT_BRIGHTNESS].w); +#endif + s->bright_g = s->bright_b = s->bright_r; + DBG(23, "bright_r of %d set to 0x%0x\n", + s->val[OPT_BRIGHTNESS].w, s->bright_r); + } else { + s->bright_r = s->bright_g = s->bright_b = 0; + } + /* figure out halftone pattern selection... */ + if (s->mode == MS_MODE_HALFTONE) { + int i = 0; + while ((halftone_mode_list[i] != NULL) && + (strcmp(halftone_mode_list[i], s->val[OPT_HALFTONE_PATTERN].s))) + i++; + s->pattern = ((i < s->dev->info.pattern_count) ? i : 0); + } else + s->pattern = 0; + + + + { + /* need to 'round' things properly! XXXXXXXX */ + SANE_Int widthpix; + double dots_per_mm = s->resolution / MM_PER_INCH; + double units_per_mm = + (s->unit_type == MS_UNIT_18INCH) ? + (8.0 / MM_PER_INCH) : /* 1/8 inches */ + (s->dev->info.base_resolution / MM_PER_INCH); /* pixels */ + + DBG(23, "sane_get_parameters: dots_per_mm: %f\n", dots_per_mm); + DBG(23, "sane_get_parameters: units_per_mm: %f\n", units_per_mm); + + /* calculate frame coordinates... + * scanner coords are in 'units' -- pixels or 1/8" + * option coords are MM + */ + s->x1 = (SANE_Int)(SANE_UNFIX(s->val[OPT_TL_X].w) * units_per_mm + 0.5); + s->y1 = (SANE_Int)(SANE_UNFIX(s->val[OPT_TL_Y].w) * units_per_mm + 0.5); + s->x2 = (SANE_Int)(SANE_UNFIX(s->val[OPT_BR_X].w) * units_per_mm + 0.5); + s->y2 = (SANE_Int)(SANE_UNFIX(s->val[OPT_BR_Y].w) * units_per_mm + 0.5); + /* bug out if length or width is <= zero... */ + if ((s->x1 >= s->x2) || (s->y1 >= s->y2)) + return SANE_STATUS_INVAL; + + /* these are just an estimate... (but *should* be completely accurate) + * real values come from scanner after sane_start. + */ + if (s->unit_type == MS_UNIT_18INCH) { + /* who *knows* what happens */ + widthpix = + (SANE_Int)((double)(s->x2 - s->x1 + 1) / 8.0 * + (double)s->resolution); + s->params.lines = + (SANE_Int)((double)(s->y2 - s->y1 + 1) / 8.0 * + (double)s->resolution); + } else { + /* calculate pixels per scanline returned by scanner... */ + /* scanner (E6 at least) always seems to return + an -even- number of -bytes- */ + if (s->resolution <= s->dev->info.base_resolution) + widthpix = + (SANE_Int)((double)(s->x2 - s->x1 + 1) * + (double)(s->resolution) / + (double)(s->dev->info.base_resolution)); + else + widthpix = (s->x2 - s->x1 + 1); + if ((s->mode == MS_MODE_LINEART) || + (s->mode == MS_MODE_HALFTONE)) { + DBG(23, "WIDTHPIX: before: %d", widthpix); + widthpix = ((widthpix / 8) & ~0x1) * 8; + DBG(23, "after: %d", widthpix); + } else { + widthpix = widthpix & ~0x1; + } + DBG(23, "WIDTHPIX: before exp: %d\n", widthpix); + /* ok, now fix up expanded-mode conversions */ + if (s->resolution > s->dev->info.base_resolution) + widthpix = (SANE_Int) ((double)widthpix * + (double)s->resolution / + (double)s->dev->info.base_resolution); + s->params.pixels_per_line = widthpix; + s->params.lines = + (SANE_Int)((double)(s->y2 - s->y1 + 1) * + (double)(s->resolution) / + (double)(s->dev->info.base_resolution)); + } + } + + switch (s->mode) { + case MS_MODE_LINEART: + case MS_MODE_HALFTONE: + s->multibit = SANE_FALSE; + s->params.format = SANE_FRAME_GRAY; + s->params.depth = 1; + s->filter = MS_FILT_CLEAR; + s->params.bytes_per_line = s->params.pixels_per_line / 8; + break; + case MS_MODE_GRAY: + s->multibit = SANE_TRUE; + s->params.format = SANE_FRAME_GRAY; + s->params.depth = s->bits_per_color; + s->filter = MS_FILT_CLEAR; + s->params.bytes_per_line = s->params.pixels_per_line; + break; + case MS_MODE_COLOR: + s->multibit = SANE_TRUE; + if (s->onepasscolor) { /* a single-pass color scan */ + s->params.format = SANE_FRAME_RGB; + s->params.depth = s->bits_per_color; + s->filter = MS_FILT_CLEAR; + s->params.bytes_per_line = s->params.pixels_per_line * 3; + } else { /* a three-pass color scan */ + s->params.depth = s->bits_per_color; + /* this will be correctly set in sane_start */ + s->params.format = SANE_FRAME_RED; + s->params.bytes_per_line = s->params.pixels_per_line; + } + break; + } + + DBG(23, "sane_get_parameters: lines: %d ppl: %d bpl: %d\n", + s->params.lines, s->params.pixels_per_line, s->params.bytes_per_line); + + /* also fixed in sane_start for multi-pass scans */ + s->params.last_frame = SANE_TRUE; /* ?? XXXXXXXX */ + } + + if (params) + *params = s->params; + + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* sane_start */ +/********************************************************************/ +static SANE_Status +sane_start_guts (SANE_Handle handle) +{ + Microtek_Scanner *s = handle; + SANE_Status status; + SANE_Int busy, linewidth; + + DBG(10, "sane_start...\n"); + + if (s->sfd != -1) { + DBG(23, "sane_start: sfd already set!\n"); + return SANE_STATUS_DEVICE_BUSY; + } + + if ((status = sane_get_parameters(s, 0)) != SANE_STATUS_GOOD) + return end_scan(s, status); + set_pass_parameters(s); + + s->scanning = SANE_TRUE; + s->cancel = SANE_FALSE; + + status = sanei_scsi_open(s->dev->sane.name, + &(s->sfd), + sense_handler, + &(s->sense_flags)); + if (status != SANE_STATUS_GOOD) { + DBG(10, "sane_start: open of %s failed: %s\n", + s->dev->sane.name, sane_strstatus (status)); + s->sfd = -1; + return end_scan(s, status); + } + + if ((status = wait_ready(s)) != SANE_STATUS_GOOD) return end_scan(s, status); + + if ((status = finagle_precal(s)) != SANE_STATUS_GOOD) + return end_scan(s, status); + + if ((status = scanning_frame(s)) != SANE_STATUS_GOOD) return end_scan(s, status); + if (s->dev->info.source_options & + (MI_SRC_FEED_BT | MI_SRC_HAS_TRANS | + MI_SRC_FEED_SUPP | MI_SRC_HAS_FEED)) { /* ZZZZZZZZZZZ */ + if ((status = accessory(s)) != SANE_STATUS_GOOD) return end_scan(s, status); + /* if SWslct ???? XXXXXXXXXXXXXXX */ + } + if ((status = download_gamma(s)) != SANE_STATUS_GOOD) + return end_scan(s, status); + if ((status = mode_select(s)) != SANE_STATUS_GOOD) + return end_scan(s, status); + if (s->dev->info.does_mode1) { + if ((status = mode_select_1(s)) != SANE_STATUS_GOOD) + return end_scan(s, status); + } + if ((s->do_clever_precal) || (s->do_real_calib)) { + if ((status = save_mode_sense(s)) != SANE_STATUS_GOOD) + return end_scan(s, status); + } + if ((status = wait_ready(s)) != SANE_STATUS_GOOD) return end_scan(s, status); + s->scan_started = SANE_TRUE; + if ((status = start_scan(s)) != SANE_STATUS_GOOD) return end_scan(s, status); + if ((status = get_scan_status(s, &busy, + &linewidth, &(s->unscanned_lines))) != + SANE_STATUS_GOOD) { + DBG(10, "sane_start: get_scan_status fails\n"); + return end_scan(s, status); + } + /* check for a bizarre linecount */ + if ((s->unscanned_lines < 0) || + (s->unscanned_lines > + (s->params.lines * 2 * (s->expandedresolution ? 2 : 1)))) { + DBG(10, "sane_start: get_scan_status returns weird line count %d\n", + s->unscanned_lines); + return end_scan(s, SANE_STATUS_DEVICE_BUSY); + } + + + /* figure out image format parameters */ + switch (s->mode) { + case MS_MODE_LINEART: + case MS_MODE_HALFTONE: + s->pixel_bpl = linewidth; + s->header_bpl = 0; + s->ppl = linewidth * 8; + s->planes = 1; + s->line_format = MS_LNFMT_FLAT; + break; + case MS_MODE_GRAY: + if (s->bits_per_color < 8) { + s->pixel_bpl = linewidth; + s->ppl = linewidth * (8 / s->bits_per_color); + } else { + s->pixel_bpl = linewidth * ((s->bits_per_color + 7) / 8); + s->ppl = linewidth; + } + s->header_bpl = 0; + s->planes = 1; + s->line_format = MS_LNFMT_FLAT; + break; + case MS_MODE_COLOR: + switch (s->color_seq) { + case MI_COLSEQ_PLANE: + s->pixel_bpl = linewidth * ((s->bits_per_color + 7) / 8); + s->ppl = linewidth; + s->header_bpl = 0; + s->planes = 1; + s->line_format = MS_LNFMT_FLAT; + break; + case MI_COLSEQ_NONRGB: + s->pixel_bpl = (linewidth - 2) * 3 * ((s->bits_per_color + 7) / 8); + s->ppl = linewidth - 2; + s->header_bpl = 2 * 3; + s->planes = 3; + s->line_format = MS_LNFMT_GOOFY_RGB; + break; + case MI_COLSEQ_PIXEL: + s->pixel_bpl = linewidth * 3 * ((s->bits_per_color + 7) / 8); + s->ppl = linewidth; + s->header_bpl = 0; + s->planes = 3; + s->line_format = MS_LNFMT_FLAT; + break; + case MI_COLSEQ_2PIXEL: + s->pixel_bpl = linewidth * 3 * ((s->bits_per_color + 7) / 8); + s->ppl = linewidth; + s->header_bpl = 0; + s->planes = 3; + s->line_format = MS_LNFMT_SEQ_2R2G2B; + break; + case MI_COLSEQ_RGB: + s->pixel_bpl = linewidth * 3 * ((s->bits_per_color + 7) / 8); + s->ppl = linewidth; + s->header_bpl = 0; + s->planes = 3; + s->line_format = MS_LNFMT_SEQ_RGB; + break; + default: + DBG(10, "sane_start: Unknown color_sequence: %d\n", + s->dev->info.color_sequence); + return end_scan(s, SANE_STATUS_INVAL); + } + break; + default: + DBG(10, "sane_start: Unknown scan mode: %d\n", s->mode); + return end_scan(s, SANE_STATUS_INVAL); + } + + if ((s->doexpansion) && + (s->resolution > s->dev->info.base_resolution)) { + s->dest_ppl = (int) ((double)s->ppl * + (double)s->resolution / + (double)s->dev->info.base_resolution); + /*+ 0.5 XXXXXX */ + s->exp_aspect = (double)s->ppl / (double)s->dest_ppl; + s->dest_pixel_bpl = (int) ceil((double)s->pixel_bpl / s->exp_aspect); + /*s->exp_aspect = + (double) s->dev->info.base_resolution / (double) s->resolution;*/ + /* s->dest_pixel_bpl = s->pixel_bpl / s->exp_aspect; + s->dest_ppl = s->ppl / s->exp_aspect;*/ + /*s->dest_ppl = s->ppl / s->exp_aspect; + s->dest_pixel_bpl = (int) ceil((double)s->dest_ppl * + (double)s->pixel_bpl / + (double)s->ppl);*/ + } else { + s->exp_aspect = 1.0; + s->dest_pixel_bpl = s->pixel_bpl; + s->dest_ppl = s->ppl; + } + + s->params.lines = s->unscanned_lines; + s->params.pixels_per_line = s->dest_ppl; + s->params.bytes_per_line = s->dest_pixel_bpl; + + /* calculate maximum line capacity of SCSI buffer */ + s->max_scsi_lines = SCSI_BUFF_SIZE / (s->pixel_bpl + s->header_bpl); + if (s->max_scsi_lines < 1) { + DBG(10, "sane_start: SCSI buffer smaller that one scan line!\n"); + return end_scan(s, SANE_STATUS_NO_MEM); + } + + s->scsi_buffer = (uint8_t *) malloc(SCSI_BUFF_SIZE * sizeof(uint8_t)); + if (s->scsi_buffer == NULL) return SANE_STATUS_NO_MEM; + + /* what's a good initial size for this? */ + s->rb = ring_alloc(s->max_scsi_lines * s->dest_pixel_bpl, + s->dest_pixel_bpl, s->dest_ppl); + + s->undelivered_bytes = s->unscanned_lines * s->dest_pixel_bpl; + + DBG(23, "Scan Param:\n"); + DBG(23, "pix bpl: %d hdr bpl: %d ppl: %d\n", + s->pixel_bpl, s->header_bpl, s->ppl); + DBG(23, "undel bytes: %d unscan lines: %d planes: %d\n", + s->undelivered_bytes, s->unscanned_lines, s->planes); + DBG(23, "dest bpl: %d dest ppl: %d aspect: %f\n", + s->dest_pixel_bpl, s->dest_ppl, s->exp_aspect); + + return SANE_STATUS_GOOD; +} + + +SANE_Status +sane_start (SANE_Handle handle) +{ + Microtek_Scanner *s = handle; + SANE_Status status; + + s->woe = SANE_TRUE; + status = sane_start_guts(handle); + s->woe = SANE_FALSE; + return status; +} + + + +/********************************************************************/ +/* sane_read */ +/********************************************************************/ +static SANE_Status +sane_read_guts (SANE_Handle handle, SANE_Byte *dest_buffer, + SANE_Int dest_length, SANE_Int *ret_length) +{ + Microtek_Scanner *s = handle; + SANE_Status status; + int nlines; + ring_buffer *rb = s->rb; + + DBG(10, "sane_read...\n"); + + *ret_length = 0; /* default: no data */ + /* we have been cancelled... */ + if (s->cancel) return end_scan(s, SANE_STATUS_CANCELLED); + /* we're not really scanning!... */ + if (!(s->scanning)) return SANE_STATUS_INVAL; + /* we are done scanning... */ + if (s->undelivered_bytes <= 0) return end_scan(s, SANE_STATUS_EOF); + + /* get more bytes if our ring is empty... */ + while (rb->complete_count == 0) { + if ((status = read_from_scanner(s, &nlines)) != SANE_STATUS_GOOD) { + DBG(18, "sane_read: read_from_scanner failed.\n"); + return end_scan(s, status); + } + if ((status = pack_into_ring(s, nlines)) != SANE_STATUS_GOOD) { + DBG(18, "sane_read: pack_into_ring failed.\n"); + return end_scan(s, status); + } + } + /* return some data to caller */ + *ret_length = pack_into_dest(dest_buffer, dest_length, rb); + s->undelivered_bytes -= *ret_length; + + if (s->cancel) return end_scan(s, SANE_STATUS_CANCELLED); + + return SANE_STATUS_GOOD; +} + + +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte *dest_buffer, + SANE_Int dest_length, SANE_Int *ret_length) +{ + Microtek_Scanner *s = handle; + SANE_Status status; + + s->woe = SANE_TRUE; + status = sane_read_guts(handle, dest_buffer, dest_length, ret_length); + s->woe = SANE_FALSE; + return status; +} + + + +/********************************************************************/ +/* sane_exit */ +/********************************************************************/ +void +sane_exit (void) +{ + Microtek_Device *next; + + DBG(10, "sane_exit...\n"); + /* close all leftover Scanners */ + /*(beware of how sane_close interacts with linked list) */ + while (first_handle != NULL) + sane_close(first_handle); + /* free up device list */ + while (first_dev != NULL) { + next = first_dev->next; + free((void *) first_dev->sane.name); + free((void *) first_dev->sane.model); + free(first_dev); + first_dev = next; + } + /* the devlist allocated by sane_get_devices */ + free(devlist); + DBG(10, "sane_exit: MICROTEK says goodbye.\n"); +} + + + +/********************************************************************/ +/* sane_cancel */ +/********************************************************************/ +void +sane_cancel (SANE_Handle handle) +{ + Microtek_Scanner *ms = handle; + DBG(10, "sane_cancel...\n"); + ms->cancel = SANE_TRUE; + if (!(ms->woe)) end_scan(ms, SANE_STATUS_CANCELLED); +} + + + +/********************************************************************/ +/* sane_set_io_mode */ +/********************************************************************/ +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + DBG(10, "sane_set_io_mode...\n"); + handle = handle; + if (non_blocking) + return SANE_STATUS_UNSUPPORTED; + else + return SANE_STATUS_GOOD; +} + + + +/********************************************************************/ +/* sane_get_select_fd */ +/********************************************************************/ +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + DBG(10, "sane_get_select_fd...\n"); + handle = handle, fd = fd; + return SANE_STATUS_UNSUPPORTED; +} |