Initial import of sane-backends version 1.0.24-1.2

1 files changed, 1368 insertions, 0 deletions

diff --git a/backend/canon_pp-dev.c b/backend/canon_pp-dev.c
new file mode 100644
index 0000000..a357cf0
--- /dev/null
+++ b/backend/canon_pp-dev.c
@@ -0,0 +1,1368 @@
+/* sane - Scanner Access Now Easy.
+   Copyright (C) 2001-2002 Matthew C. Duggan and Simon Krix
+   This file is part of the SANE package.
+
+   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.
+
+   -----
+
+   This file is part of the canon_pp backend, supporting Canon CanoScan 
+   Parallel scanners and also distributed as part of the stand-alone driver.  
+
+   canon_pp-dev.c: $Revision$
+
+   Misc constants for Canon CanoScan Parallel scanners and high-level scan 
+   functions.
+
+   Simon Krix <kinsei@users.sourceforge.net>
+   */
+
+#ifdef _AIX
+#include <lalloca.h>
+#endif
+
+#ifndef NOSANE
+#include "../include/sane/config.h"
+#endif
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ieee1284.h>
+#include "canon_pp-io.h"
+#include "canon_pp-dev.h"
+
+#ifdef NOSANE
+
+/* No SANE, Things that only apply to stand-alone */
+#include <stdio.h>
+#include <stdarg.h>
+
+static void DBG(int level, const char *format, ...)
+{
+	va_list args;
+	va_start(args, format);
+	if (level < 50) vfprintf(stderr, format, args);
+	va_end(args);
+}
+#else
+
+/* Definitions which only apply to SANE compiles */
+#ifndef VERSION
+#define VERSION "$Revision$"
+#endif
+
+#define DEBUG_DECLARE_ONLY
+#include "canon_pp.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_backend.h"
+
+#endif
+
+struct scanner_hardware_desc {
+	char *name;
+	unsigned int natural_xresolution;
+	unsigned int natural_yresolution;
+	unsigned int scanbedlength;
+	unsigned int scanheadwidth;       /* 0 means provided by scanner */
+	unsigned int type;
+};
+
+static const struct scanner_hardware_desc 
+	/* The known scanner types */
+	hw_fb320p = { "FB320P", 2, 2, 3508, 2552, 0 },
+	hw_fb330p = { "FB330P", 2, 2, 3508,    0, 1 },
+	hw_fb620p = { "FB620P", 3, 3, 7016, 5104, 0 },
+	hw_fb630p = { "FB630P", 3, 3, 7016,    0, 1 },
+	hw_n640p  = { "N640P",  3, 3, 7016,    0, 1 },
+	hw_n340p  = { "N340P",  2, 2, 3508,    0, 1 },
+
+	/* A few generic scanner descriptions for aliens */
+	hw_alien600 = { "Unknown 600dpi", 3, 3, 7016, 0, 1 },
+	hw_alien300 = { "Unknown 300dpi", 2, 2, 3508, 0, 1 },
+	hw_alien = { "Unknown (600dpi?)", 3, 3, 7016, 0, 1 };
+
+/* ID table linking ID strings with hardware descriptions */
+struct scanner_id {
+	char *id;
+	const struct scanner_hardware_desc *hw;
+};
+static const struct scanner_id scanner_id_table[] = { 
+	{ "CANON   IX-03055C", &hw_fb320p },
+	{ "CANON   IX-06025C", &hw_fb620p },
+	{ "CANON   IX-03075E", &hw_fb330p },
+	{ "CANON   IX-06075E", &hw_fb630p },
+	{ "CANON   IX-03095G", &hw_n340p },
+	{ "CANON   IX-06115G", &hw_n640p },
+	{ NULL, NULL } };
+
+/*const int scanline_count = 6;*/
+static const char *header = "#CANONPP";
+static const int fileversion = 3;
+
+/* Internal functions */
+static unsigned long column_sum(image_segment *image, int x);
+static int adjust_output(image_segment *image, scan_parameters *scanp, 
+		scanner_parameters *scannerp);
+static int check8(unsigned char *p, int s);
+/* Converts from weird scanner format -> sequential data */
+static void convdata(unsigned char *srcbuffer, unsigned char *dstbuffer, 
+		int width, int mode);
+/* Sets up the scan command. This could use a better name
+   (and a rewrite). */
+static int scanner_setup_params(unsigned char *buf, scanner_parameters *sp, 
+		scan_parameters *scanp);
+
+/* file reading and writing helpers */
+static int safe_write(int fd, const char *p, unsigned long len);
+static int safe_read(int fd, char *p, unsigned long len);
+
+/* Command sending loop (waiting for ready status) */
+static int send_command(struct parport *port, unsigned char *buf, int bufsize, 
+		int delay, int timeout);
+
+/* Commands ================================================ */
+
+/* Command_1[] moved to canon_pp-io.c for neatness */
+
+
+/* Read device ID command */
+/* after this 0x26 (38) bytes are read */
+static unsigned char cmd_readid[] = { 0xfe, 0x20, 0, 0, 0, 0, 0, 0, 0x26, 0 };
+
+/* Reads 12 bytes of unknown information */
+static unsigned char cmd_readinfo[] = { 0xf3, 0x20, 0, 0, 0, 0, 0, 0, 0x0c, 0 };
+
+/* Scan init command: Always followed immediately by command cmd_scan */
+static unsigned char cmd_initscan[] = { 0xde, 0x20, 0, 0, 0, 0, 0, 0, 0x2e, 0 };
+
+/* Scan information block */
+static unsigned char cmd_scan[45] =
+{ 0x11, 0x2c, 0x11, 0x2c, 0x10, 0x4b, 0x10, 0x4b, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0x08, 0x08, 0x01, 0x01, 0x80, 0x01,
+	0x80, 0x80, 0x02, 0, 0, 0xc1, 0, 0x08, 0x01, 0x01,
+	0, 0, 0, 0, 0
+};
+
+/* Read 6 byte buffer status block */
+static unsigned char cmd_buf_status[] = { 0xf3, 0x21, 0, 0, 0, 0, 0, 0, 0x06, 0 };
+
+/* Request a block of image data */
+static unsigned char cmd_packet_req[] = {0xd4, 0x20, 0, 0, 0, 0, 0, 0x09, 0x64, 0};
+
+/* "*SCANEND" command - returns the scanner to transparent mode */
+static unsigned char cmd_scanend[] =
+{ 0x1b, 0x2a, 0x53, 0x43, 0x41, 0x4e, 0x45, 0x4e, 0x44, 0x0d };
+
+/* Reads BLACK calibration image */
+static unsigned char cmd_calblack[] ={0xf8, 0x20, 0, 0, 0, 0, 0, 0x4a, 0xc4, 0};
+
+/* Clear the existing gamma table and create a new one */
+static unsigned char cmd_cleargamma[] = {0xc5, 0x20, 0, 0, 0, 0, 0, 0, 0, 0};
+
+/* Read back the gamma table values */
+static unsigned char cmd_readgamma[] = {0xf6, 0x20, 0, 0, 0, 0, 0, 0, 0x20, 0};
+
+/* Reads COLOUR (R,G or B) calibration image */
+static unsigned char cmd_calcolour[]={0xf9, 0x20, 0, 0, 0, 0, 0, 0x4a, 0xc4, 0};
+
+/* Abort scan */
+static unsigned char cmd_abort[] = {0xef, 0x20, 0, 0, 0, 0, 0, 0, 0, 0};
+
+/* Upload the gamma table (followed by 32 byte write) */
+static unsigned char cmd_setgamma[] = {0xe6, 0x20, 0, 0, 0, 0, 0, 0, 0x20, 0};
+
+#if 0
+/* Something about RGB gamma/gain values? Not currently used by this code */
+static unsigned char command_14[32] =
+{ 0x2, 0x0, 0x3, 0x7f,
+	0x2, 0x0, 0x3, 0x7f,
+	0x2, 0x0, 0x3, 0x7f,
+	0, 0, 0, 0,
+	0x12, 0xd1, 0x14, 0x82,
+	0, 0, 0, 0,
+	0x0f, 0xff, 
+	0x0f, 0xff, 
+	0x0f, 0xff, 0, 0 };
+#endif
+
+
+/* Misc functions =================================== */
+
+/*
+ * safe_write(): a small wrapper which ensures all the data is written in calls
+ * to write(), since the POSIX call doesn't ensure it. 
+ */
+static int safe_write(int fd, const char *p, unsigned long len) {
+	int diff; 
+	unsigned long total = 0;
+
+	do {
+		diff = write(fd, p+total, len-total);
+		if (diff < 0) 
+		{
+			if (errno == EINTR) continue;
+			return -1;
+		}
+		total += diff;
+	} while (len > total);
+
+	return 0;
+
+}
+
+/* same dealie for read, except in the case of read the return of 0 bytes with 
+ * no INTR error indicates EOF */
+static int safe_read(int fd, char *p, unsigned long len) {
+	int diff;
+	unsigned long total = 0;
+
+	do {
+		diff = read(fd, p+total, len-total);
+		if (diff <= 0) 
+		{
+			if (errno == EINTR) continue;
+			if (diff == 0) return -2;
+			return -1;
+
+		}
+		total += diff;
+	} while (len > total);
+
+	return 0;
+
+}
+
+
+/* Scan-related functions =================================== */
+
+int sanei_canon_pp_init_scan(scanner_parameters *sp, scan_parameters *scanp)
+{
+	/* Command for: Initialise and begin the scan procedure */
+	unsigned char command_b[56];
+
+	/* Buffer for buffer info block */
+	unsigned char buffer_info_block[6];
+
+	/* The image size the scanner says we asked for 
+	   (based on the scanner's replies) */
+	int true_scanline_size, true_scanline_count;
+
+	/* The image size we expect to get (based on *scanp) */
+	int expected_scanline_size, expected_scanline_count;
+
+	/* Set up the default scan command packet */
+	memcpy(command_b, cmd_initscan, 10);
+	memcpy(command_b+10, cmd_scan, 45);
+
+	/* Load the proper settings into it */
+	scanner_setup_params(command_b+10, sp, scanp);
+
+	/* Add checksum byte */
+	command_b[55] = check8(command_b+10, 45);
+
+	if (send_command(sp->port, command_b, 56, 50000, 1000000))
+		return -1;
+		
+	/* Ask the scanner about the buffer */
+	if (send_command(sp->port, cmd_buf_status, 10, 50000, 1000000))
+		return -1;
+
+	/* Read buffer information block */
+	sanei_canon_pp_read(sp->port, 6, buffer_info_block);
+
+	if (check8(buffer_info_block, 6)) 
+		DBG(1, "init_scan: ** Warning: Checksum error reading buffer "
+				"info block.\n");
+
+	expected_scanline_count = scanp->height;
+
+	switch(scanp->mode)
+	{
+		case 0: /* greyscale; 10 bits per pixel */
+			expected_scanline_size = scanp->width * 1.25; break;
+		case 1: /* true-colour; 30 bits per pixel */
+			expected_scanline_size = scanp->width * 3.75; break;
+		default: 
+			DBG(1, "init_scan: Illegal mode %i requested in "
+					"init_scan().\n", scanp->mode);
+			DBG(1, "This is a bug. Please report it.\n");
+			return -1;
+	}
+
+	/* The scanner's idea of the length of each scanline in bytes */
+	true_scanline_size = (buffer_info_block[0]<<8) | buffer_info_block[1]; 
+	/* The scanner's idea of the number of scanlines in total */
+	true_scanline_count = (buffer_info_block[2]<<8) | buffer_info_block[3]; 
+
+	if ((expected_scanline_size != true_scanline_size) 
+			|| (expected_scanline_count != true_scanline_count))
+	{
+		DBG(10, "init_scan: Warning: Scanner is producing an image "
+				"of unexpected size:\n");
+		DBG(10, "expected: %i bytes wide, %i scanlines tall.\n", 
+				expected_scanline_size, 
+				expected_scanline_count);
+		DBG(10, "true: %i bytes wide, %i scanlines tall.\n", 
+				true_scanline_size, true_scanline_count);
+
+		if (scanp->mode == 0)
+			scanp->width = true_scanline_size / 1.25;
+		else
+			scanp->width = true_scanline_size / 3.75;				
+
+		scanp->height = true_scanline_count;
+	}
+	return 0;	
+}
+
+
+/* Wake the scanner, detect it, and fill sp with stuff */
+int sanei_canon_pp_initialise(scanner_parameters *sp, int mode)
+{
+	unsigned char scanner_info[12];
+	const struct scanner_id *cur_id;
+	const struct scanner_hardware_desc *hw;
+
+	/* Hopefully take the scanner out of transparent mode */
+	if (sanei_canon_pp_wake_scanner(sp->port, mode))
+	{
+		DBG(10, "initialise: could not wake scanner\n");
+		return 1;
+	}
+
+	/* This block of code does something unknown but necessary */
+	DBG(50, "initialise: >> scanner_init\n");
+	if (sanei_canon_pp_scanner_init(sp->port))
+	{
+		/* If we're using an unsupported ieee1284 mode here, this is 
+		 * where it will fail, so fall back to nibble. */
+		sanei_canon_pp_set_ieee1284_mode(M1284_NIBBLE);
+		if (sanei_canon_pp_scanner_init(sp->port))
+		{
+			DBG(10, "initialise: Could not init scanner.\n");
+			return 1;
+		}
+	}
+	DBG(50, "initialise: << scanner_init\n");
+
+	/* Read Device ID */
+	memset(sp->id_string, 0, sizeof sp->id_string);
+	if (send_command(sp->port, cmd_readid, 10, 10000, 100000))
+		return -1;
+	sanei_canon_pp_read(sp->port, 38, (unsigned char *)(sp->id_string));
+
+	/* Read partially unknown data */
+	if (send_command(sp->port, cmd_readinfo, 10, 10000, 100000))
+		return -1;
+	sanei_canon_pp_read(sp->port, 12, scanner_info);
+
+	if (check8(scanner_info, 12))
+	{
+		DBG(10, "initialise: Checksum error reading Info Block.\n");
+		return 2;
+	}
+
+	sp->scanheadwidth = (scanner_info[2] << 8) | scanner_info[3];
+
+	/* Set up various known values */
+	cur_id = scanner_id_table;
+	while (cur_id->id)
+	{
+		if (!strncmp(sp->id_string+8, cur_id->id, strlen(cur_id->id)))
+			break;
+		cur_id++;
+	}
+
+	if (cur_id->id)
+	{
+		hw = cur_id->hw;
+	}
+	else if (sp->scanheadwidth == 5104) 
+	{
+		/* Guess 600dpi scanner */
+		hw = &hw_alien600;
+	}
+	else if (sp->scanheadwidth == 2552) 
+	{
+		/* Guess 300dpi scanner */
+		hw = &hw_alien300;
+	}
+	else
+	{
+		/* Guinea Pigs :) */
+		hw = &hw_alien;
+	}
+
+	strcpy(sp->name, hw->name);
+	sp->natural_xresolution = hw->natural_xresolution;	
+	sp->natural_yresolution = hw->natural_yresolution;	
+	sp->scanbedlength = hw->scanbedlength;
+	if (hw->scanheadwidth)
+		sp->scanheadwidth = hw->scanheadwidth;
+	sp->type = hw->type;
+
+	return 0;	
+}
+
+/* Shut scanner down */
+int sanei_canon_pp_close_scanner(scanner_parameters *sp)
+{
+	/* Put scanner in transparent mode */	
+	sanei_canon_pp_sleep_scanner(sp->port);
+
+	/* Free memory (with purchase of memory of equal or greater value) */
+	if (sp->blackweight != NULL) 
+	{
+		free(sp->blackweight);
+		sp->blackweight = NULL;
+	}
+	if (sp->redweight != NULL)
+	{
+		free(sp->redweight);
+		sp->redweight = NULL;
+	}
+	if (sp->greenweight != NULL)
+	{
+		free(sp->greenweight);
+		sp->greenweight = NULL;
+	}
+	if (sp->blueweight != NULL)
+	{
+		free(sp->blueweight);
+		sp->blueweight = NULL;
+	}
+
+	return 0;	
+}
+
+/* Read the calibration information from file */
+int sanei_canon_pp_load_weights(const char *filename, scanner_parameters *sp)
+{
+	int fd;
+	int cal_data_size = sp->scanheadwidth * sizeof(unsigned long);
+	int cal_file_size;
+
+	char buffer[10];
+	int temp, ret;
+
+	/* Open file */
+	if ((fd = open(filename, O_RDONLY)) == -1)
+		return -1;
+
+	/* Read header and check it's right */
+	ret = safe_read(fd, buffer, strlen(header) + 1);
+	if ((ret < 0) || strcmp(buffer, header) != 0)
+	{
+		DBG(1,"Calibration file header is wrong, recalibrate please\n");
+		close(fd);
+		return -2;
+	}
+
+	/* Read and check file version (the calibrate file 
+	   format changes from time to time) */
+	ret = safe_read(fd, (char *)&temp, sizeof(int));
+
+	if ((ret < 0) || (temp != fileversion))
+	{
+		DBG(1,"Calibration file is wrong version, recalibrate please\n");
+		close(fd);
+		return -3;
+	}
+
+	/* Allocate memory for calibration values */
+	if (((sp->blueweight = malloc(cal_data_size)) == NULL)
+			|| ((sp->redweight = malloc(cal_data_size)) == NULL)
+			|| ((sp->greenweight = malloc(cal_data_size)) == NULL)
+			|| ((sp->blackweight = malloc(cal_data_size)) == NULL)) 
+		return -4;
+
+	/* Read width of calibration data */
+	ret = safe_read(fd, (char *)&cal_file_size, sizeof(cal_file_size));
+
+	if ((ret < 0) || (cal_file_size != sp->scanheadwidth))
+	{
+		DBG(1, "Calibration doesn't match scanner, recalibrate?\n");
+		close(fd);
+		return -5;
+	}
+
+	/* Read calibration data */
+	if (safe_read(fd, (char *)(sp->blackweight), cal_data_size) < 0)
+	{
+		DBG(1, "Error reading black calibration data, recalibrate?\n");
+		close(fd);
+		return -6;
+	}
+
+	if (safe_read(fd, (char *)sp->redweight, cal_data_size) < 0)
+	{
+		DBG(1, "Error reading red calibration data, recalibrate?\n");
+		close(fd);
+		return -7;
+	}
+
+	if (safe_read(fd, (char *)sp->greenweight, cal_data_size) < 0)
+	{
+		DBG(1, "Error reading green calibration data, recalibrate?\n");
+		close(fd);
+		return -8;
+	}
+
+	if (safe_read(fd, (char *)sp->blueweight, cal_data_size) < 0)
+	{
+		DBG(1, "Error reading blue calibration data, recalibrate?\n");
+		close(fd);
+		return -9;
+	}
+
+	/* Read white-balance/gamma data */
+	
+	if (safe_read(fd, (char *)&(sp->gamma), 32) < 0)
+	{
+		close(fd);
+		return -10;
+	}
+
+	close(fd);	
+
+	return 0;
+}
+
+/* Mode is 0 for greyscale source data or 1 for RGB */
+static void convert_to_rgb(image_segment *dest, unsigned char *src, 
+		int width, int scanlines, int mode)
+{
+	int curline;
+
+	const int colour_size = width * 1.25;
+	const int scanline_size = (mode == 0 ? colour_size : colour_size * 3);
+
+	for (curline = 0; curline < scanlines; curline++)
+	{
+
+		if (mode == 0) /* Grey */
+		{
+			convdata(src + (curline * scanline_size), 
+					dest->image_data + 
+					(curline * width * 2), width, 1);
+		}
+		else if (mode == 1) /* Truecolour */
+		{
+			/* Red */
+			convdata(src + (curline * scanline_size), 
+					dest->image_data + 
+					(curline * width *3*2) + 4, width, 2);
+			/* Green */
+			convdata(src + (curline * scanline_size) + colour_size, 
+					dest->image_data + 
+					(curline * width *3*2) + 2, width, 2);
+			/* Blue */
+			convdata(src + (curline * scanline_size) + 
+					(2 * colour_size), dest->image_data + 
+					(curline * width *3*2), width, 2);
+		}
+
+	} /* End of scanline loop */
+
+}
+
+int sanei_canon_pp_read_segment(image_segment **dest, scanner_parameters *sp, 
+		scan_parameters *scanp, int scanline_number, int do_adjust,
+		int scanlines_left)
+{
+	unsigned char *input_buffer = NULL;
+	image_segment *output_image = NULL;
+
+	unsigned char packet_header[4];
+	unsigned char packet_req_command[10];
+
+	int read_data_size;
+	int scanline_size;
+
+	if (scanp->mode == 1) /* RGB */
+		scanline_size = scanp->width * 3.75;
+	else /* Greyscale */
+		scanline_size = scanp->width * 1.25;
+
+	read_data_size = scanline_size * scanline_number;
+
+	/* Allocate output_image struct */
+	if ((output_image = malloc(sizeof(*output_image))) == NULL)
+	{
+		DBG(1, "read_segment: Error: Not enough memory for scanner "
+				"input buffer\n");
+		goto error_out;
+	}
+
+	/* Allocate memory for input buffer */
+	if ((input_buffer = malloc(scanline_size * scanline_number)) == NULL)
+	{
+		DBG(1, "read_segment: Error: Not enough memory for scanner "
+				"input buffer\n");
+		goto error_out;
+	}
+
+	output_image->width = scanp->width;
+	output_image->height = scanline_number;
+
+	/* Allocate memory for dest image segment */
+
+	output_image->image_data = 
+		malloc(output_image->width * output_image->height * 
+				(scanp->mode ? 3 : 1) * 2);
+
+	if (output_image->image_data == NULL)
+	{
+		DBG(1, "read_segment: Error: Not enough memory for "
+				"image data\n");
+		goto error_out;
+	}
+
+	/* Set up packet request command */
+	memcpy(packet_req_command, cmd_packet_req, 10);
+	packet_req_command[7] = ((read_data_size + 4) & 0xFF00) >> 8;
+	packet_req_command[8] = (read_data_size + 4) & 0xFF;
+
+	/* Send packet req. and wait for the scanner's READY signal */
+	if (send_command(sp->port, packet_req_command, 10, 9000, 2000000))
+	{
+		DBG(1, "read_segment: Error: didn't get response within 2s "
+				"of sending request");
+		goto error_out;
+	}
+
+	/* Read packet header */
+	if (sanei_canon_pp_read(sp->port, 4, packet_header))
+	{
+		DBG(1, "read_segment: Error reading packet header\n");
+		goto error_out;
+	}
+
+	if ((packet_header[2]<<8) + packet_header[3] != read_data_size)
+	{
+		DBG(1, "read_segment: Error: Expected data size: %i bytes.\n", 
+				read_data_size);
+		DBG(1, "read_segment: Expecting %i bytes times %i "
+				"scanlines.\n", scanline_size, scanline_number);
+		DBG(1, "read_segment: Actual data size: %i bytes.\n", 
+				(packet_header[2] << 8) + packet_header[3]);
+		goto error_out;
+	}
+
+	/* Read scanlines_this_packet scanlines into the input buf */
+	
+	if (sanei_canon_pp_read(sp->port, read_data_size, input_buffer))
+	{
+		DBG(1, "read_segment: Segment read incorrectly, and we don't "
+				"know how to recover.\n");
+		goto error_out;
+	}
+
+	/* This is the only place we can abort safely - 
+	 * between reading one segment and requesting the next one. */
+	if (sp->abort_now) goto error_out;
+
+	if (scanlines_left >= (scanline_number * 2)) 
+	{
+		DBG(100, "read_segment: Speculatively starting more scanning "
+				"(%d left)\n", scanlines_left);
+		sanei_canon_pp_write(sp->port, 10, packet_req_command);
+		/* Don't read status, it's unlikely to be ready *just* yet */
+	}
+
+	DBG(100, "read_segment: Convert to RGB\n");
+	/* Convert data */
+	convert_to_rgb(output_image, input_buffer, scanp->width, 
+			scanline_number, scanp->mode);
+
+	/* Adjust pixel readings according to calibration data */
+	if (do_adjust) {
+		DBG(100, "read_segment: Adjust output\n");
+		adjust_output(output_image, scanp, sp);
+	}
+
+	/* output */
+	*dest = output_image;
+	/* finished with this now */
+	free(input_buffer);
+	return 0;	
+
+	error_out:
+	if (output_image && output_image->image_data) 
+		free(output_image->image_data);
+	if (output_image) free(output_image);
+	if (input_buffer) free(input_buffer);
+	sp->abort_now = 0;
+	return -1;
+}
+
+/* 
+check8: Calculates the checksum-8 for s bytes pointed to by p.
+
+For messages from the scanner, this should normally end up returning
+0, since the last byte of most packets is the value that makes the 
+total up to 0 (or 256 if you're left-handed).
+Hence, usage: if (check8(buffer, size)) {DBG(10, "checksum error!\n");} 
+
+Can also be used to generate valid checksums for sending to the scanner.
+*/
+static int check8(unsigned char *p, int s) {
+	int total=0,i;
+	for(i=0;i<s;i++)
+		total-=(signed char)p[i];
+	total &=0xFF;
+	return total;
+}
+
+/* Converts from scanner format -> linear
+   width is in pixels, not bytes. */
+/* This function could use a rewrite */
+static void convdata(unsigned char *srcbuffer, unsigned char *dstbuffer, 
+		int width, int mode)
+/* This is a tricky (read: crap) function (read: hack) which is why I probably 
+   spent more time commenting it than programming it. The thing to remember 
+   here is that the scanner uses interpolated scanlines, so it's
+   RRRRRRRGGGGGGBBBBBB not RGBRGBRGBRGBRGB. So, the calling function just 
+   increments the destination pointer slightly to handle green, then a bit 
+   more for blue. If you don't understand, tough. */
+{
+	int count;
+	int i, j, k;
+
+	for (count = 0; count < width; count++)
+	{
+		/* The scanner stores data in a bizzare butchered 10-bit 
+		   format.  I'll try to explain it in 100 words or less:
+
+		   Scanlines are made up of groups of 4 pixels. Each group of 
+		   4 is stored inside 5 bytes. The first 4 bytes of the group 
+		   contain the lowest 8 bits of one pixel each (in the right 
+		   order). The 5th byte contains the most significant 2 bits 
+		   of each pixel in the same order. */
+
+		i = srcbuffer[count + (count >> 2)]; /* Low byte for pixel */
+		j = srcbuffer[(((count / 4) + 1) * 5) - 1]; /* "5th" byte */
+		j = j >> ((count % 4) * 2); /* Get upper 2 bits of intensity */
+		j = j & 0x03; /* Can't hurt */
+		/* And the final 10-bit pixel value is: */
+		k = (j << 8) | i; 
+
+		/* now we return this as a 16 bit value */
+		k = k << 6;
+
+		if (mode == 1) /* Scanner -> Grey */
+		{
+			dstbuffer[count * 2] = HIGH_BYTE(k);
+			dstbuffer[(count * 2) + 1] = LOW_BYTE(k);
+		}
+		else if (mode == 2) /* Scanner -> RGB */
+		{
+			dstbuffer[count * 3 * 2] = HIGH_BYTE(k);
+			dstbuffer[(count * 3 * 2) + 1] = LOW_BYTE(k);			
+		}
+
+	}
+}
+
+static int adjust_output(image_segment *image, scan_parameters *scanp, 
+		scanner_parameters *scannerp)
+/* Needing a good cleanup */
+{
+	/* light and dark points for the CCD sensor in question 
+	 * (stored in file as 0-1024, scaled to 0-65536) */
+	unsigned long hi, lo;
+	/* The result of our calculations */
+	unsigned long result;
+	unsigned long temp;
+	/* The CCD sensor which read the current pixel - this is a tricky value
+	   to get right. */
+	int ccd, scaled_xoff;
+	/* Loop variables */
+	unsigned int scanline, pixelnum, colour;
+	unsigned long int pixel_address;
+	unsigned int cols = scanp->mode ? 3 : 1;
+
+	for (scanline = 0; scanline < image->height; scanline++)
+	{
+		for (pixelnum = 0; pixelnum < image->width; pixelnum++)
+		{
+			/* Figure out CCD sensor number */
+			/* MAGIC FORMULA ALERT! */
+			ccd = (pixelnum << (scannerp->natural_xresolution - 
+						scanp->xresolution)) + (1 << 
+						(scannerp->natural_xresolution 
+						 - scanp->xresolution)) - 1;
+
+			scaled_xoff = scanp->xoffset << 
+				(scannerp->natural_xresolution - 
+				 scanp->xresolution);
+
+			ccd += scaled_xoff;	
+
+			for (colour = 0; colour < cols; colour++)
+			{
+				/* Address of pixel under scrutiny */
+				pixel_address = 
+					(scanline * image->width * cols * 2) +
+					(pixelnum * cols * 2) + (colour * 2);
+
+				/* Dark value is easy 
+				 * Range of lo is 0-18k */
+				lo = (scannerp->blackweight[ccd]) * 3;
+
+				/* Light value depends on the colour, 
+				 * and is an average in greyscale mode. */
+				if (scanp->mode == 1) /* RGB */
+				{
+					switch (colour)
+					{
+						case 0: hi = scannerp->redweight[ccd] * 3; 
+							break;
+						case 1: hi = scannerp->greenweight[ccd] * 3; 
+							break;
+						default: hi = scannerp->blueweight[ccd] * 3; 
+							 break;
+					}
+				}
+				else /* Grey - scanned using green */
+				{
+					hi = scannerp->greenweight[ccd] * 3; 
+				}
+
+				/* Check for bad calibration data as it 
+				   can cause a divide-by-0 error */
+				if (hi <= lo)
+				{
+					DBG(1, "adjust_output: Bad cal data!"
+							" hi: %ld lo: %ld\n"
+							"Recalibrate, that "
+							"should fix it.\n", 
+							hi, lo);
+					return -1;
+				}
+
+				/* Start with the pixel value in result */
+				result = MAKE_SHORT(*(image->image_data + 
+							pixel_address), 
+						*(image->image_data + 
+							pixel_address + 1));
+
+				result = result >> 6; /* Range now = 0-1023 */
+					/*
+				if (scanline == 10)
+					DBG(200, "adjust_output: Initial pixel"
+							" value: %ld\n", 
+							result);
+							*/
+				result *= 54;         /* Range now = 0-54k */
+
+				/* Clip to dark and light values */
+				if (result < lo) result = lo;
+				if (result > hi) result = hi;
+
+				/* result = (base-lo) * max_value / (hi-lo) */
+				temp = result - lo;
+				temp *= 65536;
+				temp /= (hi - lo);
+
+				/* Clip output  result has been clipped to lo,
+				 * and hi >= lo, so temp can't be < 0 */
+				if (temp > 65535)
+					temp = 65535;
+				/*
+				if (scanline == 10)
+				{
+					DBG(200, "adjust_output: %d: base = "
+							"%lu, result %lu (%lu "
+							"- %lu)\n", pixelnum, 
+							result, temp, lo, hi);
+				}			
+				*/
+				result = temp;
+
+				/* Store the value back where it came 
+				 * from (always bigendian) */
+				*(image->image_data + pixel_address)
+					= HIGH_BYTE(result);
+				*(image->image_data + pixel_address+1)
+					= LOW_BYTE(result);
+			}
+		}
+	}
+	/*DBG(100, "Finished adjusting output\n");*/
+	return 0;
+}
+
+/* Calibration run.  Aborting allowed at "safe" points where the scanner won't
+ * be left in a crap state. */
+int sanei_canon_pp_calibrate(scanner_parameters *sp, char *cal_file) 
+{
+	int count, readnum, colournum, scanlinenum;
+	int outfile;
+
+	int scanline_size;
+
+	int scanline_count = 6;
+	/* Don't change this unless you also want to change do_adjust */
+	const int calibration_reads = 3;
+
+	unsigned char command_buffer[10];
+
+	image_segment image;
+	unsigned char *databuf;
+
+	char colours[3][6] = {"Red", "Green", "Blue"};
+
+	/* Calibration data is monochromatic (greyscale format) */
+	scanline_size = sp->scanheadwidth * 1.25;
+
+	/* 620P has to be difficult here... */
+	if (!(sp->type) ) scanline_count = 8;
+
+	/* Probably shouldn't have to abort *just* yet, but may as well check */
+	if (sp->abort_now) return -1;
+
+	DBG(40, "Calibrating %ix%i pixels calibration image "
+			"(%i bytes each scan).\n", 
+			sp->scanheadwidth, scanline_count, 
+			scanline_size * scanline_count);
+
+	/* Allocate memory for calibration data */	
+	sp->blackweight = (unsigned long *)
+		calloc(sizeof(unsigned long), sp->scanheadwidth);
+	sp->redweight = (unsigned long *)
+		calloc(sizeof(unsigned long), sp->scanheadwidth);
+	sp->greenweight = (unsigned long *)
+		calloc(sizeof(unsigned long), sp->scanheadwidth);
+	sp->blueweight = (unsigned long *)
+		calloc(sizeof(unsigned long), sp->scanheadwidth);
+
+	/* The data buffer needs to hold a number of images (calibration_reads)
+	 * per colour, each sp->scanheadwidth x scanline_count */
+	databuf = malloc(scanline_size * scanline_count * calibration_reads*3);
+
+	/* And allocate space for converted image data in this image_segment */
+	image.image_data = malloc(scanline_count * sp->scanheadwidth * 2 * 
+			calibration_reads);
+	image.width = sp->scanheadwidth;
+	image.height = scanline_count * calibration_reads;
+
+	/* Sending the "dark calibration" command */
+	memcpy(command_buffer, cmd_calblack, 10);
+
+	/* Which includes the size of data we expect the scanner to return */
+	command_buffer[7] = ((scanline_size * scanline_count) & 0xff00) >> 8;
+	command_buffer[8] = (scanline_size * scanline_count) & 0xff;
+
+	DBG(40, "Step 1/3: Calibrating black level...\n");
+	for (readnum = 0; readnum < calibration_reads; readnum++)
+	{
+		DBG(40, "  * Black scan number %d/%d.\n", readnum + 1, 
+				calibration_reads);
+
+		if (sp->abort_now) return -1;
+
+		if (send_command(sp->port, command_buffer, 10, 100000, 5000000))
+		{
+			DBG(1, "Error reading black level!\n");
+			free (image.image_data);
+			free(databuf);
+			return -1;
+			
+		}
+
+		/* Black reference data */
+		sanei_canon_pp_read(sp->port, scanline_size * scanline_count,
+				databuf + 
+				(readnum * scanline_size * scanline_count));
+	}
+
+	/* Convert scanner format to a greyscale 16bpp image */
+	for (scanlinenum = 0; 
+			scanlinenum < scanline_count * calibration_reads; 
+			scanlinenum++)
+	{
+		convdata(databuf + (scanlinenum * scanline_size), 
+				image.image_data + 
+				(scanlinenum * sp->scanheadwidth*2), 
+				sp->scanheadwidth, 1);
+	}
+
+	/* Take column totals */
+	for (count = 0; count < sp->scanheadwidth; count++)
+	{
+		/* Value is normalised as if we took 6 scanlines, even if we 
+		 * didn't (620P I'm looking at you!) */
+		sp->blackweight[count] = (column_sum(&image, count) * 6) 
+			/ scanline_count >> 6;
+	}
+
+	/* 620P has to be difficult here... */
+	if (!(sp->type) )
+	{
+		scanline_count = 6;
+		image.height = scanline_count * calibration_reads;
+	}
+
+	DBG(40, "Step 2/3: Gamma tables...\n");
+	DBG(40, "  * Requesting creation of new of gamma tables...\n");
+	if (sp->abort_now) return -1;
+	if (send_command(sp->port, cmd_cleargamma, 10, 100000, 5000000))
+	{
+		DBG(1,"Error sending gamma command!\n");
+		free (image.image_data);
+		free(databuf);
+		return -1;
+	}
+
+	DBG(20, "  * Snoozing for 15 seconds while the scanner calibrates...");
+	usleep(15000000);
+	DBG(40, "done.\n");
+	
+	DBG(40, "  * Requesting gamma table values...");
+	if (send_command(sp->port, cmd_readgamma, 10, 100000, 10000000))
+	{
+		DBG(1,"Error sending gamma table request!\n");
+		free (image.image_data);
+		free(databuf);
+		return -1;
+	}
+	DBG(40, "done.\n");
+
+	DBG(40, "  * Reading white-balance/gamma data... ");
+	sanei_canon_pp_read(sp->port, 32, sp->gamma);
+	DBG(40, "done.\n");
+
+	if (sp->abort_now) return -1;
+
+	memcpy(command_buffer, cmd_calcolour, 10);
+
+	/* Set up returned data size */
+	command_buffer[7] = ((scanline_size * scanline_count) & 0xff00) >> 8;
+	command_buffer[8] = (scanline_size * scanline_count) & 0xff;
+
+	DBG(40, "Step 3/3: Calibrating sensors...\n");
+	/* Now for the RGB high-points */
+	for (colournum = 1; colournum < 4; colournum++)
+	{
+		/* Set the colour we want to read */
+		command_buffer[3] = colournum;
+		for (readnum = 0; readnum < 3; readnum++)
+		{
+			DBG(10, "  * %s sensors, scan number %d/%d.\n", 
+					colours[colournum-1], readnum + 1,
+					calibration_reads);
+
+			if (sp->abort_now) return -1;
+			if (send_command(sp->port, command_buffer, 10,
+						100000, 5000000))
+			{
+				DBG(1,"Error sending scan request!");
+				free (image.image_data);
+				free(databuf);
+				return -1;
+			}
+
+			sanei_canon_pp_read(sp->port, scanline_size * 
+					scanline_count, databuf + 
+					(readnum * scanline_size * 
+					 scanline_count));
+
+		}
+
+		/* Convert colour data from scanner format to RGB data */
+		for (scanlinenum = 0; scanlinenum < scanline_count * 
+				calibration_reads; scanlinenum++)
+		{
+			convdata(databuf + (scanlinenum * scanline_size), 
+					image.image_data + 
+					(scanlinenum * sp->scanheadwidth * 2), 
+					sp->scanheadwidth, 1);
+		}
+
+		/* Sum each column of the image and store the results in sp */
+		for (count = 0; count < sp->scanheadwidth; count++)
+		{
+			if (colournum == 1)
+				sp->redweight[count] = 
+					column_sum(&image, count) >> 6;	
+			else if (colournum == 2)
+				sp->greenweight[count] = 
+					column_sum(&image, count) >> 6;	
+			else
+				sp->blueweight[count] = 
+					column_sum(&image, count) >> 6;	
+		}
+
+	}
+
+	if (sp->abort_now) return -1;
+
+	/* cal_file == NUL indicates we want an in-memory scan only */
+	if (cal_file != NULL)
+	{
+		DBG(40, "Writing calibration to %s\n", cal_file);
+		outfile = open(cal_file, O_WRONLY | O_TRUNC | O_CREAT, 0600);
+		if (outfile < 0)
+		{
+			DBG(10, "Error opening cal file for writing\n");
+		}
+
+		/* Header */
+		if (safe_write(outfile, header, strlen(header) + 1) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+		if (safe_write(outfile, (const char *)&fileversion, sizeof(int)) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+
+		/* Data */
+		if (safe_write(outfile, (char *)&(sp->scanheadwidth), 
+					sizeof(sp->scanheadwidth)) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+		if (safe_write(outfile, (char *)(sp->blackweight), 
+					sp->scanheadwidth * sizeof(long)) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+		if (safe_write(outfile, (char *)(sp->redweight), 
+					sp->scanheadwidth * sizeof(long)) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+		if (safe_write(outfile, (char *)(sp->greenweight), 
+					sp->scanheadwidth * sizeof(long)) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+		if (safe_write(outfile, (char *)(sp->blueweight), 
+					sp->scanheadwidth * sizeof(long)) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+		if (safe_write(outfile, (char *)(sp->gamma), 32) < 0)
+			DBG(10, "Write error on calibration file %s", cal_file);
+
+		close(outfile);
+	}
+
+	free(databuf);
+	free(image.image_data);
+
+	return 0;
+}
+
+static unsigned long column_sum(image_segment *image, int x)
+/* This gives us a number from 0-n*65535 where n is the height of the image */
+{
+	unsigned int row, p;
+	unsigned long total = 0;
+
+	p = x;
+	for (row = 0; row < image->height; row++)
+	{
+		total+= MAKE_SHORT(image->image_data[2*p],
+				image->image_data[2*p+1]);
+		p += image->width;
+	}
+	return total;
+}
+
+
+static int scanner_setup_params(unsigned char *buf, scanner_parameters *sp, 
+		scan_parameters *scanp)
+{
+	int scaled_width, scaled_height;
+	int scaled_xoff, scaled_yoff;
+
+	/* Natural resolution (I think) */
+	if (sp->scanheadwidth == 2552)
+	{
+		buf[0] = 0x11; /* 300 | 0x1000 */
+		buf[1] = 0x2c;
+		buf[2] = 0x11;
+		buf[3] = 0x2c;
+	} else {
+		buf[0] = 0x12; /* 600 | 0x1000*/
+		buf[1] = 0x58;
+		buf[2] = 0x12;
+		buf[3] = 0x58;
+	}
+
+	scaled_width = scanp->width << 
+		(sp->natural_xresolution - scanp->xresolution);
+	/* YO! This needs fixing if we ever use yresolution! */
+	scaled_height = scanp->height << 
+		(sp->natural_xresolution - scanp->xresolution);
+	scaled_xoff = scanp->xoffset << 
+		(sp->natural_xresolution - scanp->xresolution);
+	scaled_yoff = scanp->yoffset << 
+		(sp->natural_xresolution - scanp->xresolution);
+
+	/* Input resolution */
+	buf[4] = (((75 << scanp->xresolution) & 0xff00) >> 8) | 0x10;
+	buf[5] = (75 << scanp->xresolution) & 0xff;
+	/* Interpolated resolution */
+	buf[6] = (((75 << scanp->xresolution) & 0xff00) >> 8) | 0x10;;
+	buf[7] = (75 << scanp->xresolution) & 0xff;
+
+	/* X offset */
+	buf[8] = (scaled_xoff & 0xff000000) >> 24;
+	buf[9] = (scaled_xoff & 0xff0000) >> 16;
+	buf[10] = (scaled_xoff & 0xff00) >> 8;
+	buf[11] = scaled_xoff & 0xff;
+
+	/* Y offset */
+	buf[12] = (scaled_yoff & 0xff000000) >> 24;
+	buf[13] = (scaled_yoff & 0xff0000) >> 16;
+	buf[14] = (scaled_yoff & 0xff00) >> 8;
+	buf[15] = scaled_yoff & 0xff;
+
+	/* Width of image to be scanned */	
+	buf[16] = (scaled_width & 0xff000000) >> 24;
+	buf[17] = (scaled_width & 0xff0000) >> 16;
+	buf[18] = (scaled_width & 0xff00) >> 8;
+	buf[19] = scaled_width & 0xff;
+
+	/* Height of image to be scanned */
+	buf[20] = (scaled_height & 0xff000000) >> 24;
+	buf[21] = (scaled_height & 0xff0000) >> 16;
+	buf[22] = (scaled_height & 0xff00) >> 8;
+	buf[23] = scaled_height & 0xff;
+
+
+	/* These appear to be the only two colour mode possibilities. 
+	   Pure black-and-white mode probably just uses greyscale and
+	   then gets its contrast adjusted by the driver. I forget. */
+	if (scanp->mode == 1) /* Truecolour */
+		buf[24] = 0x08;
+	else /* Greyscale */
+		buf[24] = 0x04;
+
+	return 0;
+}
+
+int sanei_canon_pp_abort_scan(scanner_parameters *sp)
+{
+	/* The abort command (hopefully) */
+	sanei_canon_pp_write(sp->port, 10, cmd_abort);
+	sanei_canon_pp_check_status(sp->port);
+	return 0;
+}
+
+/* adjust_gamma: Upload a gamma profile to the scanner */
+int sanei_canon_pp_adjust_gamma(scanner_parameters *sp)
+{
+	sp->gamma[31] = check8(sp->gamma, 31);
+	if (sanei_canon_pp_write(sp->port, 10, cmd_setgamma))
+		return -1;
+	if (sanei_canon_pp_write(sp->port, 32, sp->gamma))
+		return -1;
+
+	return 0;
+}
+
+int sanei_canon_pp_sleep_scanner(struct parport *port)
+{
+	/* *SCANEND Command - puts scanner to sleep */
+	sanei_canon_pp_write(port, 10, cmd_scanend);
+	sanei_canon_pp_check_status(port);
+
+  ieee1284_terminate(port);
+
+	return 0;
+	/* FIXME: I murdered Simon's code here */
+	/* expect(port, "Enter Transparent Mode", 0x1f, 0x1f, 1000000); */
+}
+
+int sanei_canon_pp_detect(struct parport *port, int mode)
+{
+	/*int caps;*/
+	/* This code needs to detect whether or not a scanner is present on 
+	 * the port, quickly and reliably. Fast version of 
+	 * sanei_canon_pp_initialise() 
+	 *
+	 * If this detect returns true, a more comprehensive check will 
+	 * be conducted
+	 * Return values: 
+	 * 0 = scanner present
+	 * anything else = scanner not present 
+	 * PRE: port is open/unclaimed
+	 * POST: port is closed/unclaimed
+	 */
+
+	/* port is already open, just need to claim it */
+
+	if (ieee1284_claim(port) != E1284_OK)
+	{
+		DBG(0,"detect: Unable to claim port\n");
+		return 2;
+	}
+	if (sanei_canon_pp_wake_scanner(port, mode))
+	{
+		DBG(10, "detect: could not wake scanner\n");
+		ieee1284_release(port);
+		return 3;
+	}
+
+	/* Goodo, sleep (snaps fingers) */
+	sanei_canon_pp_sleep_scanner(port);
+
+	ieee1284_release(port);
+	/* ieee1284_close(port); */
+
+	return 0;
+}
+
+static int send_command(struct parport *port, unsigned char *buf, int bufsize, 
+		int delay, int timeout)
+/* Sends a command until the scanner says it is ready. 
+ * sleeps for delay microsecs between reads
+ * returns -1 on error, -2 on timeout */
+{
+	int retries = 0;
+
+	do
+	{
+		/* Send command */
+		if (sanei_canon_pp_write(port, bufsize, buf))
+			return -1;
+
+		/* sleep a bit */
+		usleep(delay);
+	} while (sanei_canon_pp_check_status(port) && 
+			retries++ < (timeout/delay));
+
+	if (retries >= (timeout/delay)) return -2;
+	return 0;
+
+}