summaryrefslogtreecommitdiff
path: root/backend/sm3840_lib.c
diff options
context:
space:
mode:
Diffstat (limited to 'backend/sm3840_lib.c')
-rwxr-xr-xbackend/sm3840_lib.c1004
1 files changed, 1004 insertions, 0 deletions
diff --git a/backend/sm3840_lib.c b/backend/sm3840_lib.c
new file mode 100755
index 0000000..485003c
--- /dev/null
+++ b/backend/sm3840_lib.c
@@ -0,0 +1,1004 @@
+/* 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, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ As a special exception, the authors of SANE give permission for
+ additional uses of the libraries contained in this release of SANE.
+
+ The exception is that, if you link a SANE library with other files
+ to produce an executable, this does not by itself cause the
+ resulting executable to be covered by the GNU General Public
+ License. Your use of that executable is in no way restricted on
+ account of linking the SANE library code into it.
+
+ This exception does not, however, invalidate any other reasons why
+ the executable file might be covered by the GNU General Public
+ License.
+
+ If you submit changes to SANE to the maintainers to be included in
+ a subsequent release, you agree by submitting the changes that
+ those changes may be distributed with this exception intact.
+
+ If you write modifications of your own for SANE, it is your choice
+ whether to permit this exception to apply to your modifications.
+ If you do not wish that, delete this exception notice.
+
+*/
+
+#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;
+
+ timeout = timeout;
+ ep = 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;
+
+ timeout = timeout;
+ ep = 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;
+
+ timeout = 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 len, i;
+ unsigned char buff[8] = { 0x64, 0x65, 0x16, 0x17, 0x64, 0x65, 0x44, 0x45 };
+ for (i = 0; i < 8; i++)
+ {
+ len = 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, unsigned char reg1,
+ unsigned char val1,
+ ... /*unsigned char reg, unsigned char val, ... */ )
+{
+ unsigned char buff[512];
+ va_list marker;
+ int len, 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);
+
+ len = 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)
+{
+ int len;
+ 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... */
+ len = 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;
+ int len;
+
+ 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);
+ len = 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);
+ len = 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);
+ len = 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);
+ len = 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);
+ len = 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);
+ len = 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);
+ len = 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);
+ len = 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 endiannes...\n");
+ for (i = 0; i < count; i++)
+ data[i] = ((data[i] >> 8) & 0x00ff) | ((data[i] << 8) & 0xff00);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-25 11:26:50 +0000