summaryrefslogtreecommitdiff
path: root/backend/microtek.c
diff options
context:
space:
mode:
Diffstat (limited to 'backend/microtek.c')
-rw-r--r--backend/microtek.c495
1 files changed, 248 insertions, 247 deletions
diff --git a/backend/microtek.c b/backend/microtek.c
index ff82df4..c3b87ec 100644
--- a/backend/microtek.c
+++ b/backend/microtek.c
@@ -1,7 +1,7 @@
/***************************************************************************
* SANE - Scanner Access Now Easy.
- microtek.c
+ microtek.c
This file Copyright 2002 Matthew Marjanovic
@@ -151,7 +151,7 @@ static SANE_Range brightness_range = {-100, 100, 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 =
+static SANE_Range analog_gamma_range =
{ SANE_FIX(0.1), SANE_FIX(4.0), SANE_FIX(0) };
@@ -235,7 +235,7 @@ ring_alloc (size_t initial_size, size_t bpl, size_t ppl)
rb->green_extra = 0;
rb->blue_extra = 0;
rb->complete_count = 0;
-
+
return rb;
}
@@ -260,7 +260,7 @@ ring_expand (ring_buffer *rb, size_t 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_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,
@@ -276,20 +276,20 @@ ring_expand (ring_buffer *rb, size_t amount)
oldsize - rb->head_complete);
if ((rb->tail_red > rb->head_complete) ||
((rb->tail_red == rb->head_complete) &&
- !(rb->complete_count) && !(rb->red_extra)))
+ !(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->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->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_red, (u_long)rb->tail_green,
(u_long)rb->tail_blue, (u_long)rb->head_complete);
return SANE_STATUS_GOOD;
}
@@ -320,13 +320,13 @@ ring_free (ring_buffer *rb)
/* typically misinterpreted/munged by the low-level scsi driver) */
/********************************************************************/
static SANE_Status
-sense_handler (int scsi_fd, u_char *sense, void *arg)
+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",
+ DBG(10, "sense = %02x %02x %02x %02x.\n",
sense[0], sense[1], sense[2], sense[3]);
switch(sense[0]) {
case 0x00:
@@ -340,7 +340,7 @@ sense_handler (int scsi_fd, u_char *sense, void *arg)
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;
@@ -394,7 +394,7 @@ wait_ready(Microtek_Scanner *ms)
int retry = 0;
DBG(23, ".wait_ready %d...\n", ms->sfd);
- while ((status = sanei_scsi_cmd(ms->sfd, comm, 6, 0, 0))
+ 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 */
@@ -403,7 +403,7 @@ wait_ready(Microtek_Scanner *ms)
}
return SANE_STATUS_GOOD;
}
-
+
/********************************************************************/
/* send scan region coordinates */
@@ -432,7 +432,7 @@ scanning_frame(Microtek_Scanner *ms)
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] =
+ data[0] =
((ms->unit_type == MS_UNIT_PIXELS) ? 0x08 : 0 ) |
((ms->mode == MS_MODE_HALFTONE) ? 0x01 : 0 );
data[1] = x1 & 0xFF;
@@ -444,7 +444,7 @@ scanning_frame(Microtek_Scanner *ms)
data[7] = y2 & 0xFF;
data[8] = (y2 >> 8) & 0xFF;
if (DBG_LEVEL >= 192) {
- int i;
+ int i;
#if 0
fprintf(stderr, "SF: ");
for (i=0;i<6+0x09;i++) fprintf(stderr, "%2x ", comm[i]);
@@ -468,8 +468,8 @@ 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] =
+ data = comm + 6;
+ data[0] =
0x81 |
((ms->unit_type == MS_UNIT_18INCH) ? 0 : 0x08) |
((ms->res_type == MS_RES_5PER) ? 0 : 0x02);
@@ -488,8 +488,8 @@ mode_select(Microtek_Scanner *ms)
comm[4] = (ms->midtone_support) ? 0x0B : 0x0A;
if (DBG_LEVEL >= 192) {
- int i;
-#if 0
+ int i;
+#if 0
fprintf(stderr, "MSL: ");
for (i=0;i<6+comm[4];i++) fprintf(stderr, "%2x ", comm[i]);
fprintf(stderr, "\n");
@@ -518,8 +518,8 @@ mode_select_1(Microtek_Scanner *ms)
data[3] = ((ms->allow_calibrate) ? 0 : 0x02); /* | 0x01; */
if (DBG_LEVEL >= 192) {
- int i;
-#if 0
+ int i;
+#if 0
fprintf(stderr, "MSL1: ");
for (i=0;i<6+0x0A;i++) fprintf(stderr, "%2x ", comm[i]);
fprintf(stderr, "\n");
@@ -532,7 +532,7 @@ mode_select_1(Microtek_Scanner *ms)
}
-
+
/********************************************************************/
/* record mode_sense results in the mode_sense buffer */
/* (this is to tell if something catastrophic has happened */
@@ -556,7 +556,7 @@ save_mode_sense(Microtek_Scanner *ms)
for (i=0; i<10; i++) ms->mode_sense_cache[i] = data[i];
if (DBG_LEVEL >= 192) {
- unsigned int i;
+ unsigned int i;
#if 0
fprintf(stderr, "SMS: ");
for (i=0;i<lenp;i++) fprintf(stderr, "%2x ", data[i]);
@@ -569,8 +569,8 @@ save_mode_sense(Microtek_Scanner *ms)
return status;
}
-
-
+
+
/********************************************************************/
/* read mode_sense and compare to what we saved before */
/********************************************************************/
@@ -590,20 +590,20 @@ compare_mode_sense(Microtek_Scanner *ms, int *match)
status = sanei_scsi_cmd(ms->sfd, comm, 6, data, &lenp);
*match = 1;
- for (i=0; i<10; i++)
+ for (i=0; i<10; i++)
*match = *match && (ms->mode_sense_cache[i] == data[i]);
if (DBG_LEVEL >= 192) {
- unsigned int i;
+ unsigned int i;
#if 0
fprintf(stderr, "CMS: ");
- for (i=0;i<lenp;i++) fprintf(stderr, "%2x(%2x) ",
+ 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) ",
+ for (i=0;i<lenp;i++) MDBG_ADD("%2x(%2x) ",
data[i],
ms->mode_sense_cache[i]);
MDBG_FINISH(192);
@@ -611,10 +611,10 @@ compare_mode_sense(Microtek_Scanner *ms, int *match)
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)
@@ -628,7 +628,7 @@ mode_sense_1(Microtek_Scanner *ms)
data[2] = ms->bright_g;
data[3] = ms->bright_b;
if (DBG_LEVEL >= 192) {
- int i;
+ int i;
fprintf(stderr, "MS1: ");
for (i=0;i<6+0x1E;i++) fprintf(stderr, "%2x ", comm[i]);
fprintf(stderr, "\n");
@@ -639,23 +639,23 @@ mode_sense_1(Microtek_Scanner *ms)
-/********************************************************************/
+/********************************************************************/
/* 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] =
+ comm[4] =
((ms->useADF) ? 0x41 : 0x40) |
((ms->prescan) ? 0x18 : 0x10) |
((ms->transparency) ? 0x24 : 0x20) |
((ms->allowbacktrack) ? 0x82 : 0x80);
if (DBG_LEVEL >= 192) {
- int i;
+ int i;
#if 0
fprintf(stderr, "AC: ");
for (i=0;i<6;i++) fprintf(stderr, "%2x ", comm[i]);
@@ -670,16 +670,16 @@ accessory(Microtek_Scanner *ms)
-/********************************************************************/
+/********************************************************************/
/* 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] =
+ comm[4] =
0x01 | /* "start" */
((ms->expandedresolution) ? 0x80 : 0) |
((ms->multibit) ? 0x40 : 0) |
@@ -691,7 +691,7 @@ start_scan(Microtek_Scanner *ms)
((ms->filter == MS_FILT_BLUE) ? 0x18 : 0) ;
if (DBG_LEVEL >= 192) {
- int i;
+ int i;
#if 0
fprintf(stderr, "SS: ");
for (i=0;i<6;i++) fprintf(stderr, "%2x ", comm[i]);
@@ -706,9 +706,9 @@ start_scan(Microtek_Scanner *ms)
-/********************************************************************/
+/********************************************************************/
/* stop the scanner a-scannin' */
-/********************************************************************/
+/********************************************************************/
static SANE_Status
stop_scan(Microtek_Scanner *ms)
{
@@ -716,8 +716,8 @@ stop_scan(Microtek_Scanner *ms)
DBG(23, ".stop_scan...\n");
if (DBG_LEVEL >= 192) {
- int i;
-#if 0
+ int i;
+#if 0
fprintf(stderr, "SPS:");
for (i=0;i<6;i++) fprintf(stderr, "%2x ", comm[i]);
fprintf(stderr, "\n");
@@ -729,11 +729,11 @@ stop_scan(Microtek_Scanner *ms)
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,
@@ -758,8 +758,8 @@ get_scan_status(Microtek_Scanner *ms,
*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",
+
+ 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]);
@@ -770,20 +770,20 @@ get_scan_status(Microtek_Scanner *ms,
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,
+ uint8_t *buffer,
size_t *bufsize)
{
uint8_t comm[6] = { 0x08, 0, 0, 0, 0, 0 };
@@ -792,15 +792,15 @@ read_scan_data(Microtek_Scanner *ms,
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)
{
@@ -824,7 +824,7 @@ download_gamma(Microtek_Scanner *ms)
}
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);
@@ -835,7 +835,7 @@ download_gamma(Microtek_Scanner *ms)
return SANE_STATUS_NO_MEM;
}
data = comm + 10;
-
+
comm[0] = 0x55;
comm[1] = 0;
comm[2] = 0x27;
@@ -873,9 +873,9 @@ download_gamma(Microtek_Scanner *ms)
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;
+ 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);
@@ -906,7 +906,7 @@ download_gamma(Microtek_Scanner *ms)
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 *
+ int val = (max_entry *
pow((double) i / ((double) ms->gamma_entries - 1.0),
1.0 / gamma));
switch (ms->gamma_entry_size) {
@@ -931,7 +931,7 @@ download_gamma(Microtek_Scanner *ms)
default: gamma = 1.0; break; /* should never happen */
}
for (i=0; i<ms->gamma_entries; i++) {
- int val = (max_entry *
+ int val = (max_entry *
pow((double) i / ((double) ms->gamma_entries - 1.0),
1.0 / gamma));
switch (ms->gamma_entry_size) {
@@ -949,15 +949,15 @@ download_gamma(Microtek_Scanner *ms)
pl++;
} while ((pl < 4) && (status == SANE_STATUS_GOOD));
}
- } else {
+ } 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 =
+ int val =
(double) max_entry * (double) i /
- ((double) ms->gamma_entries - 1.0);
+ ((double) ms->gamma_entries - 1.0);
switch (ms->gamma_entry_size) {
case 1:
data[i] = (uint8_t) val;
@@ -975,9 +975,9 @@ download_gamma(Microtek_Scanner *ms)
}
-/********************************************************************/
+/********************************************************************/
/* magic command to start calibration */
-/********************************************************************/
+/********************************************************************/
static SANE_Status
start_calibration(Microtek_Scanner *ms)
{
@@ -985,7 +985,7 @@ start_calibration(Microtek_Scanner *ms)
DBG(23, ".start_calibrate...\n");
if (DBG_LEVEL >= 192) {
- int i;
+ int i;
#if 0
fprintf(stderr, "STCal:");
for (i=0;i<8;i++) fprintf(stderr, "%2x ", comm[i]);
@@ -995,14 +995,14 @@ start_calibration(Microtek_Scanner *ms)
for (i=0;i<8;i++) MDBG_ADD("%2x ", comm[i]);
MDBG_FINISH(192);
}
- return sanei_scsi_cmd(ms->sfd, comm, 8, 0, 0);
+ 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)
@@ -1042,7 +1042,7 @@ download_calibration(Microtek_Scanner *ms, uint8_t *comm,
/********************************************************************/
/* Initialize the options registry */
/********************************************************************/
-static SANE_Status
+static SANE_Status
init_options(Microtek_Scanner *ms)
{
int i;
@@ -1136,7 +1136,7 @@ init_options(Microtek_Scanner *ms)
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 |=
+ sod[OPT_NEGATIVE].cap |=
(ms->dev->info.modes & MI_MODES_NEGATIVE) ? 0 : SANE_CAP_INACTIVE;
val[OPT_NEGATIVE].w = SANE_FALSE;
@@ -1171,7 +1171,7 @@ init_options(Microtek_Scanner *ms)
source_list[i] = NULL;
sod[OPT_SOURCE].constraint.string_list = source_list;
sod[OPT_SOURCE].size = max_string_size(source_list);
- if (i < 2)
+ if (i < 2)
sod[OPT_SOURCE].cap |= SANE_CAP_INACTIVE;
val[OPT_SOURCE].s = strdup(source_list[0]);
}
@@ -1179,7 +1179,7 @@ init_options(Microtek_Scanner *ms)
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].type = SANE_TYPE_BOOL;
sod[OPT_PREVIEW].unit = SANE_UNIT_NONE;
sod[OPT_PREVIEW].size = sizeof(SANE_Word);
val[OPT_PREVIEW].w = SANE_FALSE;
@@ -1224,10 +1224,10 @@ init_options(Microtek_Scanner *ms)
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_TL_X].constraint.range =
sod[OPT_BR_X].constraint.range = &(ms->dev->info.doc_x_range);
- sod[OPT_TL_Y].constraint.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 */
@@ -1262,7 +1262,7 @@ init_options(Microtek_Scanner *ms)
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 |=
+ 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;
@@ -1308,8 +1308,8 @@ init_options(Microtek_Scanner *ms)
} 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";
@@ -1465,7 +1465,7 @@ init_options(Microtek_Scanner *ms)
if (!(ms->do_real_calib)) {
sod[OPT_CALIB_ONCE].cap |= SANE_CAP_INACTIVE;
val[OPT_CALIB_ONCE].w = SANE_FALSE;
- } else
+ } else
val[OPT_CALIB_ONCE].w = SANE_TRUE;
/*
@@ -1499,7 +1499,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff
};
#endif
DBG(15, "parse_inquiry...\n");
@@ -1511,14 +1511,14 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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);
@@ -1526,7 +1526,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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... */
@@ -1536,7 +1536,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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]);
@@ -1548,7 +1548,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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;
@@ -1606,7 +1606,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
mi->max_x = 8.5 * mi->base_resolution - 1;
mi->max_y = 14.0 * mi->base_resolution - 1;
break;
- case 0x01:
+ case 0x01:
mi->max_x = 8.5 * mi->base_resolution - 1;
mi->max_y = 11.0 * mi->base_resolution - 1;
break;
@@ -1625,15 +1625,15 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
case 0x05:
mi->max_x = 8.3 * mi->base_resolution - 1;
mi->max_y = 14.0 * mi->base_resolution - 1;
- break;
+ break;
case 0x06:
mi->max_x = 8.3 * mi->base_resolution - 1;
mi->max_y = 13.5 * mi->base_resolution - 1;
- break;
+ break;
case 0x07:
mi->max_x = 8.0 * mi->base_resolution - 1;
mi->max_y = 14.0 * mi->base_resolution - 1;
- break;
+ break;
case 0x80:
/* Slide format, size is mm */
mi->max_x = (35.0 / MM_PER_INCH) * mi->base_resolution - 1;
@@ -1666,9 +1666,9 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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->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)) {
@@ -1685,27 +1685,27 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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:
+ 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
+ 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.
*/
@@ -1717,7 +1717,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
mi->max_lookup_size = 1024;
else if (result[66] & 0x01)
mi->max_lookup_size = 256;
- else
+ else
mi->max_lookup_size = 0;
/* my E6 reports incorrectly */
@@ -1748,13 +1748,13 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
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);
@@ -1780,7 +1780,7 @@ parse_inquiry(Microtek_Info *mi, unsigned char *result)
/********************************************************************/
/* Dump all we know about scanner to stderr */
/********************************************************************/
-static SANE_Status
+static SANE_Status
dump_inquiry(Microtek_Info *mi, unsigned char *result)
{
int i;
@@ -1802,12 +1802,12 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
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,
+ 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 " : "",
@@ -1817,7 +1817,7 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
(mi->modes & MI_MODES_TRANSMSV) ? "(X-msv) " : "",
(mi->modes & MI_MODES_ONEPASS) ? "(OnePass) " : "",
(mi->modes & MI_MODES_NEGATIVE) ? "(Negative) " : "");
- DBG(1,
+ 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%" : "",
@@ -1849,11 +1849,11 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
DBG(1, "Digital brightness/offset? %s\n",
(mi->extra_cap & MI_EXCAP_OFF_CTL) ? "yes" : "no");
/*
- fprintf(stderr,
+ 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,
+ 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);
@@ -1861,7 +1861,7 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
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");
+ (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 ");
@@ -1882,15 +1882,15 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
(mi->xfer_format_select) ? "yes" : "no");
MDBG_INIT("Color Transfer Sequence: ");
switch (mi->color_sequence) {
- case MI_COLSEQ_PLANE:
+ case MI_COLSEQ_PLANE:
MDBG_ADD("plane-by-plane (3-pass)"); break;
- case MI_COLSEQ_PIXEL:
+ 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:
+ case MI_COLSEQ_2PIXEL:
MDBG_ADD("2pixel-by-2pixel RRGGBB"); break;
default:
MDBG_ADD("UNKNOWN CODE (0x%02x)", mi->color_sequence);
@@ -1905,7 +1905,7 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
(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");
/*
@@ -1922,7 +1922,7 @@ dump_inquiry(Microtek_Info *mi, unsigned char *result)
/********************************************************************/
/* Dump all we know about some unknown scanner to stderr */
/********************************************************************/
-static SANE_Status
+static SANE_Status
dump_suspect_inquiry(unsigned char *result)
{
int i;
@@ -1953,7 +1953,7 @@ dump_suspect_inquiry(unsigned char *result)
strncpy(revision_num, (char *)&result[32], 4);
vendor_id[8] = 0;
model_name[16] = 0;
- revision_num[5] = 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);
@@ -1969,7 +1969,7 @@ dump_suspect_inquiry(unsigned char *result)
DBG(1, "Vendor Name: '%s' Model Name: '%s'\n",
vendor_id, model_name);
DBG(1, "Firmware Rev: '%s'\n", revision_num);
- DBG(1,
+ 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);
@@ -2035,7 +2035,7 @@ id_microtek(uint8_t *result, char **model_string)
case 0x5f :
*model_string = "ScanMaker E3"; break;
case 0x62 :
- if (!(strncmp("Polaroid", (char *)&(result[8]), 8)))
+ if (!(strncmp("Polaroid", (char *)&(result[8]), 8)))
*model_string = "Polaroid SprintScan 35/LE";
else
*model_string = "ScanMaker 35t+";
@@ -2123,7 +2123,7 @@ id_microtek(uint8_t *result, char **model_string)
/********************************************************************/
/* Try to attach a device as a Microtek scanner */
/********************************************************************/
-static SANE_Status
+static SANE_Status
attach_scanner(const char *devicename, Microtek_Device **devp)
{
Microtek_Device *dev;
@@ -2165,7 +2165,7 @@ attach_scanner(const char *devicename, Microtek_Device **devp)
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));
@@ -2217,7 +2217,7 @@ static SANE_Status end_scan(Microtek_Scanner *s, SANE_Status ostat)
/* stop the scanner */
if (s->scan_started) {
status = stop_scan(s);
- if (status != SANE_STATUS_GOOD)
+ if (status != SANE_STATUS_GOOD)
DBG(23, "end_scan: OY! on stop_scan\n");
s->scan_started = SANE_FALSE;
}
@@ -2285,7 +2285,7 @@ static void sort_values(int *result, uint8_t *scanline[], int pix)
/********************************************************************/
-static void calc_calibration(uint8_t *caldata, uint8_t *scanline[],
+static void calc_calibration(uint8_t *caldata, uint8_t *scanline[],
int pixels)
{
int i,j;
@@ -2303,14 +2303,14 @@ static void calc_calibration(uint8_t *caldata, uint8_t *scanline[],
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)
+ if (count)
caldata[i] = (sum + (count / 2)) / count;
else {
DBG(23, "zero: i=%d b/t=%d/%d ", i, bot, top);
@@ -2343,9 +2343,9 @@ static SANE_Status do_real_calibrate(Microtek_Scanner *s)
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))
@@ -2372,7 +2372,7 @@ static SANE_Status do_real_calibrate(Microtek_Scanner *s)
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))
+ if ((statusA = read_scan_data(s, ntoget, input+spot, &buffsize))
!= SANE_STATUS_GOOD) {
DBG(23, "...read scan failed\n");
break;
@@ -2409,7 +2409,7 @@ static SANE_Status do_real_calibrate(Microtek_Scanner *s)
switch (letter) {
case 'R': letter = 'G'; break;
case 'G': letter = 'B'; break;
- case 'B':
+ case 'B':
default: letter = 'X'; break;
}
}
@@ -2431,9 +2431,9 @@ 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;
@@ -2441,7 +2441,7 @@ static SANE_Status do_precalibrate(SANE_Handle handle)
/* some small range, but large enough to cause the scanner
to think it'll scan *something*... */
s->y1 = 0;
- s->y2 =
+ s->y2 =
(s->resolution > s->dev->info.base_resolution) ?
4 : 4 * s->dev->info.base_resolution / s->resolution;
status = scanning_frame(s);
@@ -2450,7 +2450,7 @@ static SANE_Status do_precalibrate(SANE_Handle handle)
if (status != SANE_STATUS_GOOD) return status;
}
- if (s->dev->info.source_options &
+ 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;
@@ -2465,10 +2465,10 @@ static SANE_Status do_precalibrate(SANE_Handle handle)
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,
+ if ((statusA = get_scan_status(s, &busy,
&linewidth, &lines)) != SANE_STATUS_GOOD) {
DBG(10, "do_precalibrate: get_scan_status fails\n");
}
@@ -2492,7 +2492,7 @@ static SANE_Status finagle_precal(SANE_Handle handle)
int match;
/* try to check if scanner has been reset */
- /* if so, calibrate it
+ /* 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");
@@ -2523,7 +2523,7 @@ static SANE_Status finagle_precal(SANE_Handle handle)
} else
s->precal_record = MS_PRECAL_GRAY;
} else
- DBG(23, "finagle_precal: no precalibrate necessary.\n");
+ DBG(23, "finagle_precal: no precalibrate necessary.\n");
}
return SANE_STATUS_GOOD;
}
@@ -2544,7 +2544,7 @@ set_pass_parameters (SANE_Handle handle)
switch (s->this_pass) {
case 1:
s->filter = MS_FILT_RED;
- s->params.format = SANE_FRAME_RED;
+ s->params.format = SANE_FRAME_RED;
s->params.last_frame = SANE_FALSE;
break;
case 2:
@@ -2552,7 +2552,7 @@ set_pass_parameters (SANE_Handle handle)
s->params.format = SANE_FRAME_GREEN;
s->params.last_frame = SANE_FALSE;
break;
- case 3:
+ case 3:
s->filter = MS_FILT_BLUE;
s->params.format = SANE_FRAME_BLUE;
s->params.last_frame = SANE_TRUE;
@@ -2588,7 +2588,7 @@ static SANE_Status pack_flat_data(Microtek_Scanner *s, size_t nlines)
size_t nbytes = nlines * rb->bpl;
size_t start = (rb->head_complete + rb->complete_count) % rb->size;
- size_t max_xfer =
+ size_t max_xfer =
(start < rb->head_complete) ?
(rb->head_complete - start) :
(rb->size - start + rb->head_complete);
@@ -2616,14 +2616,14 @@ static SANE_Status pack_flat_data(Microtek_Scanner *s, size_t nlines)
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 < rb->bpl;
i++) {
byte = 0;
- for (bit=0;
- bit < 8;
+ 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 |=
+ byte |=
((
(x2 == n2) ?
(((sb[(int)n1 / 8])>>(7 - ((int)n1) % 8))&1) :
@@ -2638,13 +2638,13 @@ static SANE_Status pack_flat_data(Microtek_Scanner *s, size_t nlines)
sb += s->pixel_bpl;
}
} else { /* multibit scan (8 is assumed!) */
- for (line=0; line<nlines; line++) {
+ 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 < s->dest_ppl;
i++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) {
- db[pos] =
+ db[pos] =
(x2 == n2) ?
sb[(int)n1] :
(int)(((double)sb[(int)n1] * (n2 - x1) +
@@ -2683,12 +2683,12 @@ pack_seqrgb_data (Microtek_Scanner *s, size_t nlines)
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);
@@ -2700,7 +2700,7 @@ pack_seqrgb_data (Microtek_Scanner *s, size_t nlines)
if ((dr > ar) ||
(dg > ag) ||
(db > ab)) {
- size_t increase = 0;
+ 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));
@@ -2725,9 +2725,9 @@ pack_seqrgb_data (Microtek_Scanner *s, size_t nlines)
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 < s->dest_ppl;
i++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) {
- db[spot] =
+ db[spot] =
(x2 == n2) ?
sb[(int)n1] :
(int)(((double)sb[(int)n1] * (n2 - x1) +
@@ -2756,9 +2756,9 @@ pack_seqrgb_data (Microtek_Scanner *s, size_t nlines)
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->red_extra,
(u_long)rb->green_extra,
(u_long)rb->blue_extra);
DBG(18, "pack_seq: completed: %lu complete: %lu\n",
@@ -2767,21 +2767,21 @@ pack_seqrgb_data (Microtek_Scanner *s, size_t nlines)
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;
+ 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 */
@@ -2790,7 +2790,7 @@ pack_goofyrgb_data(Microtek_Scanner *s, size_t nlines)
SANE_Byte *pt;
for (dr = dg = db = 0, seg = 0, pt = s->scsi_buffer + 1;
- seg < nlines * 3;
+ seg < nlines * 3;
seg++, pt += s->ppl + 2) {
switch (*pt) {
case 'R': dr += rb->bpl; break;
@@ -2809,7 +2809,7 @@ pack_goofyrgb_data(Microtek_Scanner *s, size_t nlines)
if ((dr > ar) ||
(dg > ag) ||
(db > ab)) {
- size_t increase = 0;
+ 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));
@@ -2838,9 +2838,9 @@ pack_goofyrgb_data(Microtek_Scanner *s, size_t nlines)
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 < s->dest_ppl;
i++, x1 = x2, n1 = n2, x2 += s->exp_aspect, n2 = floor(x2)) {
- db[spot] =
+ db[spot] =
(x2 == n2) ?
sb[(int)n1] :
(int)(((double)sb[(int)n1] * (n2 - x1) +
@@ -2868,9 +2868,9 @@ pack_goofyrgb_data(Microtek_Scanner *s, size_t nlines)
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->red_extra,
(u_long)rb->green_extra,
(u_long)rb->blue_extra);
DBG(18, "pack_goofy: completed: %lu complete: %lu\n",
@@ -2878,7 +2878,7 @@ pack_goofyrgb_data(Microtek_Scanner *s, size_t nlines)
return SANE_STATUS_GOOD;
}
-
+
/********************************************************************/
@@ -2891,14 +2891,14 @@ 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 =
+ 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));
@@ -2908,7 +2908,7 @@ pack_seq2r2g2b_data(Microtek_Scanner *s, size_t nlines)
{
unsigned int line;
int p;
- size_t pos = start;
+ size_t pos = start;
SANE_Byte *sb = s->scsi_buffer;
SANE_Byte *db = rb->base;
@@ -2968,11 +2968,11 @@ read_from_scanner (Microtek_Scanner *s, int *nlines)
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" */
@@ -3002,7 +3002,7 @@ pack_into_ring(Microtek_Scanner *s, int nlines)
switch (s->line_format) {
case MS_LNFMT_FLAT:
status = pack_flat_data(s, nlines); break;
- case MS_LNFMT_SEQ_RGB:
+ case MS_LNFMT_SEQ_RGB:
status = pack_seqrgb_data(s, nlines); break;
case MS_LNFMT_GOOFY_RGB:
status = pack_goofyrgb_data(s, nlines); break;
@@ -3081,13 +3081,13 @@ sane_init(SANE_Int *version_code, SANE_Auth_Callback authorize)
DBG(23, "sane_init: config-> %s\n", dev_name);
if (dev_name[0] == '#') continue; /* ignore comments */
if (!(strncmp("noprecal", dev_name, 8))) {
- DBG(23,
+ 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,
+ DBG(23,
"sane_init: Real calibration will be forcibly disabled...\n");
inhibit_real_calib = SANE_TRUE;
continue;
@@ -3106,7 +3106,7 @@ sane_init(SANE_Int *version_code, SANE_Auth_Callback authorize)
/* sane_get_devices */
/********************************************************************/
SANE_Status
-sane_get_devices(const SANE_Device ***device_list,
+sane_get_devices(const SANE_Device ***device_list,
SANE_Bool local_only)
{
Microtek_Device *dev;
@@ -3168,14 +3168,14 @@ sane_open(SANE_String_Const devicename,
/* initialize scanner dependent stuff */
DBG(23, "sane_open: initialize scanner dependent stuff...\n");
/* ZZZZZZZZZZZZZZ */
- scanner->unit_type =
+ 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 =
+ scanner->midtone_support =
(dev->info.enhance_cap & MI_ENH_CAP_MIDTONE) ? SANE_TRUE : SANE_FALSE;
- scanner->paper_length =
- (scanner->unit_type == MS_UNIT_PIXELS) ?
+ 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);
@@ -3202,7 +3202,7 @@ sane_open(SANE_String_Const devicename,
scanner->do_clever_precal = SANE_TRUE;
} else {
DBG(23, "sane_open: All calibration routines disabled.\n");
- scanner->allow_calibrate = SANE_TRUE;
+ scanner->allow_calibrate = SANE_TRUE;
scanner->do_real_calib = SANE_FALSE;
scanner->do_clever_precal = SANE_FALSE;
}
@@ -3227,7 +3227,7 @@ sane_open(SANE_String_Const devicename,
scanner->gray_lut = calloc(scanner->gamma_entries,
sizeof(scanner->gray_lut[0]));
- scanner->red_lut = calloc(scanner->gamma_entries,
+ scanner->red_lut = calloc(scanner->gamma_entries,
sizeof(scanner->red_lut[0]));
scanner->green_lut = calloc(scanner->gamma_entries,
sizeof(scanner->green_lut[0]));
@@ -3246,7 +3246,7 @@ sane_open(SANE_String_Const devicename,
free(scanner->blue_lut);
}
for (j=0; j<scanner->gamma_entries; j += scanner->gamma_entry_size) {
- v = (SANE_Int)
+ v = (SANE_Int)
((double) j * (double) max_entry /
((double) scanner->gamma_entries - 1.0) + 0.5);
scanner->gray_lut[j] = v;
@@ -3278,7 +3278,7 @@ sane_open(SANE_String_Const devicename,
/* clear out that clever cache, so it doesn't match anything */
{
int j;
- for (j=0; j<10; j++)
+ for (j=0; j<10; j++)
scanner->mode_sense_cache[j] = 0;
scanner->precal_record = MS_PRECAL_NONE;
}
@@ -3347,7 +3347,7 @@ sane_get_option_descriptor (SANE_Handle handle,
/********************************************************************/
/* sane_control_option */
/********************************************************************/
-SANE_Status
+SANE_Status
sane_control_option (SANE_Handle handle,
SANE_Int option,
SANE_Action action,
@@ -3429,12 +3429,12 @@ sane_control_option (SANE_Handle handle,
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:
@@ -3444,6 +3444,7 @@ sane_control_option (SANE_Handle handle,
case OPT_RESOLUTION:
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
+ // fall through
case OPT_SPEED:
case OPT_PREVIEW:
case OPT_BACKTRACK:
@@ -3457,12 +3458,12 @@ sane_control_option (SANE_Handle handle,
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 */
+ /* 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)
@@ -3514,7 +3515,7 @@ sane_control_option (SANE_Handle handle,
val[option].w = *(SANE_Word *) value;
} else if (option == OPT_CUSTOM_GAMMA) {
if (val[option].s) {
- if (strcmp(value, val[option].s))
+ if (strcmp(value, val[option].s))
if (info) *info |= SANE_INFO_RELOAD_OPTIONS;
free(val[option].s);
}
@@ -3526,7 +3527,7 @@ sane_control_option (SANE_Handle handle,
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;
@@ -3565,12 +3566,12 @@ sane_control_option (SANE_Handle handle,
else if (!(strcmp(val[OPT_MODE].s, M_COLOR)))
sod[OPT_GAMMA_BIND].cap &= ~SANE_CAP_INACTIVE;
return SANE_STATUS_GOOD;
-
- case OPT_MODE:
+
+ case OPT_MODE:
if (val[option].s) {
if (strcmp(val[option].s, value))
- if (info)
+ if (info)
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
free(val[option].s);
}
@@ -3586,7 +3587,7 @@ sane_control_option (SANE_Handle handle,
{
SANE_Bool Trueness = SANE_TRUE;
SANE_Status status;
- status = sane_control_option(handle,
+ status = sane_control_option(handle,
OPT_GAMMA_BIND,
SANE_ACTION_SET_VALUE,
&Trueness,
@@ -3619,7 +3620,7 @@ sane_control_option (SANE_Handle handle,
}
}
break;
-
+
case SANE_ACTION_SET_AUTO:
return SANE_STATUS_UNSUPPORTED; /* We are DUMB. */
}
@@ -3662,7 +3663,7 @@ sane_get_parameters (SANE_Handle handle,
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;
@@ -3673,18 +3674,18 @@ sane_get_parameters (SANE_Handle handle,
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->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->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",
+ 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");
@@ -3725,18 +3726,18 @@ sane_get_parameters (SANE_Handle handle,
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) ?
+ 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);
@@ -3755,22 +3756,22 @@ sane_get_parameters (SANE_Handle handle,
/* 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) {
+ if (s->unit_type == MS_UNIT_18INCH) {
/* who *knows* what happens */
- widthpix =
+ widthpix =
(SANE_Int)((double)(s->x2 - s->x1 + 1) / 8.0 *
(double)s->resolution);
- s->params.lines =
+ 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)
+ if (s->resolution <= s->dev->info.base_resolution)
widthpix =
(SANE_Int)((double)(s->x2 - s->x1 + 1) *
- (double)(s->resolution) /
+ (double)(s->resolution) /
(double)(s->dev->info.base_resolution));
else
widthpix = (s->x2 - s->x1 + 1);
@@ -3784,14 +3785,14 @@ sane_get_parameters (SANE_Handle handle,
}
DBG(23, "WIDTHPIX: before exp: %d\n", widthpix);
/* ok, now fix up expanded-mode conversions */
- if (s->resolution > s->dev->info.base_resolution)
+ 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 =
+ s->params.lines =
(SANE_Int)((double)(s->y2 - s->y1 + 1) *
- (double)(s->resolution) /
+ (double)(s->resolution) /
(double)(s->dev->info.base_resolution));
}
}
@@ -3822,13 +3823,13 @@ sane_get_parameters (SANE_Handle handle,
} 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.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",
+ 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 */
@@ -3852,7 +3853,7 @@ 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) {
@@ -3863,10 +3864,10 @@ sane_start_guts (SANE_Handle handle)
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,
@@ -3877,50 +3878,50 @@ sane_start_guts (SANE_Handle handle)
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)
+ 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 &
+ 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)
+ if ((status = download_gamma(s)) != SANE_STATUS_GOOD)
return end_scan(s, status);
- if ((status = mode_select(s)) != SANE_STATUS_GOOD)
+ 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)
+ 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)
+ 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,
+ 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 >
+ 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:
@@ -3990,16 +3991,16 @@ sane_start_guts (SANE_Handle handle)
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 */
+ /*+ 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 =
+ /*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;*/
@@ -4012,27 +4013,27 @@ sane_start_guts (SANE_Handle handle)
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;
-
+ 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);
@@ -4040,7 +4041,7 @@ sane_start_guts (SANE_Handle handle)
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;
}
@@ -4062,7 +4063,7 @@ sane_start (SANE_Handle handle)
/********************************************************************/
/* sane_read */
/********************************************************************/
-static SANE_Status
+static SANE_Status
sane_read_guts (SANE_Handle handle, SANE_Byte *dest_buffer,
SANE_Int dest_length, SANE_Int *ret_length)
{
@@ -4072,7 +4073,7 @@ sane_read_guts (SANE_Handle handle, SANE_Byte *dest_buffer,
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);
@@ -4102,7 +4103,7 @@ sane_read_guts (SANE_Handle handle, SANE_Byte *dest_buffer,
}
-SANE_Status
+SANE_Status
sane_read (SANE_Handle handle, SANE_Byte *dest_buffer,
SANE_Int dest_length, SANE_Int *ret_length)
{
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-28 20:57:07 +0000