kopia lustrzana https://gitlab.com/sane-project/backends
1000 wiersze
25 KiB
C
1000 wiersze
25 KiB
C
/* sane - Scanner Access Now Easy.
|
|
|
|
ScanMaker 3840 Backend
|
|
Copyright (C) 2005-7 Earle F. Philhower, III
|
|
earle@ziplabel.com - http://www.ziplabel.com
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
As a special exception, the authors of SANE give permission for
|
|
additional uses of the libraries contained in this release of SANE.
|
|
|
|
The exception is that, if you link a SANE library with other files
|
|
to produce an executable, this does not by itself cause the
|
|
resulting executable to be covered by the GNU General Public
|
|
License. Your use of that executable is in no way restricted on
|
|
account of linking the SANE library code into it.
|
|
|
|
This exception does not, however, invalidate any other reasons why
|
|
the executable file might be covered by the GNU General Public
|
|
License.
|
|
|
|
If you submit changes to SANE to the maintainers to be included in
|
|
a subsequent release, you agree by submitting the changes that
|
|
those changes may be distributed with this exception intact.
|
|
|
|
If you write modifications of your own for SANE, it is your choice
|
|
whether to permit this exception to apply to your modifications.
|
|
If you do not wish that, delete this exception notice.
|
|
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <math.h>
|
|
#include "sm3840_lib.h"
|
|
|
|
#ifndef BACKENDNAME
|
|
/* For standalone compilation */
|
|
static void
|
|
DBG (int ignored, const char *fmt, ...)
|
|
{
|
|
va_list a;
|
|
va_start (a, fmt);
|
|
vfprintf (stderr, fmt, a);
|
|
va_end (a);
|
|
}
|
|
#else
|
|
/* For SANE compilation, convert libusb to sanei_usb */
|
|
static int
|
|
my_usb_bulk_write (p_usb_dev_handle dev, int ep,
|
|
unsigned char *bytes, int size, int timeout)
|
|
{
|
|
SANE_Status status;
|
|
size_t my_size;
|
|
|
|
(void) timeout;
|
|
(void) ep;
|
|
my_size = size;
|
|
status =
|
|
sanei_usb_write_bulk ((SANE_Int) dev, (SANE_Byte *) bytes, &my_size);
|
|
if (status != SANE_STATUS_GOOD)
|
|
my_size = -1;
|
|
return my_size;
|
|
}
|
|
|
|
static int
|
|
my_usb_bulk_read (p_usb_dev_handle dev, int ep,
|
|
unsigned char *bytes, int size, int timeout)
|
|
{
|
|
SANE_Status status;
|
|
size_t my_size;
|
|
|
|
(void) timeout;
|
|
(void) ep;
|
|
my_size = size;
|
|
status =
|
|
sanei_usb_read_bulk ((SANE_Int) dev, (SANE_Byte *) bytes, &my_size);
|
|
if (status != SANE_STATUS_GOOD)
|
|
my_size = -1;
|
|
return my_size;
|
|
}
|
|
|
|
static int
|
|
my_usb_control_msg (p_usb_dev_handle dev, int requesttype,
|
|
int request, int value, int index,
|
|
unsigned char *bytes, int size, int timeout)
|
|
{
|
|
SANE_Status status;
|
|
|
|
(void) timeout;
|
|
status = sanei_usb_control_msg ((SANE_Int) dev, (SANE_Int) requesttype,
|
|
(SANE_Int) request, (SANE_Int) value,
|
|
(SANE_Int) index, (SANE_Int) size,
|
|
(SANE_Byte *) bytes);
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Sanitize and convert scan parameters from inches to pixels */
|
|
static void
|
|
prepare_params (SM3840_Params * params)
|
|
{
|
|
if (params->gray)
|
|
params->gray = 1;
|
|
if (params->lineart) {
|
|
params->gray = 1;
|
|
params->lineart = 1;
|
|
}
|
|
if (params->halftone) {
|
|
params->gray = 1;
|
|
params->halftone = 1;
|
|
}
|
|
if (params->dpi != 1200 && params->dpi != 600 && params->dpi != 300
|
|
&& params->dpi != 150)
|
|
params->dpi = 150;
|
|
if (params->bpp != 8 && params->bpp != 16)
|
|
params->bpp = 8;
|
|
|
|
/* Sanity check input sizes */
|
|
if (params->top < 0)
|
|
params->top = 0;
|
|
if (params->left < 0)
|
|
params->left = 0;
|
|
if (params->width < 0)
|
|
params->width = 0;
|
|
if (params->height < 0)
|
|
params->height = 0;
|
|
if ((params->top + params->height) > 11.7)
|
|
params->height = 11.7 - params->top;
|
|
if ((params->left + params->width) > 8.5)
|
|
params->width = 8.5 - params->left;
|
|
|
|
params->topline = params->top * params->dpi;
|
|
params->scanlines = params->height * params->dpi;
|
|
params->leftpix = params->left * params->dpi;
|
|
params->leftpix &= ~1; /* Always start on even pixel boundary for remap */
|
|
/* Scanpix always a multiple of 128 */
|
|
params->scanpix = params->width * params->dpi;
|
|
params->scanpix = (params->scanpix + 127) & ~127;
|
|
|
|
/* Sanity check outputs... */
|
|
if (params->topline < 0)
|
|
params->topline = 0;
|
|
if (params->scanlines < 1)
|
|
params->scanlines = 1;
|
|
if (params->leftpix < 0)
|
|
params->leftpix = 0;
|
|
if (params->scanpix < 128)
|
|
params->scanpix = 128;
|
|
|
|
/* Some handy calculations */
|
|
params->linelen =
|
|
params->scanpix * (params->bpp / 8) * (params->gray ? 1 : 3);
|
|
}
|
|
|
|
#ifndef BACKENDNAME
|
|
usb_dev_handle *
|
|
find_device (unsigned int idVendor, unsigned int idProduct)
|
|
{
|
|
struct usb_bus *bus;
|
|
struct usb_device *dev;
|
|
|
|
usb_init ();
|
|
usb_find_busses ();
|
|
usb_find_devices ();
|
|
|
|
for (bus = usb_get_busses (); bus; bus = bus->next)
|
|
for (dev = bus->devices; dev; dev = dev->next)
|
|
if (dev->descriptor.idVendor == idVendor &&
|
|
dev->descriptor.idProduct == idProduct)
|
|
return usb_open (dev);
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
idle_ab (p_usb_dev_handle udev)
|
|
{
|
|
int i;
|
|
unsigned char buff[8] = { 0x64, 0x65, 0x16, 0x17, 0x64, 0x65, 0x44, 0x45 };
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
usb_control_msg (udev, 0x40, 0x0c, 0x0090, 0x0000, buff + i,
|
|
0x0001, wr_timeout);
|
|
}
|
|
}
|
|
|
|
/* CW: 40 04 00b0 0000 <len> : <reg1> <value1> <reg2> <value2> ... */
|
|
static void
|
|
write_regs (p_usb_dev_handle udev, int regs, int reg1, int val1,
|
|
... /* int reg, int val, ... */ )
|
|
{
|
|
unsigned char buff[512];
|
|
va_list marker;
|
|
int i;
|
|
|
|
va_start (marker, val1);
|
|
buff[0] = reg1;
|
|
buff[1] = val1;
|
|
for (i = 1; i < regs; i++)
|
|
{
|
|
buff[i * 2] = va_arg (marker, int);
|
|
buff[i * 2 + 1] = va_arg (marker, int);
|
|
}
|
|
va_end (marker);
|
|
|
|
usb_control_msg (udev, 0x40, 0x04, 0x00b0, 0x0000, buff,
|
|
regs * 2, wr_timeout);
|
|
}
|
|
|
|
static int
|
|
write_vctl (p_usb_dev_handle udev, int request, int value,
|
|
int index, unsigned char byte)
|
|
{
|
|
return usb_control_msg (udev, 0x40, request, value, index,
|
|
&byte, 1, wr_timeout);
|
|
}
|
|
|
|
static int
|
|
read_vctl (p_usb_dev_handle udev, int request, int value,
|
|
int index, unsigned char *byte)
|
|
{
|
|
return usb_control_msg (udev, 0xc0, request, value, index,
|
|
byte, 1, wr_timeout);
|
|
}
|
|
|
|
#ifndef BACKENDNAME
|
|
/* Copy from a USB data pipe to a file with optional header */
|
|
static void
|
|
record_head (p_usb_dev_handle udev, char *fname, int bytes, char *header)
|
|
{
|
|
FILE *fp;
|
|
unsigned char buff[65536];
|
|
int len;
|
|
int toread;
|
|
|
|
fp = fopen (fname, "wb");
|
|
if (header)
|
|
fprintf (fp, "%s", header);
|
|
do
|
|
{
|
|
toread = (bytes > 65536) ? 65536 : bytes;
|
|
len = usb_bulk_read (udev, 1, buff, toread, rd_timeout);
|
|
if (len > 0)
|
|
{
|
|
fwrite (buff, len, 1, fp);
|
|
bytes -= len;
|
|
}
|
|
else
|
|
{
|
|
DBG (2, "TIMEOUT\n");
|
|
}
|
|
}
|
|
while (bytes);
|
|
fclose (fp);
|
|
}
|
|
|
|
/* Copy from a USB data pipe to a file without header */
|
|
static void
|
|
record (p_usb_dev_handle udev, char *fname, int bytes)
|
|
{
|
|
record_head (udev, fname, bytes, "");
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
max (int a, int b)
|
|
{
|
|
return (a > b) ? a : b;
|
|
}
|
|
|
|
|
|
#define DPI1200SHUFFLE 6
|
|
static void
|
|
record_line (int reset,
|
|
p_usb_dev_handle udev,
|
|
unsigned char *storeline,
|
|
int dpi, int scanpix, int gray, int bpp16,
|
|
int *save_i,
|
|
unsigned char **save_scan_line,
|
|
unsigned char **save_dpi1200_remap,
|
|
unsigned char **save_color_remap)
|
|
{
|
|
unsigned char *scan_line, *dpi1200_remap;
|
|
unsigned char *color_remap;
|
|
int i;
|
|
int red_delay, blue_delay, green_delay;
|
|
int j;
|
|
int linelen;
|
|
int pixsize;
|
|
unsigned char *ptrcur, *ptrprev;
|
|
unsigned char *savestoreline;
|
|
int lineptr, outline, bufflines;
|
|
|
|
i = *save_i;
|
|
scan_line = *save_scan_line;
|
|
dpi1200_remap = *save_dpi1200_remap;
|
|
color_remap = *save_color_remap;
|
|
|
|
pixsize = (gray ? 1 : 3) * (bpp16 ? 2 : 1);
|
|
linelen = scanpix * pixsize;
|
|
|
|
if (gray)
|
|
{
|
|
red_delay = 0;
|
|
blue_delay = 0;
|
|
green_delay = 0;
|
|
}
|
|
else if (dpi == 150)
|
|
{
|
|
red_delay = 0;
|
|
blue_delay = 6;
|
|
green_delay = 3;
|
|
}
|
|
else if (dpi == 300)
|
|
{
|
|
red_delay = 0;
|
|
blue_delay = 12;
|
|
green_delay = 6;
|
|
}
|
|
else if (dpi == 600)
|
|
{
|
|
red_delay = 0;
|
|
blue_delay = 24;
|
|
green_delay = 12;
|
|
}
|
|
else /*(dpi==1200) */
|
|
{
|
|
red_delay = 0;
|
|
blue_delay = 48;
|
|
green_delay = 24;
|
|
}
|
|
|
|
bufflines = max (max (red_delay, blue_delay), green_delay) + 1;
|
|
|
|
if (reset)
|
|
{
|
|
if (dpi1200_remap)
|
|
free (dpi1200_remap);
|
|
if (scan_line)
|
|
free (scan_line);
|
|
if (color_remap)
|
|
free (color_remap);
|
|
|
|
*save_color_remap = color_remap =
|
|
(unsigned char *) malloc (bufflines * linelen);
|
|
|
|
*save_scan_line = scan_line = (unsigned char *) calloc (linelen, 1);
|
|
if (dpi == 1200)
|
|
*save_dpi1200_remap = dpi1200_remap =
|
|
(unsigned char *) calloc (linelen, DPI1200SHUFFLE);
|
|
else
|
|
*save_dpi1200_remap = dpi1200_remap = NULL;
|
|
|
|
*save_i = i = 0; /* i is our linenumber */
|
|
}
|
|
|
|
while (1)
|
|
{ /* We'll exit inside the loop... */
|
|
usb_bulk_read (udev, 1, scan_line, linelen, rd_timeout);
|
|
if (dpi == 1200)
|
|
{
|
|
ptrcur = dpi1200_remap + (linelen * (i % DPI1200SHUFFLE));
|
|
ptrprev =
|
|
dpi1200_remap +
|
|
(linelen * ((i - (DPI1200SHUFFLE - 2)) % DPI1200SHUFFLE));
|
|
}
|
|
else
|
|
{
|
|
ptrcur = scan_line;
|
|
ptrprev = NULL;
|
|
}
|
|
if (gray)
|
|
{
|
|
memcpy (ptrcur, scan_line, linelen);
|
|
}
|
|
else
|
|
{
|
|
int pixsize = bpp16 ? 2 : 1;
|
|
int pix = linelen / (3 * pixsize);
|
|
unsigned char *outbuff = ptrcur;
|
|
|
|
outline = i;
|
|
lineptr = i % bufflines;
|
|
|
|
memcpy (color_remap + linelen * lineptr, scan_line, linelen);
|
|
|
|
outline++;
|
|
if (outline > bufflines)
|
|
{
|
|
int redline = (outline + red_delay) % bufflines;
|
|
int greenline = (outline + green_delay) % bufflines;
|
|
int blueline = (outline + blue_delay) % bufflines;
|
|
unsigned char *rp, *gp, *bp;
|
|
|
|
rp = color_remap + linelen * redline;
|
|
gp = color_remap + linelen * greenline + 1 * pixsize;
|
|
bp = color_remap + linelen * blueline + 2 * pixsize;
|
|
|
|
for (j = 0; j < pix; j++)
|
|
{
|
|
if (outbuff)
|
|
{
|
|
*(outbuff++) = *rp;
|
|
if (pixsize == 2)
|
|
*(outbuff++) = *(rp + 1);
|
|
*(outbuff++) = *gp;
|
|
if (pixsize == 2)
|
|
*(outbuff++) = *(gp + 1);
|
|
*(outbuff++) = *bp;
|
|
if (pixsize == 2)
|
|
*(outbuff++) = *(bp + 1);
|
|
}
|
|
rp += 3 * pixsize;
|
|
gp += 3 * pixsize;
|
|
bp += 3 * pixsize;
|
|
}
|
|
}
|
|
lineptr = (lineptr + 1) % bufflines;
|
|
}
|
|
|
|
if (dpi != 1200)
|
|
{
|
|
if (i > blue_delay)
|
|
{
|
|
savestoreline = storeline;
|
|
for (j = 0; j < scanpix; j++)
|
|
{
|
|
memcpy (storeline, ptrcur + linelen - (j + 1) * pixsize,
|
|
pixsize);
|
|
storeline += pixsize;
|
|
}
|
|
if (dpi == 150)
|
|
{
|
|
/* 150 DPI skips every 4th returned line */
|
|
if (i % 4)
|
|
{
|
|
i++;
|
|
*save_i = i;
|
|
if (bpp16)
|
|
fix_endian_short ((unsigned short *) storeline,
|
|
scanpix);
|
|
return;
|
|
}
|
|
storeline = savestoreline;
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
*save_i = i;
|
|
if (bpp16)
|
|
fix_endian_short ((unsigned short *) storeline, scanpix);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else /* dpi==1200 */
|
|
{
|
|
if (i > (DPI1200SHUFFLE + blue_delay))
|
|
{
|
|
for (j = 0; j < scanpix; j++)
|
|
{
|
|
if (1 == (j & 1))
|
|
memcpy (storeline, ptrcur + linelen - (j + 1) * pixsize,
|
|
pixsize);
|
|
else
|
|
memcpy (storeline, ptrprev + linelen - (j + 1) * pixsize,
|
|
pixsize);
|
|
storeline += pixsize;
|
|
} /* end for */
|
|
i++;
|
|
*save_i = i;
|
|
if (bpp16)
|
|
fix_endian_short ((unsigned short *) storeline, scanpix);
|
|
return;
|
|
} /* end if >dpi1200shuffle */
|
|
} /* end if dpi1200 */
|
|
i++;
|
|
} /* end for */
|
|
}
|
|
|
|
|
|
#ifndef BACKENDNAME
|
|
/* Record an image to a file with remapping/reordering/etc. */
|
|
void
|
|
record_image (p_usb_dev_handle udev, char *fname, int dpi,
|
|
int scanpix, int scanlines, int gray, char *head, int bpp16)
|
|
{
|
|
FILE *fp;
|
|
int i;
|
|
int save_i;
|
|
unsigned char *save_scan_line;
|
|
unsigned char *save_dpi1200_remap;
|
|
unsigned char *save_color_remap;
|
|
unsigned char *storeline;
|
|
|
|
save_i = 0;
|
|
save_scan_line = save_dpi1200_remap = save_color_remap = NULL;
|
|
storeline =
|
|
(unsigned char *) malloc (scanpix * (gray ? 1 : 3) * (bpp16 ? 2 : 1));
|
|
|
|
fp = fopen (fname, "wb");
|
|
if (head)
|
|
fprintf (fp, "%s", head);
|
|
|
|
for (i = 0; i < scanlines; i++)
|
|
{
|
|
record_line ((i == 0) ? 1 : 0, udev, storeline, dpi, scanpix, gray,
|
|
bpp16, &save_i, &save_scan_line, &save_dpi1200_remap,
|
|
&save_color_remap);
|
|
fwrite (storeline, scanpix * (gray ? 1 : 3) * (bpp16 ? 2 : 1), 1, fp);
|
|
}
|
|
fclose (fp);
|
|
if (save_scan_line)
|
|
free (save_scan_line);
|
|
if (save_dpi1200_remap)
|
|
free (save_dpi1200_remap);
|
|
if (save_color_remap)
|
|
free (save_color_remap);
|
|
free (storeline);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
record_mem (p_usb_dev_handle udev, unsigned char **dest, int bytes)
|
|
{
|
|
unsigned char *mem;
|
|
unsigned char buff[65536];
|
|
int len;
|
|
|
|
mem = (unsigned char *) malloc (bytes);
|
|
*dest = mem;
|
|
do
|
|
{
|
|
len =
|
|
usb_bulk_read (udev, 1, buff, bytes > 65536 ? 65536 : bytes,
|
|
rd_timeout);
|
|
if (len > 0)
|
|
{
|
|
memcpy (mem, buff, len);
|
|
bytes -= len;
|
|
mem += len;
|
|
}
|
|
}
|
|
while (bytes);
|
|
}
|
|
|
|
|
|
static void
|
|
reset_scanner (p_usb_dev_handle udev)
|
|
{
|
|
unsigned char rd_byte;
|
|
|
|
DBG (2, "+reset_scanner\n");
|
|
write_regs (udev, 5, 0x83, 0x00, 0xa3, 0xff, 0xa4, 0xff, 0xa1, 0xff,
|
|
0xa2, 0xff);
|
|
write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
|
|
write_regs (udev, 2, 0xbe, 0x00, 0x84, 0x00);
|
|
write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
|
|
write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
|
|
write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00,
|
|
0x88, 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00,
|
|
0xc2, 0x00, 0xc3, 0x00, 0xc4, 0x00, 0xc5, 0x00,
|
|
0xc6, 0x00, 0xc7, 0x00, 0xc8, 0x00, 0xc0, 0x00);
|
|
write_regs (udev, 16, 0x84, 0x94, 0x80, 0xd1, 0x80, 0xc1, 0x82, 0x7f,
|
|
0xcf, 0x04, 0xc1, 0x02, 0xc2, 0x00, 0xc3, 0x06,
|
|
0xc4, 0xff, 0xc5, 0x40, 0xc6, 0x8c, 0xc7, 0xdc,
|
|
0xc8, 0x20, 0xc0, 0x72, 0x89, 0xff, 0x86, 0xff);
|
|
write_regs (udev, 7, 0xa8, 0x80, 0x83, 0xa2, 0x85, 0xc8, 0x83, 0x82,
|
|
0x85, 0xaf, 0x83, 0x00, 0x93, 0x00);
|
|
write_regs (udev, 3, 0xa8, 0x0a, 0x8c, 0x08, 0x94, 0x00);
|
|
write_regs (udev, 4, 0x83, 0x00, 0xa3, 0x00, 0xa4, 0x00, 0x97, 0x0a);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
write_regs (udev, 1, 0x97, 0x0b);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
write_regs (udev, 1, 0x97, 0x0f);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
write_regs (udev, 1, 0x97, 0x05);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
DBG (2, "-reset_scanner\n");
|
|
}
|
|
|
|
static void
|
|
poll1 (p_usb_dev_handle udev)
|
|
{
|
|
unsigned char rd_byte;
|
|
DBG (2, "+poll1\n");
|
|
do
|
|
{
|
|
write_regs (udev, 1, 0x97, 0x00);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
}
|
|
while (0 == (rd_byte & 0x40));
|
|
DBG (2, "-poll1\n");
|
|
}
|
|
|
|
static void
|
|
poll2 (p_usb_dev_handle udev)
|
|
{
|
|
unsigned char rd_byte;
|
|
DBG (2, "+poll2\n");
|
|
do
|
|
{
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
}
|
|
while (0 == (rd_byte & 0x02));
|
|
DBG (2, "-poll2\n");
|
|
}
|
|
|
|
#ifndef BACKENDNAME
|
|
static void
|
|
check_buttons (p_usb_dev_handle udev, int *scan, int *print, int *mail)
|
|
{
|
|
unsigned char rd_byte;
|
|
|
|
write_regs (udev, 4, 0x83, 0x00, 0xa3, 0x00, 0xa4, 0x00, 0x97, 0x0a);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
if (scan)
|
|
{
|
|
if (0 == (rd_byte & 1))
|
|
*scan = 1;
|
|
else
|
|
*scan = 0;
|
|
}
|
|
if (print)
|
|
{
|
|
if (0 == (rd_byte & 2))
|
|
*print = 1;
|
|
else
|
|
*print = 0;
|
|
}
|
|
if (mail)
|
|
{
|
|
if (0 == (rd_byte & 4))
|
|
*mail = 1;
|
|
else
|
|
*mail = 0;
|
|
}
|
|
write_regs (udev, 1, 0x97, 0x0b);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
idle_ab (udev);
|
|
write_regs (udev, 1, 0x97, 0x0f);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
idle_ab (udev);
|
|
write_regs (udev, 1, 0x97, 0x05);
|
|
write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
|
|
read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
|
|
idle_ab (udev);
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
lut (int val, double gain, int offset)
|
|
{
|
|
/* int offset = 1800; */
|
|
/* double exponent = 3.5; */
|
|
return (offset + 8192.0 * (pow ((8192.0 - val) / 8192.0, gain)));
|
|
}
|
|
|
|
|
|
static void
|
|
calc_lightmap (unsigned short *buff,
|
|
unsigned short *storage, int index, int dpi,
|
|
double gain, int offset)
|
|
{
|
|
int val, line;
|
|
int px = 5632;
|
|
int i;
|
|
|
|
line = px * 3;
|
|
|
|
for (i = 0; i < px; i++)
|
|
{
|
|
if ((i >= 2) && (i <= (px - 2)))
|
|
{
|
|
val = 0;
|
|
val += 1 * buff[i * 3 + index - 3 * 2];
|
|
val += 3 * buff[i * 3 + index - 3 * 1];
|
|
val += 5 * buff[i * 3 + index + 3 * 0];
|
|
val += 3 * buff[i * 3 + index + 3 * 1];
|
|
val += 1 * buff[i * 3 + index + 3 * 2];
|
|
val += 2 * buff[i * 3 + index - 3 * 1 + line];
|
|
val += 3 * buff[i * 3 + index + 3 * 0 + line];
|
|
val += 2 * buff[i * 3 + index + 3 * 1 + line];
|
|
val += 1 * buff[i * 3 + index + 3 * 0 + 2 * line];
|
|
val /= 21;
|
|
}
|
|
else
|
|
{
|
|
val = 1 * buff[i * 3 + index];
|
|
}
|
|
|
|
val = val >> 3;
|
|
if (val > 8191)
|
|
val = 8191;
|
|
val = lut (val, gain, offset);
|
|
|
|
if (val > 8191)
|
|
val = 8191;
|
|
if (val < 0)
|
|
val = 0;
|
|
storage[i * (dpi == 1200 ? 2 : 1)] = val;
|
|
if (dpi == 1200)
|
|
storage[i * 2 + 1] = val;
|
|
}
|
|
|
|
fix_endian_short (storage, (dpi == 1200) ? i * 2 : i);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*#define VALMAP 0x1fff */
|
|
/*#define SCANMAP 0x2000*/
|
|
#define RAWPIXELS600 7320
|
|
#define RAWPIXELS1200 14640
|
|
|
|
static void
|
|
select_pixels (unsigned short *map, int dpi, int start, int end)
|
|
{
|
|
int i;
|
|
int skip, offset;
|
|
unsigned short VALMAP = 0x1fff;
|
|
unsigned short SCANMAP = 0x2000;
|
|
|
|
fix_endian_short (&VALMAP, 1);
|
|
fix_endian_short (&SCANMAP, 1);
|
|
|
|
/* Clear the pixel-on flags for all bits */
|
|
for (i = 0; i < ((dpi == 1200) ? RAWPIXELS1200 : RAWPIXELS600); i++)
|
|
map[i] &= VALMAP;
|
|
|
|
/* 300 and 150 have subsampling */
|
|
if (dpi == 300)
|
|
skip = -2;
|
|
else if (dpi == 150)
|
|
skip = -4;
|
|
else
|
|
skip = -1;
|
|
|
|
/* 1200 has 2x pixels so start at 2x the offset */
|
|
if (dpi == 1200)
|
|
offset = 234 + (8.5 * 1200);
|
|
else
|
|
offset = 117 + (8.5 * 600);
|
|
|
|
if (0 == (offset & 1))
|
|
offset++;
|
|
|
|
DBG (2, "offset=%d start=%d skip=%d\n", offset, start, skip);
|
|
|
|
for (i = 0; i < end; i++)
|
|
{
|
|
int x;
|
|
x = offset + (start * skip) + (i * skip);
|
|
if (x < 0 || x > ((dpi == 1200) ? RAWPIXELS1200 : RAWPIXELS600))
|
|
DBG (2, "ERR %d\n", x);
|
|
else
|
|
map[x] |= SCANMAP;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
set_lightmap_white (unsigned short *map, int dpi, int color)
|
|
{
|
|
int i;
|
|
unsigned short VALMAP = 0x1fff;
|
|
unsigned short SCANMAP = 0x2000;
|
|
|
|
fix_endian_short (&VALMAP, 1);
|
|
fix_endian_short (&SCANMAP, 1);
|
|
|
|
if (dpi != 1200)
|
|
{
|
|
memset (map, 0, RAWPIXELS600 * 2);
|
|
if (color != 0)
|
|
return; /* Only 1st has enables... */
|
|
for (i = 0; i < 22; i++)
|
|
map[7 + i] = SCANMAP; /* Get some black... */
|
|
for (i = 0; i < 1024; i++)
|
|
map[2048 + i] = SCANMAP; /* And some white... */
|
|
}
|
|
else
|
|
{
|
|
memset (map, 0, RAWPIXELS1200 * 2);
|
|
if (color != 0)
|
|
return;
|
|
for (i = 16; i < 61; i++)
|
|
map[i] = SCANMAP;
|
|
for (i = 4076; i < 6145; i++)
|
|
map[i] = SCANMAP;
|
|
/* 3rd is all clear */
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
set_lamp_timer (p_usb_dev_handle udev, int timeout_in_mins)
|
|
{
|
|
write_regs (udev, 7, 0xa8, 0x80, 0x83, 0xa2, 0x85, 0xc8, 0x83, 0x82,
|
|
0x85, 0xaf, 0x83, 0x00, 0x93, 0x00);
|
|
write_regs (udev, 3, 0xa8, timeout_in_mins * 2, 0x8c, 0x08, 0x94, 0x00);
|
|
idle_ab (udev);
|
|
write_regs (udev, 4, 0x83, 0x20, 0x8d, 0x26, 0x83, 0x00, 0x8d, 0xff);
|
|
}
|
|
|
|
|
|
static void
|
|
calculate_lut8 (double *poly, int skip, unsigned char *dest)
|
|
{
|
|
int i;
|
|
double sum, x;
|
|
if (!poly || !dest)
|
|
return;
|
|
for (i = 0; i < 8192; i += skip)
|
|
{
|
|
sum = poly[0];
|
|
x = (double) i;
|
|
sum += poly[1] * x;
|
|
x = x * i;
|
|
sum += poly[2] * x;
|
|
x = x * i;
|
|
sum += poly[3] * x;
|
|
x = x * i;
|
|
sum += poly[4] * x;
|
|
x = x * i;
|
|
sum += poly[5] * x;
|
|
x = x * i;
|
|
sum += poly[6] * x;
|
|
x = x * i;
|
|
sum += poly[7] * x;
|
|
x = x * i;
|
|
sum += poly[8] * x;
|
|
x = x * i;
|
|
sum += poly[9] * x;
|
|
x = x * i;
|
|
if (sum < 0)
|
|
sum = 0;
|
|
if (sum > 255)
|
|
sum = 255;
|
|
*dest = (unsigned char) sum;
|
|
dest++;
|
|
}
|
|
}
|
|
|
|
static void
|
|
download_lut8 (p_usb_dev_handle udev, int dpi, int incolor)
|
|
{
|
|
double color[10] = { 0.0, 1.84615261590892E-01, -2.19613868292657E-04,
|
|
1.79549523214101E-07, -8.69378513113239E-11,
|
|
2.56694911984996E-14, -4.67288886157239E-18,
|
|
5.11622894146250E-22, -3.08729724411991E-26,
|
|
7.88581670873938E-31
|
|
};
|
|
double gray[10] = { 0.0, 1.73089945056694E-01, -1.39794924306080E-04,
|
|
9.70266873814926E-08, -4.57503008236968E-11,
|
|
1.37092321631794E-14, -2.54395068387198E-18,
|
|
2.82432084125966E-22, -1.71787408822688E-26,
|
|
4.40306800664567E-31
|
|
};
|
|
unsigned char *lut;
|
|
|
|
DBG (2, "+download_lut8\n");
|
|
switch (dpi)
|
|
{
|
|
case 150:
|
|
case 300:
|
|
case 600:
|
|
lut = (unsigned char *) malloc (4096);
|
|
if (!lut)
|
|
return;
|
|
|
|
if (!incolor)
|
|
{
|
|
calculate_lut8 (gray, 2, lut);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x20, 0xb2, 0x07, 0xb3, 0xff,
|
|
0xb4, 0x2f, 0xb5, 0x07);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x1000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 4096, wr_timeout);
|
|
}
|
|
else
|
|
{
|
|
calculate_lut8 (color, 2, lut);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x10, 0xb2, 0x07, 0xb3, 0xff,
|
|
0xb4, 0x1f, 0xb5, 0x07);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x1000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 4096, wr_timeout);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x20, 0xb2, 0x07, 0xb3, 0xff,
|
|
0xb4, 0x2f, 0xb5, 0x07);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x1000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 4096, wr_timeout);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x30, 0xb2, 0x07, 0xb3, 0xff,
|
|
0xb4, 0x3f, 0xb5, 0x07);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x1000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 4096, wr_timeout);
|
|
}
|
|
break;
|
|
|
|
case 1200:
|
|
default:
|
|
lut = (unsigned char *) malloc (8192);
|
|
if (!lut)
|
|
return;
|
|
|
|
if (!incolor)
|
|
{
|
|
calculate_lut8 (gray, 1, lut);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x40, 0xb2, 0x06, 0xb3, 0xff,
|
|
0xb4, 0x5f, 0xb5, 0x06);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x2000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 8192, wr_timeout);
|
|
}
|
|
else
|
|
{
|
|
calculate_lut8 (color, 1, lut);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x20, 0xb2, 0x06, 0xb3, 0xff,
|
|
0xb4, 0x3f, 0xb5, 0x06);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x2000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 8192, wr_timeout);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x40, 0xb2, 0x06, 0xb3, 0xff,
|
|
0xb4, 0x5f, 0xb5, 0x06);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x2000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 8192, wr_timeout);
|
|
write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x60, 0xb2, 0x06, 0xb3, 0xff,
|
|
0xb4, 0x7f, 0xb5, 0x06);
|
|
write_vctl (udev, 0x0c, 0x0002, 0x2000, 0x00);
|
|
usb_bulk_write (udev, 2, lut, 8192, wr_timeout);
|
|
}
|
|
break;
|
|
}
|
|
|
|
free (lut);
|
|
DBG (2, "-download_lut8\n");
|
|
}
|
|
|
|
|
|
static void
|
|
set_gain_black (p_usb_dev_handle udev,
|
|
int r_gain, int g_gain, int b_gain,
|
|
int r_black, int g_black, int b_black)
|
|
{
|
|
write_regs (udev, 1, 0x80, 0x00);
|
|
write_regs (udev, 1, 0x80, 0x01);
|
|
write_regs (udev, 1, 0x04, 0x80);
|
|
write_regs (udev, 1, 0x04, 0x00);
|
|
write_regs (udev, 1, 0x00, 0x00);
|
|
write_regs (udev, 1, 0x01, 0x03);
|
|
write_regs (udev, 1, 0x02, 0x04);
|
|
write_regs (udev, 1, 0x03, 0x11);
|
|
write_regs (udev, 1, 0x05, 0x00);
|
|
write_regs (udev, 1, 0x28, r_gain);
|
|
write_regs (udev, 1, 0x29, g_gain);
|
|
write_regs (udev, 1, 0x2a, b_gain);
|
|
write_regs (udev, 1, 0x20, r_black);
|
|
write_regs (udev, 1, 0x21, g_black);
|
|
write_regs (udev, 1, 0x22, b_black);
|
|
write_regs (udev, 1, 0x24, 0x00);
|
|
write_regs (udev, 1, 0x25, 0x00);
|
|
write_regs (udev, 1, 0x26, 0x00);
|
|
}
|
|
|
|
/* Handle short endianness issues */
|
|
static void
|
|
fix_endian_short (unsigned short *data, int count)
|
|
{
|
|
unsigned short testvalue = 255;
|
|
unsigned char *firstbyte = (unsigned char *) &testvalue;
|
|
int i;
|
|
|
|
if (*firstbyte == 255)
|
|
return; /* INTC endianness */
|
|
|
|
DBG (2, "swapping endianness...\n");
|
|
for (i = 0; i < count; i++)
|
|
data[i] = ((data[i] >> 8) & 0x00ff) | ((data[i] << 8) & 0xff00);
|
|
}
|