summaryrefslogtreecommitdiff
path: root/backend/p5_device.c
diff options
context:
space:
mode:
Diffstat (limited to 'backend/p5_device.c')
-rw-r--r--backend/p5_device.c1611
1 files changed, 1611 insertions, 0 deletions
diff --git a/backend/p5_device.c b/backend/p5_device.c
new file mode 100644
index 0000000..c065ca2
--- /dev/null
+++ b/backend/p5_device.c
@@ -0,0 +1,1611 @@
+/**
+ * Description of the Primax PagePartner model
+ */
+static P5_Model pagepartner_model = {
+ "Primax PagePartner",
+ "Primax",
+ "PagePartner",
+ SANE_I18N ("sheetfed scanner"),
+
+ {300, 200, 150, 100, 0},
+ /* 500 seems also possible */
+ {600, 400, 300, 200, 150, 100, 0},
+
+ 300,
+ 600,
+ 100,
+ 100,
+ 16,
+
+ SANE_FIX (0.0),
+ SANE_FIX (0.0),
+ SANE_FIX (215.9),
+ SANE_FIX (300.0),
+};
+
+#ifdef HAVE_LINUX_PPDEV_H
+static char *
+addr_name (uint16_t addr)
+{
+ switch (addr)
+ {
+ case DATA:
+ return "DATA";
+ break;
+ case STATUS:
+ return "STATUS";
+ break;
+ case CONTROL:
+ return "CONTROL";
+ break;
+ case EPPADR:
+ return "EPPADR";
+ break;
+ case EPPDATA:
+ return "EPPDATA";
+ break;
+ default:
+ return "*ERROR*";
+ }
+}
+#endif
+
+/** @brief low level hardware access functions
+ * @{
+ */
+
+static uint8_t
+inb (int fd, uint16_t addr)
+{
+#ifdef HAVE_LINUX_PPDEV_H
+ uint8_t val = 0xff;
+ int rc, mode = 0xff;
+
+ switch (addr)
+ {
+ case DATA:
+ rc = ioctl (fd, PPRDATA, &val);
+ break;
+ case STATUS:
+ rc = ioctl (fd, PPRSTATUS, &val);
+ break;
+ case CONTROL:
+ rc = ioctl (fd, PPRCONTROL, &val);
+ break;
+ case EPPDATA:
+ mode = 1; /* data_reverse */
+ rc = ioctl (fd, PPDATADIR, &mode);
+ mode = IEEE1284_MODE_EPP | IEEE1284_DATA;
+ rc = ioctl (fd, PPSETMODE, &mode);
+#ifdef PPSETFLAGS
+ mode = PP_FASTREAD;
+ rc = ioctl (fd, PPSETFLAGS, &mode);
+#endif
+ rc = read (fd, &val, 1);
+ break;
+ default:
+ DBG (DBG_error, "inb(%s) escaped ppdev\n", addr_name (addr));
+ return 0xFF;
+ }
+ if (rc < 0)
+ {
+ DBG (DBG_error, "ppdev ioctl returned <%s>\n", strerror (errno));
+ }
+ return val;
+#else
+ if(fd && addr)
+ return 0;
+ return 0;
+#endif
+}
+
+static void
+outb (int fd, uint16_t addr, uint8_t value)
+{
+#ifdef HAVE_LINUX_PPDEV_H
+ int rc = 0, mode = 0xff;
+
+ switch (addr)
+ {
+ case DATA:
+ rc = ioctl (fd, PPWDATA, &value);
+ break;
+ case CONTROL:
+ mode = value & 0x20;
+ rc = ioctl (fd, PPDATADIR, &mode);
+ if (!rc)
+ {
+ value = value & 0xDF;
+ rc = ioctl (fd, PPWCONTROL, &value);
+ }
+ break;
+ case EPPDATA:
+ mode = 0; /* data forward */
+ rc = ioctl (fd, PPDATADIR, &mode);
+ mode = IEEE1284_MODE_EPP | IEEE1284_DATA;
+ rc = ioctl (fd, PPSETMODE, &mode);
+ rc = write (fd, &value, 1);
+ break;
+ case EPPADR:
+ mode = 0; /* data forward */
+ rc = ioctl (fd, PPDATADIR, &mode);
+ mode = IEEE1284_MODE_EPP | IEEE1284_ADDR;
+ rc = ioctl (fd, PPSETMODE, &mode);
+ rc = write (fd, &value, 1);
+ break;
+ default:
+ DBG (DBG_error, "outb(%s,0x%02x) escaped ppdev\n", addr_name (addr),
+ value);
+ break;
+ }
+ if (rc < 0)
+ {
+ DBG (DBG_error, "ppdev ioctl returned <%s>\n", strerror (errno));
+ }
+#else
+ if(fd && addr && value)
+ return;
+#endif /* HAVE_LINUX_PPDEV_H */
+}
+
+static void
+write_reg (int fd, uint8_t index, uint8_t value)
+{
+ uint8_t idx;
+
+ /* both nibbles hold the same value */
+ idx = index & 0x0F;
+ DBG (DBG_io2, "write_reg(REG%X,0x%x)\n", idx, value);
+ idx = idx << 4 | idx;
+ outb (fd, EPPADR, idx);
+ outb (fd, EPPDATA, value);
+}
+
+static uint8_t
+read_reg (int fd, uint8_t index)
+{
+ uint8_t idx;
+
+ /* both nibbles hold the same value */
+ idx = index & 0x0F;
+ idx = idx << 4 | idx;
+ outb (fd, EPPADR, idx);
+ return inb (fd, EPPDATA);
+}
+
+#ifdef HAVE_LINUX_PPDEV_H
+static int
+read_data (int fd, uint8_t * data, int length)
+{
+ int mode, rc, nb;
+ unsigned char bval;
+
+ bval = REG8;
+ mode = IEEE1284_MODE_EPP | IEEE1284_ADDR;
+ rc = ioctl (fd, PPSETMODE, &mode);
+ rc = write (fd, &bval, 1);
+
+ mode = 1; /* data_reverse */
+ rc = ioctl (fd, PPDATADIR, &mode);
+#ifdef PPSETFLAGS
+ mode = PP_FASTREAD;
+ rc = ioctl (fd, PPSETFLAGS, &mode);
+#endif
+ mode = IEEE1284_MODE_EPP | IEEE1284_DATA;
+ rc = ioctl (fd, PPSETMODE, &mode);
+ nb = 0;
+ while (nb < length)
+ {
+ rc = read (fd, data + nb, length - nb);
+ if (rc < 0)
+ {
+ DBG (DBG_error, "memtest: error reading data back!\n");
+ return 0;
+ }
+ else
+ {
+ nb += rc;
+ }
+ }
+
+ return 1;
+}
+
+static void
+index_write_data (int fd, uint8_t index, uint8_t * data, int length)
+{
+ int mode, rc;
+ unsigned char bval;
+
+ bval = index;
+ mode = IEEE1284_MODE_EPP | IEEE1284_ADDR;
+ rc = ioctl (fd, PPSETMODE, &mode);
+ rc = write (fd, &bval, 1);
+
+ mode = IEEE1284_MODE_EPP | IEEE1284_DATA;
+ rc = ioctl (fd, PPSETMODE, &mode);
+ mode = 0; /* data forward */
+ rc = ioctl (fd, PPDATADIR, &mode);
+ rc = write (fd, data, length);
+ return;
+}
+
+static void
+write_data (int fd, uint8_t * data, int length)
+{
+ index_write_data (fd, REG8, data, length);
+}
+
+static void
+write_reg2 (int fd, uint8_t index, uint16_t value)
+{
+ uint8_t data2[2];
+
+ data2[0] = value & 0xff;
+ data2[1] = value >> 8;
+ index_write_data (fd, index, data2, 2);
+}
+#else
+
+static int
+read_data (int fd, uint8_t * data, int length)
+{
+ if(fd && data && length)
+ return -1;
+ return -1;
+}
+
+static void
+write_data (int fd, uint8_t * data, int length)
+{
+ if(fd && data && length)
+ return;
+}
+
+static void
+write_reg2 (int fd, uint8_t index, uint16_t value)
+{
+ if(fd && index && value)
+ return;
+}
+#endif
+
+/**
+ * @}
+ */
+
+
+/** @brief This function checks a memory buffer.
+ * This function writes at the given memory address then read it back
+ * to check the scanner is correctly working.
+ * @param fd file descriptor used to access hardware
+ * @param addr address where to write and read
+ * @return SANE_TRUE on succes, SANE_FALSE otherwise
+ */
+static int
+memtest (int fd, uint16_t addr)
+{
+ uint8_t sent[256];
+ uint8_t back[256];
+ int i;
+
+ write_reg2 (fd, REG1, addr);
+ for (i = 0; i < 256; i++)
+ {
+ sent[i] = (uint8_t) i;
+ back[i] = 0;
+ }
+ write_data (fd, sent, 256);
+ read_data (fd, back, 256);
+
+ /* check if data read back is the same that the one sent */
+ for (i = 0; i < 256; i++)
+ {
+ if (back[i] != sent[i])
+ {
+ return SANE_FALSE;
+ }
+ }
+
+ return SANE_TRUE;
+}
+
+
+#define INB(k,y,z) val=inb(k,y); if(val!=z) { DBG(DBG_error,"expected 0x%02x, got 0x%02x\n",z, val); return SANE_FALSE; }
+
+/** @brief connect to scanner
+ * This function sends the connect sequence for the scanner.
+ * @param fd filedescriptor of the parallel port communication channel
+ * @return SANE_TRUE in case of success, SANE_FALSE otherwise
+ */
+static int
+connect (int fd)
+{
+ uint8_t val;
+
+ inb (fd, CONTROL);
+ outb (fd, CONTROL, 0x04);
+ outb (fd, DATA, 0x02);
+ INB (fd, DATA, 0x02);
+ outb (fd, DATA, 0x03);
+ INB (fd, DATA, 0x03);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ outb (fd, DATA, 0x03);
+ outb (fd, DATA, 0x83);
+ INB (fd, DATA, 0x83);
+ outb (fd, DATA, 0x82);
+ INB (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ outb (fd, DATA, 0x02);
+ outb (fd, DATA, 0x82);
+ outb (fd, DATA, 0xFF);
+ DBG (DBG_info, "connect() OK...\n");
+ return SANE_TRUE;
+}
+
+static int
+disconnect (int fd)
+{
+ uint8_t val;
+
+ outb (fd, CONTROL, 0x04);
+ outb (fd, DATA, 0x00);
+ INB (fd, DATA, 0x00);
+ outb (fd, DATA, 0x01);
+ INB (fd, DATA, 0x01);
+ outb (fd, DATA, 0x01);
+ outb (fd, DATA, 0x81);
+ outb (fd, DATA, 0x01);
+ outb (fd, DATA, 0x81);
+ INB (fd, DATA, 0x81);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x81);
+ INB (fd, DATA, 0x81);
+ outb (fd, DATA, 0x01);
+ outb (fd, DATA, 0x81);
+ outb (fd, DATA, 0x01);
+ outb (fd, DATA, 0x81);
+ INB (fd, DATA, 0x81);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ INB (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ outb (fd, DATA, 0x00);
+ outb (fd, DATA, 0x80);
+ inb (fd, CONTROL);
+ outb (fd, CONTROL, 0x0C);
+
+ return SANE_STATUS_GOOD;
+}
+
+static void
+setadresses (int fd, uint16_t start, uint16_t end)
+{
+ write_reg (fd, REG3, start & 0xff);
+ write_reg (fd, REG4, start >> 8);
+ write_reg (fd, REG5, end & 0xff);
+ write_reg (fd, REG6, end >> 8);
+ DBG (DBG_io, "setadresses(0x%x,0x%x); OK...\n", start, end);
+}
+
+#ifdef HAVE_LINUX_PPDEV_H
+/** @brief open parallel port device
+ * opens parallel port's low level device in EPP mode
+ * @param devicename nam of the real device or the special value 'auto'
+ * @return file descriptor in cas of successn -1 otherwise
+ */
+static int
+open_pp (const char *devicename)
+{
+ int fd, rc, mode = 0;
+ char *name;
+
+ DBG (DBG_proc, "open_pp: start, devicename=%s\n", devicename);
+ /* TODO improve auto device finding */
+ if (strncmp (devicename, "auto", 4) == 0)
+ {
+ name = strdup("/dev/parport0");
+ }
+ else
+ {
+ name = strdup(devicename);
+ }
+
+ /* open device */
+ fd = open (name, O_RDWR);
+ if (fd < 0)
+ {
+ switch (errno)
+ {
+ case ENOENT:
+#ifdef ENIO
+ case ENXIO:
+#endif
+#ifdef ENODEV
+ case ENODEV:
+#endif
+ DBG (DBG_error, "open_pp: no %s device ...\n", name);
+ break;
+ case EACCES:
+ DBG (DBG_error,
+ "open_pp: current user cannot use existing %s device ...\n",
+ name);
+ break;
+ default:
+ DBG (DBG_error, "open_pp: %s while opening %s\n", strerror (errno),
+ name);
+ }
+ return -1;
+ }
+ free(name);
+
+ /* claim device and set it to EPP */
+ rc = ioctl (fd, PPCLAIM);
+ rc = ioctl (fd, PPGETMODES, &mode);
+ if (mode & PARPORT_MODE_PCSPP)
+ DBG (DBG_io, "PARPORT_MODE_PCSPP\n");
+ if (mode & PARPORT_MODE_TRISTATE)
+ DBG (DBG_io, "PARPORT_MODE_TRISTATE\n");
+ if (mode & PARPORT_MODE_EPP)
+ DBG (DBG_io, "PARPORT_MODE_EPP\n");
+ if (mode & PARPORT_MODE_ECP)
+ DBG (DBG_io, "PARPORT_MODE_ECP\n");
+ if (mode & PARPORT_MODE_COMPAT)
+ DBG (DBG_io, "PARPORT_MODE_COMPAT\n");
+ if (mode & PARPORT_MODE_DMA)
+ DBG (DBG_io, "PARPORT_MODE_DMA\n");
+ if (mode & PARPORT_MODE_EPP)
+ {
+ mode = IEEE1284_MODE_EPP;
+ }
+ else
+ {
+ /*
+ if (mode & PARPORT_MODE_ECP)
+ {
+ mode = IEEE1284_MODE_ECP;
+ }
+ else
+ */
+ {
+ mode = -1;
+ }
+ }
+ if (mode == -1)
+ {
+ DBG (DBG_error, "open_pp: no EPP mode, giving up ...\n");
+ rc = ioctl (fd, PPRELEASE);
+ close (fd);
+ return -1;
+ }
+ rc = ioctl (fd, PPNEGOT, &mode);
+ rc = ioctl (fd, PPSETMODE, &mode);
+ DBG (DBG_proc, "open_pp: exit\n");
+ return fd;
+}
+
+/** close low level device
+ * release and close low level hardware device
+ */
+static void
+close_pp (int fd)
+{
+ int mode = IEEE1284_MODE_COMPAT;
+
+ if (fd > 2)
+ {
+ ioctl (fd, PPNEGOT, &mode);
+ ioctl (fd, PPRELEASE);
+ close (fd);
+ }
+}
+
+#else /* HAVE_LINUX_PPDEV_H */
+
+static int
+open_pp (const char *devicename)
+{
+ if(devicename)
+ return -1;
+ return -1;
+}
+
+static void
+close_pp (int fd)
+{
+ if(fd)
+ return;
+}
+#endif /* HAVE_LINUX_PPDEV_H */
+
+/** @brief test if a document is inserted
+ * Test if a document is inserted by reading register E
+ * @param fd file descriptor to access scanner
+ * @return SANE_STATUS_NO_DOCS if no document or SANE_STATUS_GOOD
+ * if something is present.
+ */
+static SANE_Status
+test_document (int fd)
+{
+ int detector;
+
+ /* check for document presence 0xC6: present, 0xC3 no document */
+ detector = read_reg (fd, REGE);
+ DBG (DBG_io, "test_document: detector=0x%02X\n", detector);
+
+ /* document inserted */
+ if (detector & 0x04)
+ return SANE_STATUS_GOOD;
+
+ return SANE_STATUS_NO_DOCS;
+}
+
+/**
+ * return the amount of scanned data available
+ * @param fd file descriptor to access scanner
+ * @return avaible byte number
+ */
+static int
+available_bytes (int fd)
+{
+ int counter;
+
+ /* read the number of 256 bytes block of scanned data */
+ counter = read_reg (fd, REG9);
+ DBG (DBG_io, "available_bytes: available_bytes=0x%02X\n", counter);
+ return 256 * counter;
+}
+
+static SANE_Status
+build_correction (P5_Device * dev, unsigned int dpi, unsigned int mode,
+ unsigned int start, unsigned int width)
+{
+ unsigned int i, j, shift, step;
+
+ DBG (DBG_proc, "build_correction: start=%d, width=%d\n", start, width);
+ DBG (DBG_trace, "build_correction: dpi=%d, mode=%d\n", dpi, mode);
+
+ /* loop on calibration data to find the matching one */
+ j = 0;
+ while (dev->calibration_data[j]->dpi != dpi)
+ {
+ j++;
+ if (j > MAX_RESOLUTIONS)
+ {
+ DBG (DBG_error, "build_correction: couldn't find calibration!\n");
+ return SANE_STATUS_INVAL;
+ }
+ }
+
+ if (dev->gain != NULL)
+ {
+ free (dev->gain);
+ dev->gain = NULL;
+ }
+ if (dev->offset != NULL)
+ {
+ free (dev->offset);
+ dev->offset = NULL;
+ }
+ dev->gain = (float *) malloc (width * sizeof (float));
+ if (dev->gain == NULL)
+ {
+ DBG (DBG_error,
+ "build_correction: failed to allocate memory for gain!\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ dev->offset = (uint8_t *) malloc (width);
+ if (dev->offset == NULL)
+ {
+ DBG (DBG_error,
+ "build_correction: failed to allocate memory for offset!\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ /* compute starting point of calibration data to use */
+ shift = start;
+ step = 1;
+ if (mode == MODE_GRAY)
+ {
+ /* we use green data */
+ shift += 1;
+ step = 3;
+ }
+ for (i = 0; i < width; i += step)
+ {
+ if (dev->calibration_data[j]->white_data[shift + i] -
+ dev->calibration_data[0]->black_data[shift + i] > BLACK_LEVEL)
+ {
+ dev->gain[i] =
+ WHITE_TARGET /
+ ((float)
+ (dev->calibration_data[j]->white_data[shift + i] -
+ dev->calibration_data[j]->black_data[shift + i]));
+ dev->offset[i] = dev->calibration_data[j]->black_data[shift + i];
+ }
+ else
+ {
+ dev->gain[i] = 1.0;
+ dev->offset[i] = 0;
+ }
+ }
+ return SANE_STATUS_GOOD;
+ DBG (DBG_proc, "build_correction: end\n");
+}
+
+/** @brief start up a real scan
+ * This function starts the scan with the given parameters.
+ * @param dev device describing hardware
+ * @param mode color, gray level or lineart.
+ * @param dpi desired scan resolution.
+ * @param startx coordinate of the first pixel to scan in
+ * scan's resolution coordinate
+ * @param width width of the scanned area
+ * scanner's physical scan aread.
+ * @return SANE_STATUS_GOOD if scan is successfully started
+ */
+static SANE_Status
+start_scan (P5_Device * dev, int mode, unsigned int dpi, unsigned int startx,
+ unsigned int width)
+{
+ uint8_t reg0=0;
+ uint8_t reg2=0;
+ uint8_t regF=0;
+ uint16_t addr=0;
+ uint16_t start, end;
+ unsigned int xdpi;
+
+ DBG (DBG_proc, "start_scan: start \n");
+ DBG (DBG_io, "start_scan: startx=%d, width=%d, dpi=%d\n", startx, width,
+ dpi);
+
+ /** @brief register values
+ * - reg2 : reg2 seems related to x dpi and provides only 100,
+ * 150, 200 and 300 resolutions.
+ * - regF : lower nibble gives y dpi resolution ranging from 150
+ * to 1200 dpi.
+ */
+ xdpi = dpi;
+ switch (dpi)
+ {
+ case 100:
+ reg2 = 0x90;
+ regF = 0xA2;
+ break;
+ case 150:
+ reg2 = 0x10;
+ regF = 0xA4;
+ break;
+ case 200:
+ reg2 = 0x80;
+ regF = 0xA6;
+ break;
+ case 300:
+ reg2 = 0x00;
+ regF = 0xA8;
+ break;
+ case 400:
+ reg2 = 0x80; /* xdpi=200 */
+ regF = 0xAA;
+ xdpi = 200;
+ break;
+ case 500:
+ reg2 = 0x00;
+ regF = 0xAC;
+ xdpi = 300;
+ break;
+ case 600:
+ reg2 = 0x00;
+ regF = 0xAE;
+ xdpi = 300;
+ break;
+ }
+
+ switch (mode)
+ {
+ case MODE_COLOR:
+ reg0 = 0x00;
+ addr = 0x0100;
+ break;
+ case MODE_GRAY:
+ /* green channel only */
+ reg0 = 0x20;
+ addr = 0x0100;
+ break;
+ case MODE_LINEART:
+ reg0 = 0x40;
+ addr = 0x0908;
+ break;
+ }
+
+ write_reg (dev->fd, REG1, 0x01);
+ write_reg (dev->fd, REG7, 0x00);
+ write_reg (dev->fd, REG0, reg0);
+ write_reg (dev->fd, REG1, 0x00);
+ write_reg (dev->fd, REGF, regF);
+ /* the memory addr used to test need not to be related
+ * to resolution, 0x0100 could be always used */
+ /* TODO get rid of it */
+ memtest (dev->fd, addr);
+
+ /* handle case where dpi>xdpi */
+ start = startx;
+ if (dpi > xdpi)
+ {
+ width = (width * xdpi) / dpi;
+ start = (startx * xdpi) / dpi;
+ }
+
+ /* compute and set start addr */
+ if (mode == MODE_COLOR)
+ {
+ start = start * 3;
+ width = width * 3;
+ }
+ end = start + width + 1;
+
+ /* build calibration data for the scan */
+ if (dev->calibrated)
+ {
+ build_correction (dev, xdpi, mode, start, width);
+ }
+
+ setadresses (dev->fd, start, end);
+
+ write_reg (dev->fd, REG1, addr >> 8);
+ write_reg (dev->fd, REG2, reg2);
+ regF = (regF & 0x0F) | 0x80;
+ write_reg (dev->fd, REGF, regF);
+ write_reg (dev->fd, REG0, reg0);
+ if (mode == MODE_LINEART)
+ {
+ write_reg (dev->fd, 0x07, 0x04);
+ }
+ else
+ {
+ write_reg (dev->fd, 0x07, 0x00);
+ }
+ write_reg (dev->fd, REG1, addr >> 8);
+ write_reg2 (dev->fd, REG1, addr);
+ write_reg (dev->fd, REGF, regF | 0x01);
+ write_reg (dev->fd, REG0, reg0 | 0x0C);
+ if (mode == MODE_LINEART)
+ {
+ write_reg (dev->fd, REG1, 0x19);
+ }
+ else
+ {
+ write_reg (dev->fd, REG1, 0x11);
+ }
+ DBG (DBG_proc, "start_scan: exit\n");
+ return SANE_STATUS_GOOD;
+}
+
+/** read a line of scan data
+ * @param dev device to read
+ * @param data pointer where to store data
+ * @param length total bytes to read on one line
+ * @param ltr total number of lines to read
+ * @param retry signals that the function must read as much lines it can
+ * @param x2 tells that lines must be enlarged by a 2 factor
+ * @param mode COLOR_MODE if color mode
+ * @returns number of data lines read, -1 in case of error
+ */
+static int
+read_line (P5_Device * dev, uint8_t * data, size_t length, int ltr,
+ SANE_Bool retry, SANE_Bool x2, int mode, SANE_Bool correction)
+{
+ uint8_t counter, read, cnt;
+ uint8_t inbuffer[MAX_SENSOR_PIXELS * 2 * 3 + 2];
+ unsigned int i, factor;
+ float val;
+
+ DBG (DBG_proc, "read_line: trying to read %d lines of %lu bytes\n", ltr,
+ (unsigned long)length);
+
+ counter = read_reg (dev->fd, REG9);
+ DBG (DBG_io, "read_line: %d bytes available\n", counter * 256);
+ read = 0;
+ if (x2 == SANE_FALSE)
+ {
+ factor = 1;
+ }
+ else
+ {
+ factor = 2;
+ }
+
+ /* in retry mode we read until not enough data, but in no retry
+ * read only one line , counter give us 256 bytes block available
+ * and we want an number multiple of color channels */
+ cnt = (255 + length / factor) / 256;
+ while ((counter > cnt && retry == 1) || (counter > cnt && read == 0))
+ {
+ /* read data from scanner, first and last byte aren't picture data */
+ read_data (dev->fd, inbuffer, length / factor + 2);
+
+ /* image correction */
+ if (correction == SANE_TRUE)
+ {
+ for (i = 0; i < length / factor; i++)
+ {
+ val = inbuffer[i + 1] - dev->offset[i];
+ if (val > 0)
+ {
+ val = val * dev->gain[i];
+ if (val < 255)
+ inbuffer[i + 1] = val;
+ else
+ inbuffer[i + 1] = 255;
+ }
+ else
+ {
+ inbuffer[i + 1] = 0;
+ }
+ }
+ }
+
+ /* handle horizontal data doubling */
+ if (x2 == SANE_FALSE)
+ {
+ memcpy (data + read * length, inbuffer + 1, length);
+ }
+ else
+ {
+ if (mode == MODE_COLOR)
+ {
+ for (i = 0; i < length / factor; i += 3)
+ {
+ data[read * length + i * factor] = inbuffer[i + 1];
+ data[read * length + i * factor + 1] = inbuffer[i + 2];
+ data[read * length + i * factor + 2] = inbuffer[i + 3];
+ data[read * length + i * factor + 3] = inbuffer[i + 1];
+ data[read * length + i * factor + 4] = inbuffer[i + 2];
+ data[read * length + i * factor + 5] = inbuffer[i + 3];
+ }
+ }
+ else
+ {
+ for (i = 0; i < length / factor; i++)
+ {
+ data[read * length + i * factor] = inbuffer[i + 1];
+ data[read * length + i * factor + 1] = inbuffer[i + 1];
+ }
+ }
+ }
+ read++;
+ if (retry == SANE_TRUE)
+ {
+ read_reg (dev->fd, REGF);
+ read_reg (dev->fd, REGA);
+ read_reg (dev->fd, REG9);
+ counter = read_reg (dev->fd, REG9);
+ read_reg (dev->fd, REGA);
+ if (read >= ltr)
+ {
+ DBG (DBG_io, "read_line returning %d lines\n", read);
+ return read;
+ }
+ counter = read_reg (dev->fd, REG9);
+ }
+ }
+ read_reg (dev->fd, REGF);
+ read_reg (dev->fd, REGA);
+ read_reg (dev->fd, REG9);
+ counter = read_reg (dev->fd, REG9);
+ read_reg (dev->fd, REGA);
+ DBG (DBG_io, "read_line returning %d lines\n", read);
+ return read;
+}
+
+
+static SANE_Status
+eject (int fd)
+{
+ int detector;
+
+ DBG (DBG_proc, "eject: start ...\n");
+
+ do
+ {
+ write_reg2 (fd, REG1, 0x1110);
+ detector = read_reg (fd, REGE);
+ detector = read_reg (fd, REGE);
+ }
+ while ((detector & 0x04) != 0);
+ write_reg (fd, REG0, 0x00);
+ write_reg (fd, REG1, 0x00);
+ write_reg (fd, REGF, 0x82);
+ write_reg (fd, REG7, 0x00);
+
+ DBG (DBG_proc, "eject: end.\n");
+ return SANE_STATUS_GOOD;
+}
+
+/** @brief wait for document to be present in feeder
+ * Polls document sensor until something is present. Give up after 20 seconds
+ * @param fd file descriptor of the physical device
+ */
+/* static int
+wait_document (int fd, uint8_t detector)
+{
+ int count = 0;
+ uint8_t val;
+
+ write_reg (fd, REG1, 0x00);
+ write_reg (fd, REG7, 0x00);
+ detector = read_reg (fd, REGE);
+ while (detector == 0xc3 && count < 20)
+ {
+ sleep (1);
+ count++;
+ detector = read_reg (fd, REGE);
+ }
+ setadresses (fd, 0x002d, 0x09c7);
+ write_reg (fd, REG1, 0x00);
+ write_reg (fd, REG2, 0x90);
+ write_reg (fd, REGF, 0x82);
+ write_reg (fd, REG0, 0x00);
+ val = inb (fd, STATUS) & 0xf8;
+ if (val != 0xf8)
+ {
+ DBG (DBG_error, "wait_document: unexpected STATUS value 0x%02x instead of 0xf8", val);
+ }
+ if (count >= 20)
+ {
+ DBG (DBG_error, "wait_document: failed to detect document!\n");
+ return 0;
+ }
+ return 1;
+} */
+
+/** @brief move at 150 dpi
+ * move the paper at 150 dpi motor speed by the amount specified
+ * @params dev pointer to the device structure
+ */
+static SANE_Status
+move (P5_Device * dev)
+{
+ int skip, done, read, count;
+ SANE_Status status = SANE_STATUS_GOOD;
+ unsigned char buffer[256];
+
+ DBG (DBG_proc, "move: start\n");
+
+ /* compute number of lines to skip */
+ skip = dev->ystart;
+
+ /* works, but remains to be explained ... */
+ if (dev->ydpi > 300)
+ skip = skip / 2;
+
+ DBG (DBG_io, "move: skipping %d lines at %d dpi\n", skip, dev->ydpi);
+
+ /* we do a real scan of small width, discarding data */
+ done = 0;
+ status = start_scan (dev, MODE_GRAY, dev->ydpi, 0, 256);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "move: failed to start scan\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ do
+ {
+ /* test if document left the feeder */
+ status = test_document (dev->fd);
+ if (status == SANE_STATUS_NO_DOCS)
+ {
+ DBG (DBG_info,
+ "move: document was shorter than the required move\n");
+ return SANE_STATUS_INVAL;
+ }
+ /* test if data is available */
+ count = available_bytes (dev->fd);
+ if (count)
+ {
+ read =
+ read_line (dev, buffer, 256, 1, SANE_FALSE, SANE_FALSE,
+ MODE_GRAY, SANE_FALSE);
+ if (read == -1)
+ {
+ DBG (DBG_error, "move: failed to read data\n");
+ return SANE_STATUS_INVAL;
+ }
+ done += read;
+ }
+ }
+ while (done < skip);
+
+ /* reset scanner */
+ write_reg2 (dev->fd, REG1, 0x1110);
+ count = read_reg (dev->fd, REGE);
+ count = read_reg (dev->fd, REGE);
+ write_reg (dev->fd, REG0, 0x00);
+ write_reg (dev->fd, REG1, 0x00);
+ write_reg (dev->fd, REGF, 0x82);
+ write_reg (dev->fd, REG7, 0x00);
+
+ DBG (DBG_proc, "move: exit\n");
+ return status;
+}
+
+/** clean up calibration data
+ * @param dev device to clean up
+ */
+static void
+cleanup_calibration (P5_Device * dev)
+{
+ int i;
+
+ for (i = 0; i < MAX_RESOLUTIONS * 2; i++)
+ {
+ if (dev->calibration_data[i] != NULL)
+ {
+ free (dev->calibration_data[i]);
+ dev->calibration_data[i] = NULL;
+ }
+ }
+ dev->calibrated = SANE_FALSE;
+}
+
+/** detect a black scan line
+ * parses the given buffer and retrun SANE_TRUE if the line is an
+ * acceptable black line for calibration
+ * @param buffer data line to parse
+ * @param pixels number of pixels
+ * @param mode MODE_COLOR or MODE_GRAY
+ * @returns SANE_TRUE if it is considered as a white line
+ */
+static SANE_Bool
+is_black_line (uint8_t * buffer, unsigned int pixels, int mode)
+{
+ unsigned int i, start, end, count, width;
+
+ /* compute width in bytes */
+ if (mode == MODE_COLOR)
+ {
+ width = pixels * 3;
+ }
+ else
+ {
+ width = pixels;
+ }
+
+ /* we allow the calibration target to be narrower than full width, ie
+ * black margin at both ends of the line */
+ start = (5 * width) / 100;
+ end = (95 * width) / 100;
+ count = 0;
+
+ /* count number of black bytes */
+ for (i = start; i < end; i++)
+ {
+ if (buffer[i] > BLACK_LEVEL)
+ {
+ count++;
+ }
+ }
+
+ /* we allow 3% black pixels maximum */
+ if (count > (3 * width) / 100)
+ {
+ DBG (DBG_io, "is_black_line=SANE_FALSE\n");
+ return SANE_FALSE;
+ }
+
+ DBG (DBG_io, "is_black_line=SANE_TRUE\n");
+ return SANE_TRUE;
+}
+
+/** detect a white scan line
+ * parses the given buffer and retrun SANE_TRUE if the line is an
+ * acceptable white line for calibration
+ * @param buffer data line to parse
+ * @param pixels number of pixels
+ * @param mode MODE_COLOR or MODE_GRAY
+ * @returns SANE_TRUE if it is considered as a white line
+ */
+static SANE_Bool
+is_white_line (uint8_t * buffer, unsigned int pixels, int mode)
+{
+ unsigned int i, start, end, count, width;
+
+ /* compute width in bytes */
+ if (mode == MODE_COLOR)
+ {
+ width = pixels * 3;
+ }
+ else
+ {
+ width = pixels;
+ }
+
+ /* we allow the calibration target to be narrower than full width, ie
+ * black margin at both ends of the line */
+ start = (5 * width) / 100;
+ end = (95 * width) / 100;
+ count = 0;
+
+ /* count number of black bytes */
+ for (i = start; i < end; i++)
+ {
+ if (buffer[i] < BLACK_LEVEL)
+ {
+ count++;
+ }
+ }
+
+ /* we allow 3% black pixels maximum */
+ if (count > (3 * width) / 100)
+ {
+ DBG (DBG_io, "is_white_line=SANE_FALSE\n");
+ return SANE_FALSE;
+ }
+
+ DBG (DBG_io, "is_white_line=SANE_TRUE\n");
+ return SANE_TRUE;
+}
+
+/* ------------------------------------------------------------------------- */
+/* writes gray data to a pnm file */
+/*
+static void
+write_gray_data (unsigned char *image, char *name, SANE_Int width,
+ SANE_Int height)
+{
+ FILE *fdbg = NULL;
+
+ fdbg = fopen (name, "wb");
+ if (fdbg == NULL)
+ return;
+ fprintf (fdbg, "P5\n%d %d\n255\n", width, height);
+ fwrite (image, width, height, fdbg);
+ fclose (fdbg);
+}
+*/
+
+/* ------------------------------------------------------------------------- */
+/* writes rgb data to a pnm file */
+static void
+write_rgb_data (char *name, unsigned char *image, SANE_Int width,
+ SANE_Int height)
+{
+ FILE *fdbg = NULL;
+
+ fdbg = fopen (name, "wb");
+ if (fdbg == NULL)
+ return;
+ fprintf (fdbg, "P6\n%d %d\n255\n", width, height);
+ fwrite (image, width * 3, height, fdbg);
+ fclose (fdbg);
+}
+
+/** give calibration file name
+ * computes the calibration file name to use based on the
+ * backend name and device
+ */
+static char *
+calibration_file (const char *devicename)
+{
+ char *ptr = NULL;
+ char tmp_str[PATH_MAX];
+
+ ptr = getenv ("HOME");
+ if (ptr != NULL)
+ {
+ sprintf (tmp_str, "%s/.sane/p5-%s.cal", ptr, devicename);
+ }
+ else
+ {
+ ptr = getenv ("TMPDIR");
+ if (ptr != NULL)
+ {
+ sprintf (tmp_str, "%s/p5-%s.cal", ptr, devicename);
+ }
+ else
+ {
+ sprintf (tmp_str, "/tmp/p5-%s.cal", devicename);
+ }
+ }
+ DBG (DBG_trace, "calibration_file: using >%s< for calibration file name\n",
+ tmp_str);
+ return strdup (tmp_str);
+}
+
+/** restore calibration data
+ * restore calibration data by loading previously saved calibration data
+ * @param dev device to restore
+ * @return SANE_STATUS_GOOD on success, otherwise error code
+ */
+static SANE_Status
+restore_calibration (P5_Device * dev)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ char *fname = NULL;
+ FILE *fcalib = NULL;
+ size_t size;
+ int i;
+
+ DBG (DBG_proc, "restore_calibration: start\n");
+ cleanup_calibration (dev);
+ fname = calibration_file (dev->model->name);
+ fcalib = fopen (fname, "rb");
+ if (fcalib == NULL)
+ {
+ DBG (DBG_error, "restore_calibration: failed to open %s!\n", fname);
+ free (fname);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ /* loop filling calibration data until EOF reached */
+ i = 0;
+ while (!feof (fcalib) && (i < 2 * MAX_RESOLUTIONS))
+ {
+ dev->calibration_data[i] = malloc (sizeof (P5_Calibration_Data));
+ if (dev->calibration_data[i] == NULL)
+ {
+ cleanup_calibration (dev);
+ free (fname);
+ fclose (fcalib);
+ DBG (DBG_error,
+ "restore_calibration: failed to allocate memory for calibration\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ size =
+ fread (dev->calibration_data[i], 1, sizeof (P5_Calibration_Data),
+ fcalib);
+ if (feof (fcalib))
+ {
+ free (dev->calibration_data[i]);
+ dev->calibration_data[i] = NULL;
+ }
+ else if (size != sizeof (P5_Calibration_Data))
+ {
+ cleanup_calibration (dev);
+ free (fname);
+ fclose (fcalib);
+ DBG (DBG_error, "restore_calibration: failed to read from file\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ DBG (DBG_trace,
+ "restore_calibration: read 1 calibration structure from file\n");
+ i++;
+ }
+
+ dev->calibrated = SANE_TRUE;
+ fclose (fcalib);
+ free (fname);
+
+ DBG (DBG_proc, "restore_calibration: end\n");
+ return status;
+}
+
+/** save calibration data
+ * save calibration data from memory to file
+ * @param dev device calibration to save
+ * @return SANE_STATUS_GOOD on success, otherwise error code
+ */
+static SANE_Status
+save_calibration (P5_Device * dev)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ char *fname = NULL;
+ FILE *fcalib = NULL;
+ int i;
+ size_t size;
+
+ DBG (DBG_proc, "save_calibration: start\n");
+ fname = calibration_file (dev->model->name);
+ fcalib = fopen (fname, "wb");
+ if (fcalib == NULL)
+ {
+ DBG (DBG_error, "save_calibration: failed to open %s!\n", fname);
+ free (fname);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ /* loop filling calibration data until EOF reached */
+ i = 0;
+ while (dev->calibration_data[i] != NULL && (i < 2 * MAX_RESOLUTIONS))
+ {
+ size =
+ fwrite (dev->calibration_data[i], sizeof (P5_Calibration_Data), 1,
+ fcalib);
+ if (size != sizeof (P5_Calibration_Data))
+ {
+ free (fname);
+ fclose (fcalib);
+ DBG (DBG_error, "save_calibration: failed to write to file\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ DBG (DBG_trace,
+ "save_calibration: wrote 1 calibration structure to file\n");
+ i++;
+ }
+
+ fclose (fcalib);
+ free (fname);
+
+ DBG (DBG_proc, "save_calibration: end\n");
+ return status;
+}
+
+/** calibrate scanner
+ * calibrates scanner by scanning a white sheet to get
+ * reference data. The black reference data is extracted from the lines
+ * that precede the physical document.
+ * Calibration is done at 300 color, then data is built for other modes
+ * and resolutions.
+ * @param dev device to calibrate
+ */
+static SANE_Status
+sheetfed_calibration (P5_Device * dev)
+{
+ uint8_t buffer[MAX_SENSOR_PIXELS * 3];
+ uint16_t white_data[MAX_SENSOR_PIXELS * 3];
+ uint16_t black_data[MAX_SENSOR_PIXELS * 3];
+ unsigned int i, j, k, dpi, pixels, read, black, white;
+ float coeff;
+ unsigned int red, green, blue;
+ int line;
+ SANE_Status status;
+ char title[40];
+
+ FILE *dbg = fopen ("debug.pnm", "wb");
+ fprintf (dbg, "P6\n%d %d\n255\n", MAX_SENSOR_PIXELS,
+ CALIBRATION_SKIP_LINES * 4);
+
+ DBG (DBG_proc, "sheetfed_calibration: start\n");
+
+ /* check calibration target has been loaded in ADF */
+ status = test_document (dev->fd);
+ if (status == SANE_STATUS_NO_DOCS)
+ {
+ DBG (DBG_error,
+ "sheetfed_calibration: no calibration target present!\n");
+ return SANE_STATUS_NO_DOCS;
+ }
+
+ /* clean up calibration data */
+ cleanup_calibration (dev);
+
+ /* a RGB scan to get reference data */
+ /* initialize calibration slot for the resolution */
+ i = 0;
+ dpi = dev->model->max_xdpi;
+ pixels = MAX_SENSOR_PIXELS;
+ dev->calibration_data[i] =
+ (P5_Calibration_Data *) malloc (sizeof (P5_Calibration_Data));
+ if (dev->calibration_data[i] == NULL)
+ {
+ cleanup_calibration (dev);
+ DBG (DBG_error,
+ "sheetfed_calibration: failed to allocate memory for calibration\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ dev->calibration_data[i]->dpi = dpi;
+
+ /* start scan */
+ status = start_scan (dev, MODE_COLOR, dpi, 0, pixels);
+ if (status != SANE_STATUS_GOOD)
+ {
+ cleanup_calibration (dev);
+ DBG (DBG_error,
+ "sheetfed_calibration: failed to start scan at %d dpi\n", dpi);
+ return SANE_STATUS_INVAL;
+ }
+
+ white = 0;
+ black = 0;
+ read = 0;
+ for (j = 0; j < pixels * 3; j++)
+ {
+ black_data[j] = 0;
+ white_data[j] = 0;
+ }
+
+ /* read lines and gather black and white ones until enough for sensor's
+ * native resolution */
+ do
+ {
+ status = test_document (dev->fd);
+ if (status == SANE_STATUS_NO_DOCS && (white < 10 || black < 10))
+ {
+ cleanup_calibration (dev);
+ DBG (DBG_error,
+ "sheetfed_calibration: calibration sheet too short!\n");
+ return SANE_STATUS_INVAL;
+ }
+ memset (buffer, 0x00, MAX_SENSOR_PIXELS * 3);
+ line =
+ read_line (dev, buffer, pixels * 3, 1, SANE_FALSE, SANE_FALSE,
+ MODE_COLOR, SANE_FALSE);
+ if (line == -1)
+ {
+ DBG (DBG_error, "sheetfed_calibration: failed to read data\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ /* if a data line has been read, add it to reference data */
+ if (line)
+ {
+ read++;
+ fwrite (buffer, pixels * 3, 1, dbg);
+ if (is_white_line (buffer, pixels, MODE_COLOR) && white < 256)
+ {
+ white++;
+ /* first calibration lines are skipped */
+ for (j = 0; j < pixels * 3 && read > CALIBRATION_SKIP_LINES;
+ j++)
+ {
+ white_data[j] += buffer[j];
+ }
+ }
+ if (is_black_line (buffer, pixels, MODE_COLOR) && black < 256)
+ {
+ black++;
+ for (j = 0; j < pixels * 3; j++)
+ {
+ black_data[j] += buffer[j];
+ }
+ }
+ }
+ }
+ while (test_document (dev->fd) != SANE_STATUS_NO_DOCS);
+ DBG (DBG_trace, "sheetfed_calibration: white lines=%d, black lines=%d\n",
+ white, black);
+
+ /* average pixels and store in per dpi calibration data */
+ for (j = 0; j < pixels * 3; j++)
+ {
+ dev->calibration_data[i]->white_data[j] = white_data[j] / white;
+ dev->calibration_data[i]->black_data[j] = black_data[j] / black;
+ }
+
+ /* we average red, green and blue offset on the full sensor */
+ red = 0;
+ green = 0;
+ blue = 0;
+ for (j = 0; j < pixels * 3; j += 3)
+ {
+ red += dev->calibration_data[i]->black_data[j];
+ green += dev->calibration_data[i]->black_data[j + 1];
+ blue += dev->calibration_data[i]->black_data[j + 2];
+ }
+ for (j = 0; j < pixels * 3; j += 3)
+ {
+ dev->calibration_data[i]->black_data[j] = red / pixels;
+ dev->calibration_data[i]->black_data[j + 1] = green / pixels;
+ dev->calibration_data[i]->black_data[j + 2] = blue / pixels;
+ }
+
+ /* trace calibration data for debug */
+ if (DBG_LEVEL > DBG_data)
+ {
+ sprintf (title, "calibration-white-%d.pnm",
+ dev->calibration_data[i]->dpi);
+ write_rgb_data (title, dev->calibration_data[i]->white_data, pixels, 1);
+ sprintf (title, "calibration-black-%d.pnm",
+ dev->calibration_data[i]->dpi);
+ write_rgb_data (title, dev->calibration_data[i]->black_data, pixels, 1);
+ }
+
+ /* loop on all remaining resolution and compute calibration data from it */
+ for (i = 1; i < MAX_RESOLUTIONS && dev->model->xdpi_values[i] > 0; i++)
+ {
+ dev->calibration_data[i] =
+ (P5_Calibration_Data *) malloc (sizeof (P5_Calibration_Data));
+ if (dev->calibration_data[i] == NULL)
+ {
+ cleanup_calibration (dev);
+ DBG (DBG_error,
+ "sheetfed_calibration: failed to allocate memory for calibration\n");
+ return SANE_STATUS_INVAL;
+ }
+ dev->calibration_data[i]->dpi = dev->model->xdpi_values[i];
+
+ coeff = ((float) dev->model->xdpi_values[i]) / (float) dpi;
+
+ /* generate data by decimation */
+ for (j = 0; j < pixels / coeff; j++)
+ {
+ k = j * coeff;
+ dev->calibration_data[i]->white_data[j] =
+ dev->calibration_data[0]->white_data[k];
+ dev->calibration_data[i]->white_data[j + 1] =
+ dev->calibration_data[0]->white_data[k + 1];
+ dev->calibration_data[i]->white_data[j + 2] =
+ dev->calibration_data[0]->white_data[k + 2];
+ dev->calibration_data[i]->black_data[j] =
+ dev->calibration_data[0]->black_data[k];
+ dev->calibration_data[i]->black_data[j + 1] =
+ dev->calibration_data[0]->black_data[k + 1];
+ dev->calibration_data[i]->black_data[j + 2] =
+ dev->calibration_data[0]->black_data[k + 2];
+ }
+ }
+
+ fclose (dbg);
+ dev->calibrated = SANE_TRUE;
+
+ /* eject calibration target */
+ eject (dev->fd);
+
+ DBG (DBG_proc, "sheetfed_calibration: end\n");
+ return SANE_STATUS_GOOD;
+}
+
+/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-12 09:17:21 +0000