summaryrefslogtreecommitdiff
path: root/backend/canon_pp-dev.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/canon_pp-dev.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/canon_pp-dev.c')
-rw-r--r--backend/canon_pp-dev.c1368
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;
+
+}