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/sane.h"
#include "../include/sane/sanei.h" #include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h"
#include "../include/sane/sanei_usb.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); SANE_Byte * byte_pointer);
static SANE_Status read_buffer_add_byte_gray (Read_Buffer *rb, static SANE_Status read_buffer_add_byte_gray (Read_Buffer *rb,
SANE_Byte * byte_pointer); 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, static size_t read_buffer_get_bytes (Read_Buffer *rb, SANE_Byte * buffer,
size_t rqst_size); size_t rqst_size);
static SANE_Bool read_buffer_is_empty (Read_Buffer *rb); 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; int i;
/* resolution */ /* resolution */
yres = dev->val[OPT_Y_DPI].w; yres = dev->val[OPT_RESOLUTION].w;
/* colour mode */ /* 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; isColourScan = SANE_TRUE;
else else
isColourScan = SANE_FALSE; 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_Int devnum;
SANE_Bool isColourScan; SANE_Bool isColourScan, isGrayScan;
/* SANE_Byte temp_byte; */ /* SANE_Byte temp_byte; */
static SANE_Byte command1_block[] = { 0x91, 0x00, 0xff, 0xc0 }; static SANE_Byte command1_block[] = { 0x91, 0x00, 0xff, 0xc0 };
size_t xfer_size, cmd_size, xfer_request, remainder; 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"); DBG (2, "sanei_lexmark_x1100_read_scan_data:\n");
/* colour mode */ /* 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; isColourScan = SANE_TRUE;
else 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; 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, " write ptr: %p\n", dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", dev->read_buffer->readptr); DBG (5, " read ptr: %p\n", dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr); 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); read_buffer_add_byte (dev->read_buffer, dev->read_pointer-1);
even_byte = ! even_byte; 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 else
{ {
/* read_buffer_add_byte_gray(dev->read_pointer); */ if (even_byte)
read_buffer_add_byte_gray (dev->read_buffer, dev->read_pointer); 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->read_pointer = dev->read_pointer + sizeof (SANE_Byte);
dev->bytes_in_buffer--; 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; 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 */ /* Read blocks out of read buffer */
bytes_read = read_buffer_get_bytes (dev->read_buffer, data, size); 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. */ and grayscale scans at the same resolution. */
/* Scan resolution */ /* Scan resolution */
scan_resolution = dev->val[OPT_Y_DPI].w; scan_resolution = dev->val[OPT_RESOLUTION].w;
/* Colour mode */ /* 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; colour_scan = SANE_TRUE;
else else
colour_scan = SANE_FALSE; colour_scan = SANE_FALSE;
@ -2632,7 +2668,8 @@ read_buffer_init (Lexmark_Device *dev, int bytesperline)
(no_lines_in_buffer - 1) * bytesperline; (no_lines_in_buffer - 1) * bytesperline;
dev->read_buffer->empty = SANE_TRUE; dev->read_buffer->empty = SANE_TRUE;
dev->read_buffer->image_line_no = 0; 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; 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"); */ /* DBG(2, "read_buffer_add_byte_gray:\n"); */
/* Fix the endian byte ordering here */ *(rb->writeptr + rb->gray_offset) = *byte_pointer;
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;
}
if (rb->gray_offset == rb->max_gray_offset) if (rb->gray_offset == rb->max_gray_offset)
{ {
rb->image_line_no++; rb->image_line_no++;
@ -2749,6 +2777,80 @@ read_buffer_add_byte_gray (Read_Buffer *rb, SANE_Byte * byte_pointer)
return SANE_STATUS_GOOD; 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 size_t
read_buffer_get_bytes (Read_Buffer *rb, SANE_Byte * buffer, size_t rqst_size) 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?*/ /* Program globals F.O - Should this be per device?*/
static SANE_Bool initialized = SANE_FALSE; 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[] = { 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 */ /* possible resolutions are: 75x75, 150x150, 300x300, 600X600, 600X1200 */
static SANE_Int x_dpi_list[] = { static SANE_Int dpi_list[] = {
4, 75, 150, 300, 600 5, 75, 150, 300, 600, 1200
};
static SANE_Int y_dpi_list[] = {
5, 75, 150, 300, 600,
1200
}; };
static SANE_String_Const size_list[] = { static SANE_String_Const size_list[] = {
"Wallet", "3x5", "4x6", "5x7", "8x10", "Letter", NULL "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 functions */
static SANE_Status init_options (Lexmark_Device * lexmark_device); static SANE_Status init_options (Lexmark_Device * lexmark_device);
static SANE_Status attachLexmark (SANE_String_Const devname); 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); lexmark_device->val[OPT_MODE].s = malloc (od->size);
if (!lexmark_device->val[OPT_MODE].s) if (!lexmark_device->val[OPT_MODE].s)
return SANE_STATUS_NO_MEM; 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 */ /* resolution */
od = &(lexmark_device->opt[OPT_X_DPI]); od = &(lexmark_device->opt[OPT_RESOLUTION]);
od->name = SANE_NAME_SCAN_X_RESOLUTION; od->name = SANE_NAME_SCAN_RESOLUTION;
od->title = SANE_TITLE_SCAN_X_RESOLUTION; od->title = SANE_TITLE_SCAN_RESOLUTION;
od->desc = SANE_DESC_SCAN_X_RESOLUTION; od->desc = SANE_DESC_SCAN_RESOLUTION;
od->type = SANE_TYPE_INT; od->type = SANE_TYPE_INT;
od->unit = SANE_UNIT_DPI; od->unit = SANE_UNIT_DPI;
od->size = sizeof (SANE_Word); od->size = sizeof (SANE_Word);
od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
od->constraint_type = SANE_CONSTRAINT_WORD_LIST; od->constraint_type = SANE_CONSTRAINT_WORD_LIST;
od->constraint.word_list = x_dpi_list; od->constraint.word_list = dpi_list;
lexmark_device->val[OPT_X_DPI].w = 150; lexmark_device->val[OPT_RESOLUTION].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;
/* preview mode */ /* preview mode */
od = &(lexmark_device->opt[OPT_PREVIEW]); od = &(lexmark_device->opt[OPT_PREVIEW]);
@ -189,9 +173,6 @@ init_options (Lexmark_Device * lexmark_device)
/* scan size */ /* scan size */
od = &(lexmark_device->opt[OPT_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->name = SANE_NAME_PAPER_SIZE;
od->title = SANE_TITLE_PAPER_SIZE; od->title = SANE_TITLE_PAPER_SIZE;
od->desc = SANE_DESC_PAPER_SIZE; od->desc = SANE_DESC_PAPER_SIZE;
@ -206,6 +187,18 @@ init_options (Lexmark_Device * lexmark_device)
return SANE_STATUS_NO_MEM; return SANE_STATUS_NO_MEM;
strcpy (lexmark_device->val[OPT_SCAN_SIZE].s, "3x5"); 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; return SANE_STATUS_GOOD;
} }
@ -243,6 +236,9 @@ attachLexmark (SANE_String_Const devname)
/* Make the pointer to the read buffer null here */ /* Make the pointer to the read buffer null here */
lexmark_device->read_buffer = NULL; lexmark_device->read_buffer = NULL;
/* Set the default threshold for lineart mode here */
lexmark_device->threshold = 0x80;
lexmark_device->next = first_lexmark_device; lexmark_device->next = first_lexmark_device;
first_lexmark_device = 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, sanei_constrain_value (&(lexmark_device->opt[option]), value,
info); info);
if (status != SANE_STATUS_GOOD) 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) switch (option)
{ {
case OPT_NUM_OPTS: case OPT_NUM_OPTS:
case OPT_X_DPI: case OPT_RESOLUTION:
lexmark_device->val[option].w = *(SANE_Int *) value; 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); sane_get_parameters (handle, 0);
if (info) break;
*info |= SANE_INFO_RELOAD_OPTIONS; case OPT_THRESHOLD:
return SANE_STATUS_GOOD; lexmark_device->val[option].w = *(SANE_Fixed *) value;
case OPT_Y_DPI: lexmark_device->threshold = 0xFF * (lexmark_device->val[option].w/100);
lexmark_device->val[option].w = *(SANE_Int *) value; break;
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;
case OPT_SCAN_SIZE: case OPT_SCAN_SIZE:
strcpy (lexmark_device->val[option].s, value); strcpy (lexmark_device->val[option].s, value);
break; 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; lexmark_device->val[option].w = *(SANE_Int *) value;
if (*(SANE_Word *) value) if (*(SANE_Word *) value)
{ {
lexmark_device->x_dpi = lexmark_device->val[OPT_X_DPI].w; lexmark_device->y_dpi = lexmark_device->val[OPT_RESOLUTION].w;
lexmark_device->y_dpi = lexmark_device->val[OPT_Y_DPI].w; lexmark_device->val[OPT_RESOLUTION].w = 75;
lexmark_device->val[OPT_X_DPI].w = 75;
lexmark_device->val[OPT_Y_DPI].w = 75;
} }
else else
{ {
lexmark_device->val[OPT_X_DPI].w = lexmark_device->x_dpi; lexmark_device->val[OPT_RESOLUTION].w = lexmark_device->y_dpi;
lexmark_device->val[OPT_Y_DPI].w = lexmark_device->y_dpi;
} }
if (info) if (info)
*info |= SANE_INFO_RELOAD_OPTIONS; *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; lexmark_device->val[option].w = *(SANE_Int *) value;
break; break;
case OPT_MODE: 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; break;
} }
@ -627,10 +621,14 @@ sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action,
switch (option) switch (option)
{ {
case OPT_NUM_OPTS: case OPT_NUM_OPTS:
case OPT_X_DPI: case OPT_RESOLUTION:
case OPT_Y_DPI:
case OPT_PREVIEW: case OPT_PREVIEW:
*(SANE_Int *) value = lexmark_device->val[option].w; *(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; break;
case OPT_MODE: case OPT_MODE:
case OPT_SCAN_SIZE: case OPT_SCAN_SIZE:
@ -676,16 +674,20 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
if (!lexmark_device) if (!lexmark_device)
return SANE_STATUS_INVAL; return SANE_STATUS_INVAL;
xres = lexmark_device->val[OPT_X_DPI].w; yres = lexmark_device->val[OPT_RESOLUTION].w;
yres = lexmark_device->val[OPT_Y_DPI].w; if (yres == 1200)
xres = 600;
else
xres = yres;
/* 24 bit colour = 8 bits/channel for each of the RGB channels */ /* 24 bit colour = 8 bits/channel for each of the RGB channels */
channels = 3; channels = 3;
bitsperchannel = 8; bitsperchannel = 8;
isColourScan = SANE_TRUE; isColourScan = SANE_TRUE;
/* If grayscale there is only 1 channel */ /* If not color there is only 1 channel */
if (strcmp (lexmark_device->val[OPT_MODE].s, "Gray") == 0) if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)
!= 0)
{ {
channels = 1; channels = 1;
bitsperchannel = 8; bitsperchannel = 8;
@ -742,12 +744,22 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
lexmark_device->pixel_width = width_px; lexmark_device->pixel_width = width_px;
lexmark_device->pixel_height = height_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 = lexmark_device->data_size =
width_px * height_px * channels * (bitsperchannel / 8); width_px * height_px * channels * (bitsperchannel / 8);
DBG (2, "sane_get_parameters: Data size determined as %lx\n", DBG (2, "sane_get_parameters: Data size determined as %lx\n",
lexmark_device->data_size); 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 = &(lexmark_device->params);
device_params->format = SANE_FRAME_RGB; device_params->format = SANE_FRAME_RGB;
if (channels == 1) if (channels == 1)
@ -759,7 +771,16 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
device_params->bytes_per_line = device_params->bytes_per_line =
(SANE_Int) (channels * device_params->pixels_per_line * (SANE_Int) (channels * device_params->pixels_per_line *
(bitsperchannel / 8)); (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"); DBG (2, "sane_get_parameters: \n");
if (device_params->format == SANE_FRAME_GRAY) if (device_params->format == SANE_FRAME_GRAY)
DBG (2, " format: SANE_FRAME_GRAY\n"); 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_NUM_OPTS = 0,
OPT_MODE, OPT_MODE,
OPT_X_DPI, /* OPT_X_DPI, */
OPT_Y_DPI, /* OPT_Y_DPI, */
OPT_RESOLUTION,
OPT_PREVIEW, OPT_PREVIEW,
OPT_SCAN_SIZE, OPT_SCAN_SIZE,
OPT_THRESHOLD,
/* must come last: */ /* must come last: */
NUM_OPTIONS NUM_OPTIONS
} }
@ -114,6 +116,8 @@ typedef struct Read_Buffer
size_t linesize; size_t linesize;
SANE_Bool empty; SANE_Bool empty;
SANE_Int image_line_no; SANE_Int image_line_no;
SANE_Int bit_counter;
SANE_Int max_lineart_offset;
} }
Read_Buffer; Read_Buffer;
@ -141,6 +145,7 @@ typedef struct Lexmark_Device
size_t bytes_in_buffer; size_t bytes_in_buffer;
SANE_Byte *read_pointer; SANE_Byte *read_pointer;
Read_Buffer *read_buffer; Read_Buffer *read_buffer;
SANE_Byte threshold;
} }
Lexmark_Device; Lexmark_Device;