mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Added support for Linart and threshold option.

merge-requests/1/head
Fred Odendaal 2005-11-17 04:43:56 +00:00
rodzic 9d74e8173c
commit cae18a7907
3 zmienionych plików z 230 dodań i 102 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

152
backend/lexmark-x1100.c
Wyświetl plik

@ -51,6 +51,7 @@
#include "../include/sane/sane.h"
#include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h"
#include "../include/sane/sanei_usb.h"
@ -147,6 +148,9 @@ static SANE_Status read_buffer_add_byte (Read_Buffer *rb,
SANE_Byte * byte_pointer);
static SANE_Status read_buffer_add_byte_gray (Read_Buffer *rb,
SANE_Byte * byte_pointer);
static SANE_Status read_buffer_add_bit_lineart (Read_Buffer *rb,
SANE_Byte * byte_pointer,
SANE_Byte threshold);
static size_t read_buffer_get_bytes (Read_Buffer *rb, SANE_Byte * buffer,
size_t rqst_size);
static SANE_Bool read_buffer_is_empty (Read_Buffer *rb);
@ -1421,10 +1425,10 @@ sanei_lexmark_x1100_set_scan_regs (Lexmark_Device * dev, SANE_Int offset)
int i;
/* resolution */
yres = dev->val[OPT_Y_DPI].w;
yres = dev->val[OPT_RESOLUTION].w;
/* colour mode */
if (strcmp (dev->val[OPT_MODE].s, "Color") == 0)
if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
isColourScan = SANE_TRUE;
else
isColourScan = SANE_FALSE;
@ -2329,7 +2333,7 @@ sanei_lexmark_x1100_read_scan_data (SANE_Byte * data, SANE_Int size, Lexmark_Dev
{
SANE_Int devnum;
SANE_Bool isColourScan;
SANE_Bool isColourScan, isGrayScan;
/* SANE_Byte temp_byte; */
static SANE_Byte command1_block[] = { 0x91, 0x00, 0xff, 0xc0 };
size_t xfer_size, cmd_size, xfer_request, remainder;
@ -2340,10 +2344,16 @@ sanei_lexmark_x1100_read_scan_data (SANE_Byte * data, SANE_Int size, Lexmark_Dev
DBG (2, "sanei_lexmark_x1100_read_scan_data:\n");
/* colour mode */
if (strcmp (dev->val[OPT_MODE].s, "Color") == 0)
isGrayScan = SANE_FALSE;
if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
isColourScan = SANE_TRUE;
else
isColourScan = SANE_FALSE;
{
isColourScan = SANE_FALSE;
/* grayscale mode */
if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) == 0)
isGrayScan = SANE_TRUE;
}
devnum = dev->devnum;
@ -2393,7 +2403,7 @@ sanei_lexmark_x1100_read_scan_data (SANE_Byte * data, SANE_Int size, Lexmark_Dev
}
}
DBG (5, "\nREAD BUFFER INFO: \n");
DBG (5, "READ BUFFER INFO: \n");
DBG (5, " write ptr: %p\n", dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr);
@ -2419,13 +2429,30 @@ sanei_lexmark_x1100_read_scan_data (SANE_Byte * data, SANE_Int size, Lexmark_Dev
read_buffer_add_byte (dev->read_buffer, dev->read_pointer-1);
even_byte = ! even_byte;
}
/* Gray or Black&White Scan */
/* Gray Scan */
else if (isGrayScan)
{
if (even_byte)
read_buffer_add_byte_gray (dev->read_buffer,
dev->read_pointer+1);
else
read_buffer_add_byte_gray (dev->read_buffer,
dev->read_pointer-1);
even_byte = ! even_byte;
}
/* Lineart Scan */
else
{
/* read_buffer_add_byte_gray(dev->read_pointer); */
read_buffer_add_byte_gray (dev->read_buffer, dev->read_pointer);
if (even_byte)
read_buffer_add_bit_lineart (dev->read_buffer,
dev->read_pointer+1,
dev->threshold);
else
read_buffer_add_bit_lineart (dev->read_buffer,
dev->read_pointer-1,
dev->threshold);
even_byte = ! even_byte;
}
dev->read_pointer = dev->read_pointer + sizeof (SANE_Byte);
dev->bytes_in_buffer--;
}
@ -2434,6 +2461,15 @@ sanei_lexmark_x1100_read_scan_data (SANE_Byte * data, SANE_Int size, Lexmark_Dev
dev->transfer_buffer = NULL;
}
DBG (5, "READ BUFFER INFO: \n");
DBG (5, " write ptr: %p\n", dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr);
DBG (5, " buffer size: %lu\n", (u_long)dev->read_buffer->size);
DBG (5, " line size: %lu\n", (u_long)dev->read_buffer->linesize);
DBG (5, " empty: %d\n", dev->read_buffer->empty);
DBG (5, " line no: %d\n", dev->read_buffer->image_line_no);
/* Read blocks out of read buffer */
bytes_read = read_buffer_get_bytes (dev->read_buffer, data, size);
@ -2487,10 +2523,10 @@ x1100_rewind (Lexmark_Device * dev)
and grayscale scans at the same resolution. */
/* Scan resolution */
scan_resolution = dev->val[OPT_Y_DPI].w;
scan_resolution = dev->val[OPT_RESOLUTION].w;
/* Colour mode */
if (strcmp (dev->val[OPT_MODE].s, "Color") == 0)
if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
colour_scan = SANE_TRUE;
else
colour_scan = SANE_FALSE;
@ -2632,7 +2668,8 @@ read_buffer_init (Lexmark_Device *dev, int bytesperline)
(no_lines_in_buffer - 1) * bytesperline;
dev->read_buffer->empty = SANE_TRUE;
dev->read_buffer->image_line_no = 0;
dev->read_buffer->bit_counter = 0;
dev->read_buffer->max_lineart_offset = dev->params.pixels_per_line - 1;
return SANE_STATUS_GOOD;
}
@ -2720,18 +2757,9 @@ read_buffer_add_byte_gray (Read_Buffer *rb, SANE_Byte * byte_pointer)
{
/* DBG(2, "read_buffer_add_byte_gray:\n"); */
/* Fix the endian byte ordering here */
if ((rb->gray_offset & 0x01) == 0)
{
/*Even byte number */
*(rb->writeptr + rb->gray_offset + 1) = *byte_pointer;
}
else
{
/*Odd byte number */
*(rb->writeptr + rb->gray_offset - 1) = *byte_pointer;
}
*(rb->writeptr + rb->gray_offset) = *byte_pointer;
if (rb->gray_offset == rb->max_gray_offset)
{
rb->image_line_no++;
@ -2749,6 +2777,80 @@ read_buffer_add_byte_gray (Read_Buffer *rb, SANE_Byte * byte_pointer)
return SANE_STATUS_GOOD;
}
SANE_Status
read_buffer_add_bit_lineart (Read_Buffer *rb, SANE_Byte * byte_pointer,
SANE_Byte threshold)
{
SANE_Byte tmpByte;
SANE_Byte *currentBytePtr;
SANE_Int bitIndex;
/* DBG(2, "read_buffer_add_bit_lineart:\n"); */
/* threshold = 0x80; */
tmpByte = 0;
/* Create a bit by comparing incoming byte to threshold */
if (*byte_pointer >= threshold)
{
tmpByte = 128;
}
/* Calculate the bit index in the current byte */
bitIndex = rb->bit_counter % 8;
/* Move the bit to its correct position in the temporary byte */
tmpByte = tmpByte >> bitIndex;
/* Get the pointer to the current byte */
currentBytePtr = rb->writeptr + rb->gray_offset;
/* If this is the first write to this byte, clear the byte */
if ( bitIndex == 0 )
*currentBytePtr = 0;
/* Set the value of the bit in the current byte */
*currentBytePtr = *currentBytePtr | tmpByte;
/* last bit in the line? */
if (rb->bit_counter == rb->max_lineart_offset)
{
/* Check if we're at the last byte of the line - error if not */
if (rb->gray_offset != rb->max_gray_offset)
{
DBG(5, "read_buffer_add_bit_lineart:\n");
DBG(5, " Last bit of line is not last byte.\n");
DBG(5, " Bit Index: %d, Byte Index: %d. \n", rb->bit_counter,
rb->max_gray_offset);
return SANE_STATUS_INVAL;
}
rb->image_line_no++;
/* line finished read_buffer no longer empty */
rb->empty = SANE_FALSE;
rb->gray_offset = 0;
/* are we at the last line in the read buffer ? */
if (rb->writeptr == rb->max_writeptr)
rb->writeptr = rb->data; /* back to beginning of buffer */
else
rb->writeptr = rb->writeptr + rb->linesize; /* next line */
/* clear the bit counter */
rb->bit_counter = 0;
}
/* last bit in the byte? */
else if ( bitIndex == 7 )
{
/* Not at the end of the line, but byte done. Increment byte offset */
rb->gray_offset = rb->gray_offset + (1 * sizeof (SANE_Byte));
/* increment bit counter */
rb->bit_counter++;
}
else
{
/* else increment bit counter */
rb->bit_counter++;
}
return SANE_STATUS_GOOD;
}
size_t
read_buffer_get_bytes (Read_Buffer *rb, SANE_Byte * buffer, size_t rqst_size)

171
backend/lexmark.c
Wyświetl plik

@ -82,33 +82,30 @@ static const SANE_Device **sane_device_list = NULL;
/* Program globals F.O - Should this be per device?*/
static SANE_Bool initialized = SANE_FALSE;
/* F.O. Per device globals - moved to lexmark.h as part of Lexmark_Device */
/* static int eof = 0; */
/* static SANE_Int x_dpi = 75; */
/* static SANE_Int y_dpi = 75; */
/* static long data_ctr = 0; */
/* static SANE_Bool device_cancelled = SANE_FALSE; */
/* static int cancel_ctr = 0; */
static SANE_String_Const mode_list[] = {
"Color", "Gray", "Lineart", NULL
SANE_VALUE_SCAN_MODE_COLOR,
SANE_VALUE_SCAN_MODE_GRAY,
SANE_VALUE_SCAN_MODE_LINEART,
NULL
};
/* possible resolutions are: 75x75, 150x150, 300x300, 600X600, 600X1200 */
static SANE_Int x_dpi_list[] = {
4, 75, 150, 300, 600
};
static SANE_Int y_dpi_list[] = {
5, 75, 150, 300, 600,
1200
static SANE_Int dpi_list[] = {
5, 75, 150, 300, 600, 1200
};
static SANE_String_Const size_list[] = {
"Wallet", "3x5", "4x6", "5x7", "8x10", "Letter", NULL
};
static SANE_Range threshold_range = {
SANE_FIX(0.0), /* minimum */
SANE_FIX(100.0), /* maximum */
SANE_FIX(1.0) /* quantization */
};
/* static functions */
static SANE_Status init_options (Lexmark_Device * lexmark_device);
static SANE_Status attachLexmark (SANE_String_Const devname);
@ -148,33 +145,20 @@ init_options (Lexmark_Device * lexmark_device)
lexmark_device->val[OPT_MODE].s = malloc (od->size);
if (!lexmark_device->val[OPT_MODE].s)
return SANE_STATUS_NO_MEM;
strcpy (lexmark_device->val[OPT_MODE].s, "Color");
strcpy (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR);
/* X dots per inch */
od = &(lexmark_device->opt[OPT_X_DPI]);
od->name = SANE_NAME_SCAN_X_RESOLUTION;
od->title = SANE_TITLE_SCAN_X_RESOLUTION;
od->desc = SANE_DESC_SCAN_X_RESOLUTION;
/* resolution */
od = &(lexmark_device->opt[OPT_RESOLUTION]);
od->name = SANE_NAME_SCAN_RESOLUTION;
od->title = SANE_TITLE_SCAN_RESOLUTION;
od->desc = SANE_DESC_SCAN_RESOLUTION;
od->type = SANE_TYPE_INT;
od->unit = SANE_UNIT_DPI;
od->size = sizeof (SANE_Word);
od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
od->constraint_type = SANE_CONSTRAINT_WORD_LIST;
od->constraint.word_list = x_dpi_list;
lexmark_device->val[OPT_X_DPI].w = 150;
/* Y dots per inch */
od = &(lexmark_device->opt[OPT_Y_DPI]);
od->name = SANE_NAME_SCAN_Y_RESOLUTION;
od->title = SANE_TITLE_SCAN_Y_RESOLUTION;
od->desc = SANE_DESC_SCAN_Y_RESOLUTION;
od->type = SANE_TYPE_INT;
od->unit = SANE_UNIT_DPI;
od->size = sizeof (SANE_Word);
od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
od->constraint_type = SANE_CONSTRAINT_WORD_LIST;
od->constraint.word_list = y_dpi_list;
lexmark_device->val[OPT_Y_DPI].w = 150;
od->constraint.word_list = dpi_list;
lexmark_device->val[OPT_RESOLUTION].w = 150;
/* preview mode */
od = &(lexmark_device->opt[OPT_PREVIEW]);
@ -189,9 +173,6 @@ init_options (Lexmark_Device * lexmark_device)
/* scan size */
od = &(lexmark_device->opt[OPT_SCAN_SIZE]);
/* od->name = "scan-size"; */
/* od->title = SANE_I18N ("Scan size"); */;
/* od->desc = SANE_I18N ("Selects the size of the scan."); */
od->name = SANE_NAME_PAPER_SIZE;
od->title = SANE_TITLE_PAPER_SIZE;
od->desc = SANE_DESC_PAPER_SIZE;
@ -206,6 +187,18 @@ init_options (Lexmark_Device * lexmark_device)
return SANE_STATUS_NO_MEM;
strcpy (lexmark_device->val[OPT_SCAN_SIZE].s, "3x5");
/* threshold */
od = &(lexmark_device->opt[OPT_THRESHOLD]);
od->name = SANE_NAME_THRESHOLD;
od->title = SANE_TITLE_THRESHOLD;
od->desc = SANE_DESC_THRESHOLD;
od->type = SANE_TYPE_FIXED;
od->unit = SANE_UNIT_PERCENT;
od->size = sizeof (SANE_Fixed);
od->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE;
od->constraint_type = SANE_CONSTRAINT_RANGE;
od->constraint.range = &threshold_range;
lexmark_device->val[OPT_THRESHOLD].w = SANE_FIX(50.0);
return SANE_STATUS_GOOD;
}
@ -243,6 +236,9 @@ attachLexmark (SANE_String_Const devname)
/* Make the pointer to the read buffer null here */
lexmark_device->read_buffer = NULL;
/* Set the default threshold for lineart mode here */
lexmark_device->threshold = 0x80;
lexmark_device->next = first_lexmark_device;
first_lexmark_device = lexmark_device;
@ -560,33 +556,23 @@ sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action,
sanei_constrain_value (&(lexmark_device->opt[option]), value,
info);
if (status != SANE_STATUS_GOOD)
return SANE_STATUS_INVAL;
{
DBG(2, "SANE_CONTROL_OPTION: Bad value for range\n");
return SANE_STATUS_INVAL;
}
}
switch (option)
{
case OPT_NUM_OPTS:
case OPT_X_DPI:
case OPT_RESOLUTION:
lexmark_device->val[option].w = *(SANE_Int *) value;
lexmark_device->val[OPT_Y_DPI].w = *(SANE_Int *) value;
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
sane_get_parameters (handle, 0);
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
case OPT_Y_DPI:
lexmark_device->val[option].w = *(SANE_Int *) value;
if (*(SANE_Int *) value == 1200)
lexmark_device->val[OPT_X_DPI].w = 600;
else
lexmark_device->val[OPT_X_DPI].w = *(SANE_Int *) value;
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
sane_get_parameters (handle, 0);
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
break;
case OPT_THRESHOLD:
lexmark_device->val[option].w = *(SANE_Fixed *) value;
lexmark_device->threshold = 0xFF * (lexmark_device->val[option].w/100);
break;
case OPT_SCAN_SIZE:
strcpy (lexmark_device->val[option].s, value);
break;
@ -594,15 +580,12 @@ sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action,
lexmark_device->val[option].w = *(SANE_Int *) value;
if (*(SANE_Word *) value)
{
lexmark_device->x_dpi = lexmark_device->val[OPT_X_DPI].w;
lexmark_device->y_dpi = lexmark_device->val[OPT_Y_DPI].w;
lexmark_device->val[OPT_X_DPI].w = 75;
lexmark_device->val[OPT_Y_DPI].w = 75;
lexmark_device->y_dpi = lexmark_device->val[OPT_RESOLUTION].w;
lexmark_device->val[OPT_RESOLUTION].w = 75;
}
else
{
lexmark_device->val[OPT_X_DPI].w = lexmark_device->x_dpi;
lexmark_device->val[OPT_Y_DPI].w = lexmark_device->y_dpi;
lexmark_device->val[OPT_RESOLUTION].w = lexmark_device->y_dpi;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
@ -613,7 +596,18 @@ sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action,
lexmark_device->val[option].w = *(SANE_Int *) value;
break;
case OPT_MODE:
strcpy (lexmark_device->val[option].s, value);
strcpy (lexmark_device->val[option].s, value);
if (strcmp (lexmark_device->val[option].s,
SANE_VALUE_SCAN_MODE_LINEART) == 0)
{
lexmark_device->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
}
else
{
lexmark_device->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
break;
}
@ -627,10 +621,14 @@ sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action,
switch (option)
{
case OPT_NUM_OPTS:
case OPT_X_DPI:
case OPT_Y_DPI:
case OPT_RESOLUTION:
case OPT_PREVIEW:
*(SANE_Int *) value = lexmark_device->val[option].w;
DBG(2,"Option value = %d\n", *(SANE_Int *) value);
break;
case OPT_THRESHOLD:
*(SANE_Fixed *) value = lexmark_device->val[option].w;
DBG(2,"Option value = %f\n", SANE_UNFIX(*(SANE_Fixed *) value));
break;
case OPT_MODE:
case OPT_SCAN_SIZE:
@ -676,16 +674,20 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
if (!lexmark_device)
return SANE_STATUS_INVAL;
xres = lexmark_device->val[OPT_X_DPI].w;
yres = lexmark_device->val[OPT_Y_DPI].w;
yres = lexmark_device->val[OPT_RESOLUTION].w;
if (yres == 1200)
xres = 600;
else
xres = yres;
/* 24 bit colour = 8 bits/channel for each of the RGB channels */
channels = 3;
bitsperchannel = 8;
isColourScan = SANE_TRUE;
/* If grayscale there is only 1 channel */
if (strcmp (lexmark_device->val[OPT_MODE].s, "Gray") == 0)
/* If not color there is only 1 channel */
if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)
!= 0)
{
channels = 1;
bitsperchannel = 8;
@ -742,12 +744,22 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
lexmark_device->pixel_width = width_px;
lexmark_device->pixel_height = height_px;
/* data_size is the size transferred from the scanner to the backend */
/* therefor bitsperchannel is the same for gray and lineart */
lexmark_device->data_size =
width_px * height_px * channels * (bitsperchannel / 8);
DBG (2, "sane_get_parameters: Data size determined as %lx\n",
lexmark_device->data_size);
/* we must tell the front end the bitsperchannel for lineart is really */
/* only 1, so it can calculate the correct image size */
/* If not color there is only 1 channel */
if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART)
== 0)
{
bitsperchannel = 1;
}
device_params = &(lexmark_device->params);
device_params->format = SANE_FRAME_RGB;
if (channels == 1)
@ -759,7 +771,16 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
device_params->bytes_per_line =
(SANE_Int) (channels * device_params->pixels_per_line *
(bitsperchannel / 8));
/* bytesperchannel = bitsperchannel/8 */
if ( bitsperchannel == 1 )
{
device_params->bytes_per_line =
(SANE_Int) (device_params->pixels_per_line / 8);
if ((device_params->pixels_per_line % 8) != 0)
device_params->bytes_per_line++;
}
DBG (2, "sane_get_parameters: \n");
if (device_params->format == SANE_FRAME_GRAY)
DBG (2, " format: SANE_FRAME_GRAY\n");

9
backend/lexmark.h
Wyświetl plik

@ -61,10 +61,12 @@ typedef enum
{
OPT_NUM_OPTS = 0,
OPT_MODE,
OPT_X_DPI,
OPT_Y_DPI,
/* OPT_X_DPI, */
/* OPT_Y_DPI, */
OPT_RESOLUTION,
OPT_PREVIEW,
OPT_SCAN_SIZE,
OPT_THRESHOLD,
/* must come last: */
NUM_OPTIONS
}
@ -114,6 +116,8 @@ typedef struct Read_Buffer
size_t linesize;
SANE_Bool empty;
SANE_Int image_line_no;
SANE_Int bit_counter;
SANE_Int max_lineart_offset;
}
Read_Buffer;
@ -141,6 +145,7 @@ typedef struct Lexmark_Device
size_t bytes_in_buffer;
SANE_Byte *read_pointer;
Read_Buffer *read_buffer;
SANE_Byte threshold;
}
Lexmark_Device;