summaryrefslogtreecommitdiff
path: root/backend/epson2-ops.c
diff options
context:
space:
mode:
Diffstat (limited to 'backend/epson2-ops.c')
-rw-r--r--backend/epson2-ops.c2211
1 files changed, 2211 insertions, 0 deletions
diff --git a/backend/epson2-ops.c b/backend/epson2-ops.c
new file mode 100644
index 0000000..df6958c
--- /dev/null
+++ b/backend/epson2-ops.c
@@ -0,0 +1,2211 @@
+/*
+ * epson2.c - SANE library for Epson scanners.
+ *
+ * Based on Kazuhiro Sasayama previous
+ * Work on epson.[ch] file from the SANE package.
+ * Please see those files for additional copyrights.
+ *
+ * Copyright (C) 2006-09 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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, version 2.
+ */
+
+#define DEBUG_DECLARE_ONLY
+
+#include "sane/config.h"
+
+#include <unistd.h> /* sleep */
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+#include "byteorder.h"
+
+#include "epson2.h"
+#include "epson2-ops.h"
+
+#include "epson2-io.h"
+#include "epson2-commands.h"
+
+/*
+ * request identity
+ * | request identity2
+ * | | request status
+ * | | | request condition
+ * | | | | set color mode
+ * | | | | | start scanning
+ * | | | | | | set data format
+ * | | | | | | | set resolution
+ * | | | | | | | | set zoom
+ * | | | | | | | | | set scan area
+ * | | | | | | | | | | set brightness
+ * | | | | | | | | | | | set gamma
+ * | | | | | | | | | | | | set halftoning
+ * | | | | | | | | | | | | | set color correction
+ * | | | | | | | | | | | | | | initialize scanner
+ * | | | | | | | | | | | | | | | set speed
+ * | | | | | | | | | | | | | | | | set lcount
+ * | | | | | | | | | | | | | | | | | mirror image
+ * | | | | | | | | | | | | | | | | | | set gamma table
+ * | | | | | | | | | | | | | | | | | | | set outline emphasis
+ * | | | | | | | | | | | | | | | | | | | | set dither
+ * | | | | | | | | | | | | | | | | | | | | | set color correction coefficients
+ * | | | | | | | | | | | | | | | | | | | | | | request extension status
+ * | | | | | | | | | | | | | | | | | | | | | | | control an extension
+ * | | | | | | | | | | | | | | | | | | | | | | | | forward feed / eject
+ * | | | | | | | | | | | | | | | | | | | | | | | | | feed
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | request push button status
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | control auto area segmentation
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | set film type
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | set exposure time
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | set bay
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | set threshold
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | set focus position
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | request focus position
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | request extended identity
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | request scanner status
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
+ */
+
+static struct EpsonCmd epson_cmd[] = {
+ {"A1",'I', 0 ,'F','S', 0 ,'G', 0 ,'R', 0 ,'A', 0 ,{ 0, 0, 0}, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"A2",'I', 0 ,'F','S', 0 ,'G','D','R','H','A','L',{-3, 3, 0},'Z','B', 0 ,'@', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B1",'I', 0 ,'F','S','C','G','D','R', 0 ,'A', 0 ,{ 0, 0, 0}, 0 ,'B', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B2",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-3, 3, 0},'Z','B', 0 ,'@', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B3",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-3, 3, 0},'Z','B','M','@', 0 , 0 , 0 , 0 , 0 , 0 ,'m','f','e', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B4",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-3, 3, 0},'Z','B','M','@','g','d', 0 ,'z','Q','b','m','f','e', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B5",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-3, 3, 0},'Z','B','M','@','g','d','K','z','Q','b','m','f','e', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B6",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-3, 3, 0},'Z','B','M','@','g','d','K','z','Q','b','m','f','e', 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 },
+ {"B7",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-4, 3, 0},'Z','B','M','@','g','d','K','z','Q','b','m','f','e','\f', 0 ,'!','s','N', 0 , 0 ,'t', 0 , 0 ,'I','F'},
+ {"B8",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-4, 3, 0},'Z','B','M','@','g','d','K','z','Q','b','m','f','e','\f', 0x19,'!','s','N', 0 , 0 ,'t','p','q','I','F'},
+/* XXX 'f' probably not supported on F5 */
+ {"F5",'I', 0 ,'F','S','C','G','D','R','H','A','L',{-3, 3, 0},'Z', 0 ,'M','@','g','d','K','z','Q', 0 ,'m','f','e','\f', 0 , 0 , 0 ,'N','T','P', 0 , 0 , 0 , 0 , 0 },
+ {"D1",'I','i','F', 0 ,'C','G','D','R', 0 ,'A', 0 ,{ 0, 0, 0},'Z', 0 , 0 ,'@','g','d', 0 ,'z', 0 , 0 , 0 ,'f', 0 , 0 , 0 ,'!', 0 , 0 , 0 , 0 ,'t', 0 , 0 , 0 , 0 },
+ {"D2",'I','i','F', 0 ,'C','G','D','R', 0 ,'A', 0 ,{ 0, 0, 0},'Z', 0 , 0 ,'@','g','d', 0 ,'z', 0 , 0 , 0 ,'f','e', 0 , 0 ,'!', 0 ,'N', 0 , 0 ,'t', 0 , 0 , 0 , 0 },
+ {"D7",'I','i','F', 0 ,'C','G','D','R', 0 ,'A', 0 ,{ 0, 0, 0},'Z', 0 , 0 ,'@','g','d', 0 ,'z', 0 , 0 , 0 ,'f','e','\f', 0 ,'!', 0 ,'N', 0 , 0 ,'t', 0 , 0 , 0 , 0 },
+ {"D8",'I','i','F', 0 ,'C','G','D','R', 0 ,'A', 0 ,{ 0, 0, 0},'Z', 0 , 0 ,'@','g','d', 0 ,'z', 0 , 0 , 0 ,'f','e','\f', 0 ,'!', 0 ,'N', 0 , 0 ,'t', 0 , 0 , 0 , 0 },
+};
+
+
+
+extern struct mode_param mode_params[];
+
+/* Define the different scan sources */
+
+#define FBF_STR SANE_I18N("Flatbed")
+#define TPU_STR SANE_I18N("Transparency Unit")
+#define TP2_STR SANE_I18N("TPU8x10")
+#define ADF_STR SANE_I18N("Automatic Document Feeder")
+
+/*
+ * source list need one dummy entry (save device settings is crashing).
+ * NOTE: no const - this list gets created while exploring the capabilities
+ * of the scanner.
+ */
+
+extern SANE_String_Const source_list[];
+
+static int film_params[] = { 0, 1, 2, 3 };
+
+extern const int halftone_params[];
+
+static const int dropout_params[] = {
+ 0x00, /* none */
+ 0x10, /* red */
+ 0x20, /* green */
+ 0x30 /* blue */
+};
+
+/*
+ * Color correction:
+ * One array for the actual parameters that get sent to the scanner (color_params[]),
+ * one array for the strings that get displayed in the user interface (correction_list[])
+ * and one array to mark the user defined color correction (correction_userdefined[]).
+ */
+static const int correction_params[] = {
+ 0x00, /* None */
+ 0x01, /* Auto */
+ 0x01, /* User defined */
+};
+
+void
+e2_dev_init(Epson_Device *dev, const char *devname, int conntype)
+{
+ DBG(5, "%s\n", __func__);
+
+ dev->name = NULL;
+ dev->model = NULL;
+ dev->connection = conntype;
+
+ dev->model_id = 0;
+
+ dev->sane.name = devname;
+ dev->sane.model = NULL;
+
+ dev->sane.type = "flatbed scanner";
+ dev->sane.vendor = "Epson";
+
+ dev->optical_res = 0; /* just to have it initialized */
+ dev->color_shuffle = SANE_FALSE;
+ dev->extension = SANE_FALSE;
+ dev->use_extension = SANE_FALSE;
+
+ dev->need_color_reorder = SANE_FALSE;
+ dev->need_double_vertical = SANE_FALSE;
+
+ dev->cct_profile = &epson_cct_profiles[0]; /* default profile */
+
+ dev->cmd = &epson_cmd[EPSON_LEVEL_DEFAULT];
+
+ /* Change default level when using a network connection */
+ if (dev->connection == SANE_EPSON_NET)
+ dev->cmd = &epson_cmd[EPSON_LEVEL_B7];
+
+ dev->last_res = 0;
+ dev->last_res_preview = 0; /* set resolution to safe values */
+
+ dev->res_list_size = 0;
+ dev->res_list = NULL;
+}
+
+SANE_Status
+e2_dev_post_init(struct Epson_Device *dev)
+{
+ int i;
+
+ DBG(5, "%s\n", __func__);
+
+ /* find cct model id */
+ for (i = 0; epson_cct_models[i].name != NULL; i++) {
+ if (strcmp(epson_cct_models[i].name, dev->model) == 0) {
+ dev->model_id = epson_cct_models[i].id;
+ break;
+ }
+ }
+
+ /* find cct profile */
+ for (i = 0; epson_cct_profiles[i].model != 0xFF; i++) {
+ if (epson_cct_profiles[i].model == dev->model_id) {
+ dev->cct_profile = &epson_cct_profiles[i];
+ break;
+ }
+ }
+
+ DBG(1, "CCT model id is 0x%02x, profile offset %d\n", dev->model_id, i);
+
+ /* If we have been unable to obtain supported resolutions
+ * due to the fact we are on the network transport,
+ * add some convenient ones
+ */
+
+ if (dev->res_list_size == 0) {
+
+ int val = (dev->dpi_range.min < 150) ? 150 : dev->dpi_range.min;
+
+ DBG(1, "cannot obtain resolution list, faking (%d-%d)\n",
+ dev->dpi_range.min, dev->dpi_range.max);
+
+ if (dev->dpi_range.min <= 25)
+ e2_add_resolution(dev, 25);
+
+ if (dev->dpi_range.min <= 50)
+ e2_add_resolution(dev, 50);
+
+ if (dev->dpi_range.min <= 75)
+ e2_add_resolution(dev, 75);
+
+ if (dev->dpi_range.min <= 100)
+ e2_add_resolution(dev, 100);
+
+ while (val <= dev->dpi_range.max) {
+ e2_add_resolution(dev, val);
+ val *= 2;
+ }
+ }
+
+ /* try to expand the resolution list where appropriate */
+
+ int last = dev->res_list[dev->res_list_size - 1];
+
+ DBG(1, "highest available resolution: %d\n", last);
+
+ if (dev->optical_res > last) {
+ DBG(1, "adding optical resolution (%d)\n", dev->optical_res);
+ e2_add_resolution(dev, dev->optical_res);
+ }
+
+ if (dev->dpi_range.max > last && dev->dpi_range.max != dev->optical_res) {
+
+ int val = last + last;
+
+ DBG(1, "integrating resolution list (%d-%d)\n",
+ val, dev->dpi_range.max);
+
+ while (val <= dev->dpi_range.max) {
+ e2_add_resolution(dev, val);
+ val += last;
+ }
+ }
+
+
+ /*
+ * Copy the resolution list to the resolution_list array so that the frontend can
+ * display the correct values
+ */
+
+ dev->resolution_list =
+ malloc((dev->res_list_size + 1) * sizeof(SANE_Word));
+
+ if (dev->resolution_list == NULL)
+ return SANE_STATUS_NO_MEM;
+
+
+ *(dev->resolution_list) = dev->res_list_size;
+
+ memcpy(&(dev->resolution_list[1]), dev->res_list,
+ dev->res_list_size * sizeof(SANE_Word));
+
+
+ /* establish defaults */
+ dev->need_reset_on_source_change = SANE_FALSE;
+
+ if (e2_dev_model(dev, "ES-9000H") || e2_dev_model(dev, "GT-30000")) {
+ dev->cmd->set_focus_position = 0;
+ dev->cmd->feed = 0x19;
+ }
+
+ if (e2_dev_model(dev, "GT-8200") || e2_dev_model(dev, "Perfection1650")
+ || e2_dev_model(dev, "Perfection1640") || e2_dev_model(dev, "GT-8700")) {
+ dev->cmd->feed = 0;
+ dev->cmd->set_focus_position = 0;
+ dev->need_reset_on_source_change = SANE_TRUE;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+SANE_Bool
+e2_dev_model(Epson_Device *dev, const char *model)
+{
+ if (dev->model == NULL)
+ return SANE_FALSE;
+
+ if (strncmp(dev->model, model, strlen(model)) == 0)
+ return SANE_TRUE;
+
+ return SANE_FALSE;
+}
+
+void
+e2_set_cmd_level(SANE_Handle handle, unsigned char *level)
+{
+ Epson_Scanner *s = (Epson_Scanner *) handle;
+ Epson_Device *dev = s->hw;
+
+ int n;
+
+ DBG(1, "%s: %c%c\n", __func__, level[0], level[1]);
+
+ /* set command type and level */
+ for (n = 0; n < NELEMS(epson_cmd); n++) {
+ char type_level[3];
+ sprintf(type_level, "%c%c", level[0], level[1]);
+ if (!strncmp(type_level, epson_cmd[n].level, 2))
+ break;
+ }
+
+ if (n < NELEMS(epson_cmd)) {
+ dev->cmd = &epson_cmd[n];
+ } else {
+ dev->cmd = &epson_cmd[EPSON_LEVEL_DEFAULT];
+ DBG(1, " unknown type %c or level %c, using %s\n",
+ level[0], level[1], dev->cmd->level);
+ }
+
+ s->hw->level = dev->cmd->level[1] - '0';
+}
+
+SANE_Status
+e2_set_model(Epson_Scanner * s, unsigned char *model, size_t len)
+{
+ unsigned char *buf;
+ unsigned char *p;
+ struct Epson_Device *dev = s->hw;
+
+ buf = malloc(len + 1);
+ if (buf == NULL)
+ return SANE_STATUS_NO_MEM;
+
+ memcpy(buf, model, len);
+ buf[len] = '\0';
+
+ p = &buf[len - 1];
+
+ while (*p == ' ') {
+ *p = '\0';
+ p--;
+ }
+
+ if (dev->model)
+ free(dev->model);
+
+ dev->model = strndup((const char *) buf, len);
+ dev->sane.model = dev->model;
+
+ DBG(10, "%s: model is '%s'\n", __func__, dev->model);
+
+ free(buf);
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+e2_add_resolution(Epson_Device *dev, int r)
+{
+ dev->res_list_size++;
+ dev->res_list = (SANE_Int *) realloc(dev->res_list,
+ dev->res_list_size *
+ sizeof(SANE_Word));
+
+ DBG(10, "%s: add (dpi): %d\n", __func__, r);
+
+ if (dev->res_list == NULL)
+ return SANE_STATUS_NO_MEM;
+
+ dev->res_list[dev->res_list_size - 1] = (SANE_Int) r;
+
+ return SANE_STATUS_GOOD;
+}
+
+void
+e2_set_fbf_area(Epson_Scanner * s, int x, int y, int unit)
+{
+ struct Epson_Device *dev = s->hw;
+
+ if (x == 0 || y == 0)
+ return;
+
+ dev->fbf_x_range.min = 0;
+ dev->fbf_x_range.max = SANE_FIX(x * MM_PER_INCH / unit);
+ dev->fbf_x_range.quant = 0;
+
+ dev->fbf_y_range.min = 0;
+ dev->fbf_y_range.max = SANE_FIX(y * MM_PER_INCH / unit);
+ dev->fbf_y_range.quant = 0;
+
+ DBG(5, "%s: %f,%f %f,%f %d [mm]\n",
+ __func__,
+ SANE_UNFIX(dev->fbf_x_range.min),
+ SANE_UNFIX(dev->fbf_y_range.min),
+ SANE_UNFIX(dev->fbf_x_range.max),
+ SANE_UNFIX(dev->fbf_y_range.max), unit);
+}
+
+void
+e2_set_adf_area(struct Epson_Scanner *s, int x, int y, int unit)
+{
+ struct Epson_Device *dev = s->hw;
+
+ dev->adf_x_range.min = 0;
+ dev->adf_x_range.max = SANE_FIX(x * MM_PER_INCH / unit);
+ dev->adf_x_range.quant = 0;
+
+ dev->adf_y_range.min = 0;
+ dev->adf_y_range.max = SANE_FIX(y * MM_PER_INCH / unit);
+ dev->adf_y_range.quant = 0;
+
+ DBG(5, "%s: %f,%f %f,%f %d [mm]\n",
+ __func__,
+ SANE_UNFIX(dev->adf_x_range.min),
+ SANE_UNFIX(dev->adf_y_range.min),
+ SANE_UNFIX(dev->adf_x_range.max),
+ SANE_UNFIX(dev->adf_y_range.max), unit);
+}
+
+void
+e2_set_tpu_area(struct Epson_Scanner *s, int x, int y, int unit)
+{
+ struct Epson_Device *dev = s->hw;
+
+ dev->tpu_x_range.min = 0;
+ dev->tpu_x_range.max = SANE_FIX(x * MM_PER_INCH / unit);
+ dev->tpu_x_range.quant = 0;
+
+ dev->tpu_y_range.min = 0;
+ dev->tpu_y_range.max = SANE_FIX(y * MM_PER_INCH / unit);
+ dev->tpu_y_range.quant = 0;
+
+ DBG(5, "%s: %f,%f %f,%f %d [mm]\n",
+ __func__,
+ SANE_UNFIX(dev->tpu_x_range.min),
+ SANE_UNFIX(dev->tpu_y_range.min),
+ SANE_UNFIX(dev->tpu_x_range.max),
+ SANE_UNFIX(dev->tpu_y_range.max), unit);
+}
+
+void
+e2_set_tpu2_area(struct Epson_Scanner *s, int x, int y, int unit)
+{
+ struct Epson_Device *dev = s->hw;
+
+ dev->tpu2_x_range.min = 0;
+ dev->tpu2_x_range.max = SANE_FIX(x * MM_PER_INCH / unit);
+ dev->tpu2_x_range.quant = 0;
+
+ dev->tpu2_y_range.min = 0;
+ dev->tpu2_y_range.max = SANE_FIX(y * MM_PER_INCH / unit);
+ dev->tpu2_y_range.quant = 0;
+
+ DBG(5, "%s: %f,%f %f,%f %d [mm]\n",
+ __func__,
+ SANE_UNFIX(dev->tpu2_x_range.min),
+ SANE_UNFIX(dev->tpu2_y_range.min),
+ SANE_UNFIX(dev->tpu2_x_range.max),
+ SANE_UNFIX(dev->tpu2_y_range.max), unit);
+}
+
+void
+e2_add_depth(Epson_Device * dev, SANE_Word depth)
+{
+ if (depth > dev->maxDepth)
+ dev->maxDepth = depth;
+
+ dev->depth_list[0]++;
+ dev->depth_list[dev->depth_list[0]] = depth;
+}
+
+/* A little helper function to correct the extended status reply
+ * gotten from scanners with known buggy firmware.
+ */
+static void
+fix_up_extended_status_reply(Epson_Scanner * s, unsigned char *buf)
+{
+ if (e2_model(s, "ES-9000H") || e2_model(s, "GT-30000")) {
+ DBG(1, "fixing up buggy ADF max scan dimensions.\n");
+ buf[2] = 0xB0;
+ buf[3] = 0x6D;
+ buf[4] = 0x60;
+ buf[5] = 0x9F;
+ }
+}
+
+
+SANE_Status
+e2_discover_capabilities(Epson_Scanner *s)
+{
+ SANE_Status status;
+
+ unsigned char scanner_status;
+ Epson_Device *dev = s->hw;
+
+ SANE_String_Const *source_list_add = source_list;
+
+ DBG(5, "%s\n", __func__);
+
+ /* always add flatbed */
+ *source_list_add++ = FBF_STR;
+
+ /* ESC I, request identity
+ * this must be the first command on the FilmScan 200
+ */
+ if (dev->connection != SANE_EPSON_NET) {
+ unsigned int n, k, x = 0, y = 0;
+ unsigned char *buf, *area;
+ size_t len;
+
+ status = esci_request_identity(s, &buf, &len);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ e2_set_cmd_level(s, &buf[0]);
+
+ /* Setting available resolutions and xy ranges for sane frontend. */
+ /* cycle thru the resolutions, saving them in a list */
+ for (n = 2, k = 0; n < len; n += k) {
+
+ area = buf + n;
+
+ switch (*area) {
+ case 'R':
+ {
+ int val = area[2] << 8 | area[1];
+
+ status = e2_add_resolution(s->hw, val);
+ k = 3;
+ continue;
+ }
+ case 'A':
+ {
+ x = area[2] << 8 | area[1];
+ y = area[4] << 8 | area[3];
+
+ DBG(1, "maximum scan area: %dx%d\n", x, y);
+ k = 5;
+ continue;
+ }
+ default:
+ break;
+ }
+ }
+
+ /* min and max dpi */
+ dev->dpi_range.min = dev->res_list[0];
+ dev->dpi_range.max = dev->res_list[dev->res_list_size - 1];
+ dev->dpi_range.quant = 0;
+
+ e2_set_fbf_area(s, x, y, dev->dpi_range.max);
+
+ free(buf);
+ }
+
+ /* ESC F, request status */
+ status = esci_request_status(s, &scanner_status);
+ if (status != SANE_STATUS_GOOD)
+ return status;;
+
+ /* set capabilities */
+ if (scanner_status & STATUS_OPTION)
+ dev->extension = SANE_TRUE;
+
+ if (scanner_status & STATUS_EXT_COMMANDS)
+ dev->extended_commands = 1;
+
+ /*
+ * Extended status flag request (ESC f).
+ * this also requests the scanner device name from the the scanner.
+ * It seems unsupported on the network transport (CX11NF/LP-A500).
+ */
+
+ if (dev->cmd->request_extended_status && dev->connection != SANE_EPSON_NET) {
+
+ unsigned char *es;
+ size_t es_len;
+
+ DBG(1, "detection with request_extended_status\n");
+
+ status = esci_request_extended_status(s, &es, &es_len);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /*
+ * Get the device name and copy it to dev->sane.model.
+ * The device name starts at es[0x1A] and is up to 16 bytes long
+ * We are overwriting whatever was set previously!
+ */
+ if (es_len == CMD_SIZE_EXT_STATUS) /* 42 */
+ e2_set_model(s, es + 0x1A, 16);
+
+ if (es[0] & EXT_STATUS_LID)
+ DBG(1, "LID detected\n");
+
+ if (es[0] & EXT_STATUS_PB)
+ DBG(1, "push button detected\n");
+ else
+ dev->cmd->request_push_button_status = 0;
+
+ /* Flatbed */
+ e2_set_fbf_area(s, es[13] << 8 | es[12], es[15] << 8 | es[14],
+ dev->dpi_range.max);
+
+ /* ADF */
+ if (dev->extension && (es[1] & EXT_STATUS_IST)) {
+ DBG(1, "ADF detected\n");
+
+ fix_up_extended_status_reply(s, es);
+
+ dev->duplex = (es[0] & EXT_STATUS_ADFS) != 0;
+ if (dev->duplex)
+ DBG(1, "ADF supports duplex\n");
+
+ if (es[1] & EXT_STATUS_EN) {
+ DBG(1, "ADF is enabled\n");
+ dev->x_range = &dev->adf_x_range;
+ dev->y_range = &dev->adf_y_range;
+ }
+
+ e2_set_adf_area(s, es[3] << 8 | es[2],
+ es[5] << 8 | es[4],
+ dev->dpi_range.max);
+ *source_list_add++ = ADF_STR;
+
+ dev->ADF = SANE_TRUE;
+ }
+
+ /* TPU */
+ if (dev->extension && (es[6] & EXT_STATUS_IST)) {
+ DBG(1, "TPU detected\n");
+
+ if (es[6] & EXT_STATUS_EN) {
+ DBG(1, "TPU is enabled\n");
+ dev->x_range = &dev->tpu_x_range;
+ dev->y_range = &dev->tpu_y_range;
+ }
+
+ e2_set_tpu_area(s,
+ (es[8] << 8 | es[7]),
+ (es[10] << 8 | es[9]),
+ dev->dpi_range.max);
+
+ *source_list_add++ = TPU_STR;
+ dev->TPU = SANE_TRUE;
+ }
+
+ free(es);
+
+ *source_list_add = NULL; /* add end marker to source list */
+ }
+
+ /* FS I, request extended identity (B7/B8) */
+ if (dev->extended_commands && dev->cmd->request_extended_identity) {
+ unsigned char buf[80];
+
+ DBG(1, "detection with request_extended_identity\n");
+
+ status = esci_request_extended_identity(s, buf);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ e2_set_cmd_level(s, &buf[0]);
+
+ dev->maxDepth = buf[67];
+
+ /* set model name. it will probably be
+ * different than the one reported by request_identity
+ * for the same unit (i.e. LP-A500 vs CX11) .
+ */
+ e2_set_model(s, &buf[46], 16);
+
+ dev->optical_res = le32atoh(&buf[4]);
+
+ dev->dpi_range.min = le32atoh(&buf[8]);
+ dev->dpi_range.max = le32atoh(&buf[12]);
+
+ /* Flatbed */
+ e2_set_fbf_area(s, le32atoh(&buf[20]),
+ le32atoh(&buf[24]), dev->optical_res);
+
+ /* ADF */
+ if (le32atoh(&buf[28]) > 0) {
+ e2_set_adf_area(s, le32atoh(&buf[28]),
+ le32atoh(&buf[32]), dev->optical_res);
+
+ if (!dev->ADF) {
+ *source_list_add++ = ADF_STR;
+ dev->ADF = SANE_TRUE;
+ }
+ }
+
+ /* TPU */
+ if (le32atoh(&buf[36]) > 0 && !dev->TPU) {
+ e2_set_tpu_area(s,
+ le32atoh(&buf[36]),
+ le32atoh(&buf[40]), dev->optical_res);
+
+ *source_list_add++ = TPU_STR;
+ dev->TPU = SANE_TRUE;
+ }
+
+ /* TPU2 */
+ if (e2_model(s, "GT-X800") || e2_model(s, "GT-X900")) {
+ if (le32atoh(&buf[68]) > 0 ) {
+ e2_set_tpu2_area(s,
+ le32atoh(&buf[68]),
+ le32atoh(&buf[72]),
+ dev->optical_res);
+
+ *source_list_add++ = TP2_STR;
+ }
+ }
+
+ *source_list_add = NULL; /* add end marker to source list */
+
+ } else {
+ DBG(1, "no command available to detect capabilities\n");
+ }
+
+ /*
+ * request identity 2 (ESC i), if available will
+ * get the information from the scanner and store it in dev
+ */
+
+ if (dev->cmd->request_identity2 && dev->connection != SANE_EPSON_NET) {
+ unsigned char *buf;
+ status = esci_request_identity2(s, &buf);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /* the first two bytes of the buffer contain the optical resolution */
+ dev->optical_res = buf[1] << 8 | buf[0];
+
+ /*
+ * the 4th and 5th byte contain the line distance. Both values have to
+ * be identical, otherwise this software can not handle this scanner.
+ */
+ if (buf[4] != buf[5]) {
+ status = SANE_STATUS_INVAL;
+ return status;
+ }
+
+ dev->max_line_distance = buf[4];
+ }
+
+ /*
+ * Check for the max. supported color depth and assign
+ * the values to the bitDepthList.
+ */
+ dev->depth_list = malloc(sizeof(SANE_Word) * 4);
+ if (dev->depth_list == NULL) {
+ DBG(1, "out of memory (line %d)\n", __LINE__);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ dev->depth_list[0] = 0;
+
+ /* maximum depth discovery */
+ DBG(3, "discovering max depth, NAKs are expected\n");
+
+ if (dev->maxDepth >= 16 || dev->maxDepth == 0) {
+ if (esci_set_data_format(s, 16) == SANE_STATUS_GOOD)
+ e2_add_depth(dev, 16);
+ }
+
+ if (dev->maxDepth >= 14 || dev->maxDepth == 0) {
+ if (esci_set_data_format(s, 14) == SANE_STATUS_GOOD)
+ e2_add_depth(dev, 14);
+ }
+
+ if (dev->maxDepth >= 12 || dev->maxDepth == 0) {
+ if (esci_set_data_format(s, 12) == SANE_STATUS_GOOD)
+ e2_add_depth(dev, 12);
+ }
+
+ /* add default depth */
+ e2_add_depth(dev, 8);
+
+ DBG(1, "maximum supported color depth: %d\n", dev->maxDepth);
+
+ /*
+ * Check for "request focus position" command. If this command is
+ * supported, then the scanner does also support the "set focus
+ * position" command.
+ * XXX ???
+ */
+
+ if (esci_request_focus_position(s, &s->currentFocusPosition) ==
+ SANE_STATUS_GOOD) {
+ DBG(1, "setting focus is supported\n");
+ dev->focusSupport = SANE_TRUE;
+ s->opt[OPT_FOCUS].cap &= ~SANE_CAP_INACTIVE;
+
+ /* reflect the current focus position in the GUI */
+ if (s->currentFocusPosition < 0x4C) {
+ /* focus on glass */
+ s->val[OPT_FOCUS].w = 0;
+ } else {
+ /* focus 2.5mm above glass */
+ s->val[OPT_FOCUS].w = 1;
+ }
+
+ } else {
+ DBG(1, "setting focus is not supported\n");
+ dev->focusSupport = SANE_FALSE;
+ s->opt[OPT_FOCUS].cap |= SANE_CAP_INACTIVE;
+ s->val[OPT_FOCUS].w = 0; /* on glass - just in case */
+ }
+
+ /* Set defaults for no extension. */
+ dev->x_range = &dev->fbf_x_range;
+ dev->y_range = &dev->fbf_y_range;
+
+ /*
+ * Correct for a firmware bug in some Perfection 1650 scanners:
+ * Firmware version 1.08 reports only half the vertical scan area, we have
+ * to double the number. To find out if we have to do this, we just compare
+ * is the vertical range is smaller than the horizontal range.
+ */
+
+ if ((dev->x_range->max - dev->x_range->min) >
+ (dev->y_range->max - dev->y_range->min)) {
+ DBG(1, "found buggy scan area, doubling it.\n");
+ dev->y_range->max += (dev->y_range->max - dev->y_range->min);
+ dev->need_double_vertical = SANE_TRUE;
+ dev->need_color_reorder = SANE_TRUE;
+ }
+
+ /* FS F, request scanner status */
+ if (dev->extended_commands) {
+ unsigned char buf[16];
+
+ status = esci_request_scanner_status(s, buf);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ return status;
+}
+
+
+SANE_Status
+e2_set_extended_scanning_parameters(Epson_Scanner * s)
+{
+ unsigned char buf[64];
+
+ const struct mode_param *mparam;
+
+ DBG(1, "%s\n", __func__);
+
+ mparam = &mode_params[s->val[OPT_MODE].w];
+
+ memset(buf, 0x00, sizeof(buf));
+
+ /* ESC R, resolution */
+ htole32a(&buf[0], s->val[OPT_RESOLUTION].w);
+ htole32a(&buf[4], s->val[OPT_RESOLUTION].w);
+
+ /* ESC A, scanning area */
+ htole32a(&buf[8], s->left);
+ htole32a(&buf[12], s->top);
+ htole32a(&buf[16], s->params.pixels_per_line);
+ htole32a(&buf[20], s->params.lines);
+
+ /*
+ * The byte sequence mode was introduced in B5,
+ *for B[34] we need line sequence mode
+ */
+
+ /* ESC C, set color */
+ if ((s->hw->cmd->level[0] == 'D'
+ || (s->hw->cmd->level[0] == 'B' && s->hw->level >= 5))
+ && mparam->flags == 0x02) {
+ buf[24] = 0x13;
+ } else {
+ buf[24] = mparam->flags | (mparam->dropout_mask
+ & dropout_params[s->
+ val[OPT_DROPOUT].
+ w]);
+ }
+
+ /* ESC D, set data format */
+ mparam = &mode_params[s->val[OPT_MODE].w];
+ buf[25] = mparam->depth;
+
+ /* ESC e, control option */
+ if (s->hw->extension) {
+
+ char extensionCtrl;
+ extensionCtrl = (s->hw->use_extension ? 1 : 0);
+ if (s->hw->use_extension && (s->val[OPT_ADF_MODE].w == 1))
+ extensionCtrl = 2;
+
+ /* Test for TPU2
+ * Epson Perfection 4990 Command Specifications
+ * JZIS-0075 Rev. A, page 31
+ */
+ if (s->hw->use_extension && s->hw->TPU2)
+ extensionCtrl = 5;
+
+ if (s->val[OPT_MODE].w == MODE_INFRARED)
+ /* only infrared in TPU mode (NOT in TPU2 or flatbeth)
+ * XXX investigate this ... only tested on GT-X800
+ */
+
+ if (extensionCtrl == 1) /* test for TPU */
+ extensionCtrl = 3;
+ else
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* ESC e */
+ buf[26] = extensionCtrl;
+
+ /* XXX focus */
+ }
+
+ /* ESC g, scanning mode (normal or high speed) */
+ if (s->val[OPT_PREVIEW].w)
+ buf[27] = 1; /* High speed */
+ else
+ buf[27] = 0;
+
+ /* ESC d, block line number */
+ buf[28] = s->lcount;
+
+ /* ESC Z, set gamma correction */
+ buf[29] = 0x01; /* default */
+
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_GAMMA_CORRECTION].cap)) {
+ char val;
+ if (s->hw->cmd->level[0] == 'D') {
+ /* The D1 level has only the two user defined gamma
+ * settings.
+ */
+ val = gamma_params[s->val[OPT_GAMMA_CORRECTION].w];
+ } else {
+ val = gamma_params[s->val[OPT_GAMMA_CORRECTION].w];
+
+ /*
+ * If "Default" is selected then determine the actual value
+ * to send to the scanner: If bilevel mode, just send the
+ * value from the table (0x01), for grayscale or color mode
+ * add one and send 0x02.
+ */
+
+ if (s->val[OPT_GAMMA_CORRECTION].w == 0) {
+ val += mparam->depth == 1 ? 0 : 1;
+ }
+ }
+
+ buf[29] = val;
+ }
+
+ /* ESC L, set brightness */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_BRIGHTNESS].cap))
+ buf[30] = s->val[OPT_BRIGHTNESS].w;
+
+ /* ESC B, set halftoning mode / halftone processing */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_HALFTONE].cap))
+ buf[32] = halftone_params[s->val[OPT_HALFTONE].w];
+
+ /* ESC s, auto area segmentation */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_AAS].cap))
+ buf[34] = s->val[OPT_AAS].w;
+
+ /* ESC Q, set sharpness / sharpness control */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_SHARPNESS].cap))
+ buf[35] = s->val[OPT_SHARPNESS].w;
+
+ /* ESC K, set data order / mirroring */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_MIRROR].cap))
+ buf[36] = s->val[OPT_MIRROR].w;
+
+ /* ESC N, film type */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_FILM_TYPE].cap))
+ buf[37] = film_params[s->val[OPT_FILM_TYPE].w];
+
+ /* ESC M, color correction */
+ buf[31] = correction_params[s->val[OPT_COLOR_CORRECTION].w];
+
+ /* ESC t, threshold */
+ buf[33] = s->val[OPT_THRESHOLD].w;
+
+ return esci_set_scanning_parameter(s, buf);
+}
+
+SANE_Status
+e2_set_scanning_parameters(Epson_Scanner * s)
+{
+ SANE_Status status;
+ struct mode_param *mparam = &mode_params[s->val[OPT_MODE].w];
+ unsigned char color_mode;
+
+ DBG(1, "%s\n", __func__);
+
+ /*
+ * There is some undocumented special behavior with the TPU enable/disable.
+ * TPU power ESC e status
+ * on 0 NAK
+ * on 1 ACK
+ * off 0 ACK
+ * off 1 NAK
+ *
+ * It makes no sense to scan with TPU powered on and source flatbed, because
+ * light will come from both sides.
+ */
+
+ if (s->hw->extension) {
+
+ int extensionCtrl;
+ extensionCtrl = (s->hw->use_extension ? 1 : 0);
+ if (s->hw->use_extension && (s->val[OPT_ADF_MODE].w == 1))
+ extensionCtrl = 2;
+
+ status = esci_control_extension(s, extensionCtrl);
+ if (status != SANE_STATUS_GOOD) {
+ DBG(1, "you may have to power %s your TPU\n",
+ s->hw->use_extension ? "on" : "off");
+ DBG(1,
+ "and you may also have to restart the SANE frontend.\n");
+ return status;
+ }
+
+ /* XXX use request_extended_status and analyze
+ * buffer to set the scan area for
+ * ES-9000H and GT-30000
+ */
+
+ /*
+ * set the focus position according to the extension used:
+ * if the TPU is selected, then focus 2.5mm above the glass,
+ * otherwise focus on the glass. Scanners that don't support
+ * this feature, will just ignore these calls.
+ */
+
+ if (s->hw->focusSupport == SANE_TRUE) {
+ if (s->val[OPT_FOCUS].w == 0) {
+ DBG(1, "setting focus to glass surface\n");
+ esci_set_focus_position(s, 0x40);
+ } else {
+ DBG(1,
+ "setting focus to 2.5mm above glass\n");
+ esci_set_focus_position(s, 0x59);
+ }
+ }
+ }
+
+ /* ESC C, Set color */
+ color_mode = mparam->flags | (mparam->dropout_mask
+ & dropout_params[s->val[OPT_DROPOUT].
+ w]);
+
+ /*
+ * The byte sequence mode was introduced in B5, for B[34] we need line sequence mode
+ * XXX Check what to do for the FilmScan 200
+ */
+ if ((s->hw->cmd->level[0] == 'D'
+ || (s->hw->cmd->level[0] == 'B' && s->hw->level >= 5))
+ && mparam->flags == 0x02)
+ color_mode = 0x13;
+
+ status = esci_set_color_mode(s, color_mode);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /* ESC D, set data format */
+ DBG(1, "%s: setting data format to %d bits\n", __func__,
+ mparam->depth);
+ status = esci_set_data_format(s, mparam->depth);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /* ESC B, set halftoning mode */
+ if (s->hw->cmd->set_halftoning
+ && SANE_OPTION_IS_ACTIVE(s->opt[OPT_HALFTONE].cap)) {
+ status = esci_set_halftoning(s,
+ halftone_params[s->
+ val
+ [OPT_HALFTONE].
+ w]);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ /* ESC L, set brightness */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_BRIGHTNESS].cap)) {
+ status = esci_set_bright(s, s->val[OPT_BRIGHTNESS].w);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_AAS].cap)) {
+ status = esci_set_auto_area_segmentation(s,
+ s->val[OPT_AAS].w);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_FILM_TYPE].cap)) {
+ status = esci_set_film_type(s,
+ film_params[s->val[OPT_FILM_TYPE].w]);
+
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ if (s->hw->cmd->set_gamma
+ && SANE_OPTION_IS_ACTIVE(s->opt[OPT_GAMMA_CORRECTION].cap)) {
+ int val;
+ if (s->hw->cmd->level[0] == 'D') {
+ /*
+ * The D1 level has only the two user defined gamma
+ * settings.
+ */
+ val = gamma_params[s->val[OPT_GAMMA_CORRECTION].w];
+ } else {
+ val = gamma_params[s->val[OPT_GAMMA_CORRECTION].w];
+
+ /*
+ * If "Default" is selected then determine the actual value
+ * to send to the scanner: If bilevel mode, just send the
+ * value from the table (0x01), for grayscale or color mode
+ * add one and send 0x02.
+ */
+
+/* if( s->val[ OPT_GAMMA_CORRECTION].w <= 1) { */
+ if (s->val[OPT_GAMMA_CORRECTION].w == 0) {
+ val += mparam->depth == 1 ? 0 : 1;
+ }
+ }
+
+ status = esci_set_gamma(s, val);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ if (s->hw->cmd->set_threshold != 0
+ && SANE_OPTION_IS_ACTIVE(s->opt[OPT_THRESHOLD].cap)) {
+ status = esci_set_threshold(s, s->val[OPT_THRESHOLD].w);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ /* XXX ESC Z here */
+
+ /* ESC M, set color correction */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_COLOR_CORRECTION].cap)) {
+
+ status = esci_set_color_correction(s,
+ correction_params[s->val[OPT_COLOR_CORRECTION].w]);
+
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ /* ESC Q, set sharpness */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_SHARPNESS].cap)) {
+
+ status = esci_set_sharpness(s, s->val[OPT_SHARPNESS].w);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ /* ESC g, set scanning mode */
+ if (s->val[OPT_PREVIEW].w)
+ status = esci_set_speed(s, 1);
+ else
+ status = esci_set_speed(s, 0);
+
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /* ESC K, set data order */
+ if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_MIRROR].cap)) {
+ status = esci_mirror_image(s, s->val[OPT_MIRROR].w);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ /* ESC R */
+ status = esci_set_resolution(s, s->val[OPT_RESOLUTION].w,
+ s->val[OPT_RESOLUTION].w);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /* ESC H, set zoom */
+ /* not implemented */
+
+ /* ESC A, set scanning area */
+
+ /*
+ * Modify the scan area: If the scanner requires color shuffling, then we try to
+ * scan more lines to compensate for the lines that will be removed from the scan
+ * due to the color shuffling algorithm.
+ */
+
+ if (s->hw->color_shuffle == SANE_TRUE) {
+
+ unsigned int lines = s->params.lines + (2 * s->line_distance);
+ int top = s->top - (1 * s->line_distance);
+
+ if (top < 0)
+ top = 0;
+
+ status = esci_set_scan_area(s, s->left, top,
+ s->params.pixels_per_line,
+ lines);
+
+ } else {
+
+ status = esci_set_scan_area(s, s->left, s->top,
+ s->params.pixels_per_line,
+ s->params.lines);
+ }
+
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ /* ESC d, set block line number / set line counter */
+ status = esci_set_lcount(s, s->lcount);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ return SANE_STATUS_GOOD;
+}
+
+void
+e2_setup_block_mode(Epson_Scanner * s)
+{
+ int maxreq;
+
+ DBG(5, "%s\n", __func__);
+
+ s->block = SANE_TRUE;
+
+ if (s->hw->connection == SANE_EPSON_SCSI)
+ maxreq = sanei_scsi_max_request_size;
+ else if (s->hw->connection == SANE_EPSON_USB)
+ maxreq = 128 * 1024;
+ else
+ maxreq = 32 * 1024;
+
+ /* XXX verify if this can b extended to other models */
+ if (s->hw->connection == SANE_EPSON_NET && e2_model(s, "LP-A500"))
+ maxreq = 64 * 1024;
+
+ s->lcount = maxreq / s->params.bytes_per_line;
+
+ DBG(1, "max req size: %d, line count: %d\n", maxreq, s->lcount);
+
+ /* XXX investigate this */
+ if (s->lcount < 3 && (e2_model(s, "GT-X800") || e2_model(s, "GT-X900"))) {
+ s->lcount = 21;
+ DBG(17,
+ "%s: set lcount = %i bigger than sanei_scsi_max_request_size\n",
+ __func__, s->lcount);
+ }
+
+ if (s->lcount >= 255)
+ s->lcount = 255;
+
+ /* XXX why this? */
+ if (s->hw->TPU && s->hw->use_extension && s->lcount > 32)
+ s->lcount = 32;
+
+ /*
+ * The D1 series of scanners only allow an even line number
+ * for bi-level scanning. If a bit depth of 1 is selected, then
+ * make sure the next lower even number is selected.
+ */
+
+ /* XXX check bith depth? */
+ if (s->hw->cmd->level[0] == 'D' && s->lcount > 3 && s->lcount % 2)
+ s->lcount -= 1;
+
+ DBG(1, "final line count is %d\n", s->lcount);
+}
+
+SANE_Status
+e2_init_parameters(Epson_Scanner * s)
+{
+ int dpi, bytes_per_pixel;
+ struct mode_param *mparam;
+
+ DBG(5, "%s\n", __func__);
+
+ memset(&s->params, 0, sizeof(SANE_Parameters));
+
+ dpi = s->val[OPT_RESOLUTION].w;
+
+ mparam = &mode_params[s->val[OPT_MODE].w];
+
+ if (SANE_UNFIX(s->val[OPT_BR_Y].w) == 0 ||
+ SANE_UNFIX(s->val[OPT_BR_X].w) == 0)
+ return SANE_STATUS_INVAL;
+
+ s->left = ((SANE_UNFIX(s->val[OPT_TL_X].w) / MM_PER_INCH) *
+ s->val[OPT_RESOLUTION].w) + 0.5;
+
+ s->top = ((SANE_UNFIX(s->val[OPT_TL_Y].w) / MM_PER_INCH) *
+ s->val[OPT_RESOLUTION].w) + 0.5;
+
+ s->params.pixels_per_line =
+ ((SANE_UNFIX(s->val[OPT_BR_X].w -
+ s->val[OPT_TL_X].w) / MM_PER_INCH) * dpi) + 0.5;
+ s->params.lines =
+ ((SANE_UNFIX(s->val[OPT_BR_Y].w -
+ s->val[OPT_TL_Y].w) / MM_PER_INCH) * dpi) + 0.5;
+
+
+ DBG(1, "%s: resolution = %d, preview = %d\n",
+ __func__, s->val[OPT_RESOLUTION].w, s->val[OPT_PREVIEW].w);
+
+ DBG(1, "%s: %p %p tlx %f tly %f brx %f bry %f [mm]\n",
+ __func__, (void *) s, (void *) s->val,
+ SANE_UNFIX(s->val[OPT_TL_X].w), SANE_UNFIX(s->val[OPT_TL_Y].w),
+ SANE_UNFIX(s->val[OPT_BR_X].w), SANE_UNFIX(s->val[OPT_BR_Y].w));
+
+ /*
+ * Calculate bytes_per_pixel and bytes_per_line for
+ * any color depths.
+ *
+ * The default color depth is stored in mode_params.depth:
+ */
+
+ if (mode_params[s->val[OPT_MODE].w].depth == 1)
+ s->params.depth = 1;
+ else
+ s->params.depth = s->val[OPT_BIT_DEPTH].w;
+
+ if (s->params.depth > 8) {
+ s->params.depth = 16; /*
+ * The frontends can only handle 8 or 16 bits
+ * for gray or color - so if it's more than 8,
+ * it gets automatically set to 16. This works
+ * as long as EPSON does not come out with a
+ * scanner that can handle more than 16 bits
+ * per color channel.
+ */
+ }
+
+ /* this works because it can only be set to 1, 8 or 16 */
+ bytes_per_pixel = s->params.depth / 8;
+ if (s->params.depth % 8) { /* just in case ... */
+ bytes_per_pixel++;
+ }
+
+ /* pixels_per_line is rounded to the next 8bit boundary */
+ s->params.pixels_per_line = s->params.pixels_per_line & ~7;
+
+ s->params.last_frame = SANE_TRUE;
+
+ switch (s->val[OPT_MODE].w) {
+ case MODE_BINARY:
+ case MODE_GRAY:
+ s->params.format = SANE_FRAME_GRAY;
+ s->params.bytes_per_line =
+ s->params.pixels_per_line * s->params.depth / 8;
+ break;
+ case MODE_COLOR:
+ s->params.format = SANE_FRAME_RGB;
+ s->params.bytes_per_line =
+ 3 * s->params.pixels_per_line * bytes_per_pixel;
+ break;
+#ifdef SANE_FRAME_IR
+ case MODE_INFRARED:
+ s->params.format = SANE_FRAME_IR;
+ s->params.bytes_per_line =
+ s->params.pixels_per_line * s->params.depth / 8;
+ break;
+#endif
+ }
+
+ if (s->params.bytes_per_line == 0)
+ return SANE_STATUS_INVAL;
+
+ /*
+ * Calculate correction for line_distance in D1 scanner:
+ * Start line_distance lines earlier and add line_distance lines at the end
+ *
+ * Because the actual line_distance is not yet calculated we have to do this
+ * first.
+ */
+
+ s->hw->color_shuffle = SANE_FALSE;
+
+ s->lines_written = 0;
+ s->color_shuffle_line = 0;
+ s->current_output_line = 0;
+
+ if ((s->hw->optical_res != 0) && (mparam->depth == 8)
+ && (mparam->flags != 0)) {
+
+ s->line_distance =
+ s->hw->max_line_distance * dpi / s->hw->optical_res;
+
+ if (s->line_distance != 0) {
+
+ s->hw->color_shuffle = SANE_TRUE;
+
+ DBG(1, "%s: color shuffling required\n", __func__);
+ }
+ }
+
+ /*
+ * If (s->top + s->params.lines) is larger than the max scan area, reset
+ * the number of scan lines:
+ * XXX: precalculate the maximum scanning area elsewhere (use dev max_y)
+ */
+
+ if (SANE_UNFIX(s->val[OPT_BR_Y].w) / MM_PER_INCH * dpi <
+ (s->params.lines + s->top)) {
+ s->params.lines =
+ ((int) SANE_UNFIX(s->val[OPT_BR_Y].w) / MM_PER_INCH *
+ dpi + 0.5) - s->top;
+ }
+
+ s->block = SANE_FALSE;
+ s->lcount = 1;
+
+ /*
+ * The set line count commands needs to be sent for certain scanners in
+ * color mode. The D1 level requires it, we are however only testing for
+ * 'D' and not for the actual numeric level.
+ */
+
+ if ((s->hw->cmd->level[0] == 'B') && (s->hw->level >= 5)) /* >= B5 */
+ e2_setup_block_mode(s);
+
+ else if ((s->hw->cmd->level[0] == 'B') && (s->hw->level == 4) /* B4 !color */
+ && (!mode_params[s->val[OPT_MODE].w].color))
+ e2_setup_block_mode(s);
+
+ else if (s->hw->cmd->level[0] == 'D') /* Dx */
+ e2_setup_block_mode(s);
+
+ return (s->params.lines > 0) ? SANE_STATUS_GOOD : SANE_STATUS_INVAL;
+}
+
+void
+e2_wait_button(Epson_Scanner * s)
+{
+ DBG(5, "%s\n", __func__);
+
+ s->hw->wait_for_button = SANE_TRUE;
+
+ while (s->hw->wait_for_button == SANE_TRUE) {
+ unsigned char button_status = 0;
+
+ if (s->canceling == SANE_TRUE)
+ s->hw->wait_for_button = SANE_FALSE;
+
+ /* get the button status from the scanner */
+ else if (esci_request_push_button_status(s, &button_status) ==
+ SANE_STATUS_GOOD) {
+ if (button_status)
+ s->hw->wait_for_button = SANE_FALSE;
+ else
+ sleep(1);
+ } else {
+ /* we run into an error condition, just continue */
+ s->hw->wait_for_button = SANE_FALSE;
+ }
+ }
+}
+
+/*
+SANE_Status
+e2_check_extended_status(Epson_Scanner *s)
+{
+
+ SANE_Status status = esci_request_scanner_status(s, buf);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (buf[0] & FSF_STATUS_MAIN_WU)
+
+ main -> 0
+ fbf -> 3
+ adf -> 1, 10
+ tpu -> 2
+}
+*/
+
+SANE_Status
+e2_check_warm_up(Epson_Scanner * s, SANE_Bool * wup)
+{
+ SANE_Status status;
+
+ DBG(5, "%s\n", __func__);
+
+ *wup = SANE_FALSE;
+
+ if (s->hw->extended_commands) {
+ unsigned char buf[16];
+
+ status = esci_request_scanner_status(s, buf);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (buf[0] & FSF_STATUS_MAIN_WU)
+ *wup = SANE_TRUE;
+
+ } else {
+ unsigned char *es;
+
+ /* this command is not available on some scanners */
+ if (!s->hw->cmd->request_extended_status)
+ return SANE_STATUS_GOOD;
+
+ status = esci_request_extended_status(s, &es, NULL);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (es[0] & EXT_STATUS_WU)
+ *wup = SANE_TRUE;
+
+ free(es);
+ }
+
+ return status;
+}
+
+SANE_Status
+e2_wait_warm_up(Epson_Scanner * s)
+{
+ SANE_Status status;
+ SANE_Bool wup;
+
+ DBG(5, "%s\n", __func__);
+
+ s->retry_count = 0;
+
+ while (1) {
+
+ if (s->canceling)
+ return SANE_STATUS_CANCELLED;
+
+ status = e2_check_warm_up(s, &wup);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (wup == SANE_FALSE)
+ break;
+
+ s->retry_count++;
+
+ if (s->retry_count > SANE_EPSON_MAX_RETRIES) {
+ DBG(1, "max retry count exceeded (%d)\n",
+ s->retry_count);
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+ sleep(5);
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+e2_check_adf(Epson_Scanner * s)
+{
+ SANE_Status status;
+
+ DBG(5, "%s\n", __func__);
+
+ if (s->hw->use_extension == SANE_FALSE)
+ return SANE_STATUS_GOOD;
+
+ if (s->hw->extended_commands) {
+ unsigned char buf[16];
+
+ status = esci_request_scanner_status(s, buf);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (buf[1] & FSF_STATUS_ADF_PE)
+ return SANE_STATUS_NO_DOCS;
+
+ if (buf[1] & FSF_STATUS_ADF_PJ)
+ return SANE_STATUS_JAMMED;
+
+ } else {
+ unsigned char *buf, t;
+
+ status = esci_request_extended_status(s, &buf, NULL);
+ if (status != SANE_STATUS_GOOD)
+ return status;;
+
+ t = buf[1];
+
+ free(buf);
+
+ if (t & EXT_STATUS_PE)
+ return SANE_STATUS_NO_DOCS;
+
+ if (t & EXT_STATUS_PJ)
+ return SANE_STATUS_JAMMED;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+e2_start_std_scan(Epson_Scanner * s)
+{
+ SANE_Status status;
+ unsigned char params[2];
+
+ DBG(5, "%s\n", __func__);
+
+ /* ESC g */
+ params[0] = ESC;
+ params[1] = s->hw->cmd->start_scanning;
+
+ e2_send(s, params, 2, 6 + (s->lcount * s->params.bytes_per_line),
+ &status);
+
+ return status;
+}
+
+SANE_Status
+e2_start_ext_scan(Epson_Scanner * s)
+{
+ SANE_Status status;
+ unsigned char params[2];
+ unsigned char buf[14];
+
+ DBG(5, "%s\n", __func__);
+
+ params[0] = FS;
+ params[1] = 'G';
+
+ status = e2_txrx(s, params, 2, buf, 14);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (buf[0] != STX)
+ return SANE_STATUS_INVAL;
+
+ if (buf[1] & 0x80) {
+ DBG(1, "%s: fatal error\n", __func__);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ s->ext_block_len = le32atoh(&buf[2]);
+ s->ext_blocks = le32atoh(&buf[6]);
+ s->ext_last_len = le32atoh(&buf[10]);
+
+ s->ext_counter = 0;
+
+ DBG(5, " status : 0x%02x\n", buf[1]);
+ DBG(5, " block size : %u\n", (unsigned int) le32atoh(&buf[2]));
+ DBG(5, " block count : %u\n", (unsigned int) le32atoh(&buf[6]));
+ DBG(5, " last block size: %u\n", (unsigned int) le32atoh(&buf[10]));
+
+ if (s->ext_last_len) {
+ s->ext_blocks++;
+ DBG(1, "adjusted block count: %d\n", s->ext_blocks);
+ }
+
+ /* adjust block len if we have only one block to read */
+ if (s->ext_block_len == 0 && s->ext_last_len)
+ s->ext_block_len = s->ext_last_len;
+
+ return status;
+}
+
+void
+e2_scan_finish(Epson_Scanner * s)
+{
+ DBG(5, "%s\n", __func__);
+
+ free(s->buf);
+ s->buf = NULL;
+
+ if (s->hw->ADF && s->hw->use_extension && s->val[OPT_AUTO_EJECT].w)
+ if (e2_check_adf(s) == SANE_STATUS_NO_DOCS)
+ esci_eject(s);
+
+ /* XXX required? */
+ if (s->hw->connection != SANE_EPSON_NET)
+ esci_reset(s);
+}
+
+void
+e2_copy_image_data(Epson_Scanner * s, SANE_Byte * data, SANE_Int max_length,
+ SANE_Int * length)
+{
+ if (!s->block && s->params.format == SANE_FRAME_RGB) {
+
+ max_length /= 3;
+
+ if (max_length > s->end - s->ptr)
+ max_length = s->end - s->ptr;
+
+ *length = 3 * max_length;
+
+ while (max_length-- != 0) {
+ *data++ = s->ptr[0];
+ *data++ = s->ptr[s->params.pixels_per_line];
+ *data++ = s->ptr[2 * s->params.pixels_per_line];
+ ++s->ptr;
+ }
+
+ } else {
+ if (max_length > s->end - s->ptr)
+ max_length = s->end - s->ptr;
+
+ *length = max_length;
+
+ if (s->params.depth == 1) {
+ while (max_length-- != 0)
+ *data++ = ~*s->ptr++;
+ } else {
+ memcpy(data, s->ptr, max_length);
+ s->ptr += max_length;
+ }
+ }
+}
+
+SANE_Status
+e2_ext_read(struct Epson_Scanner *s)
+{
+ struct Epson_Device *dev = s->hw;
+ SANE_Status status = SANE_STATUS_GOOD;
+ ssize_t buf_len = 0, read;
+
+ /* did we passed everything we read to sane? */
+ if (s->ptr == s->end) {
+
+ if (s->eof)
+ return SANE_STATUS_EOF;
+
+ s->ext_counter++;
+
+ /* sane has already got the data, read some more, the final
+ * error byte must not be included in buf_len
+ */
+ buf_len = s->ext_block_len;
+
+ if (s->ext_counter == s->ext_blocks && s->ext_last_len)
+ buf_len = s->ext_last_len;
+
+ DBG(18, "%s: block %d/%d, size %lu\n", __func__,
+ s->ext_counter, s->ext_blocks,
+ (unsigned long) buf_len);
+
+ /* receive image data + error code */
+ read = e2_recv(s, s->buf, buf_len + 1, &status);
+
+ DBG(18, "%s: read %lu bytes\n", __func__, (unsigned long) read);
+
+ if (read != buf_len + 1)
+ return SANE_STATUS_IO_ERROR;
+
+ if (e2_dev_model(dev, "GT-8200") || e2_dev_model(dev, "Perfection1650")) {
+ /* See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=597922#127 */
+ s->buf[buf_len] &= 0xc0;
+ }
+
+ if (s->buf[buf_len] & FSG_STATUS_CANCEL_REQ) {
+ DBG(0, "%s: cancel request received\n", __func__);
+ e2_cancel(s);
+ return SANE_STATUS_CANCELLED;
+ }
+
+ if (s->buf[buf_len] & (FSG_STATUS_FER | FSG_STATUS_NOT_READY))
+ return SANE_STATUS_IO_ERROR;
+
+ /* ack every block except the last one */
+ if (s->ext_counter < s->ext_blocks) {
+ size_t next_len = s->ext_block_len;
+
+ if (s->ext_counter == (s->ext_blocks - 1))
+ next_len = s->ext_last_len;
+
+ if (s->canceling) {
+ e2_cancel(s);
+ return SANE_STATUS_CANCELLED;
+ }
+
+ status = e2_ack_next(s, next_len + 1);
+ } else
+ s->eof = SANE_TRUE;
+
+ s->end = s->buf + buf_len;
+ s->ptr = s->buf;
+ }
+
+ return status;
+}
+
+/* XXXX use routine from sane-evolution */
+
+typedef struct
+{
+ unsigned char code;
+ unsigned char status;
+
+ unsigned char buf[4];
+
+} EpsonDataRec;
+
+
+/* XXX this routine is ugly and should be avoided */
+static SANE_Status
+read_info_block(Epson_Scanner * s, EpsonDataRec * result)
+{
+ SANE_Status status;
+ unsigned char params[2];
+
+ retry:
+ e2_recv(s, result, s->block ? 6 : 4, &status);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (result->code != STX) {
+ DBG(1, "error: got %02x, expected STX\n", result->code);
+ return SANE_STATUS_INVAL;
+ }
+
+ /* XXX */
+ if (result->status & STATUS_FER) {
+ unsigned char *ext_status;
+
+ DBG(1, "fatal error, status = %02x\n", result->status);
+
+ if (s->retry_count > SANE_EPSON_MAX_RETRIES) {
+ DBG(1, "max retry count exceeded (%d)\n",
+ s->retry_count);
+ return SANE_STATUS_INVAL;
+ }
+
+ /* if the scanner is warming up, retry after a few secs */
+ status = esci_request_extended_status(s, &ext_status, NULL);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ if (ext_status[0] & EXT_STATUS_WU) {
+ free(ext_status);
+
+ sleep(5); /* for the next attempt */
+
+ DBG(1, "retrying ESC G - %d\n", ++(s->retry_count));
+
+ params[0] = ESC;
+ params[1] = s->hw->cmd->start_scanning;
+
+ e2_send(s, params, 2, 0, &status);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ goto retry;
+ } else
+ free(ext_status);
+ }
+
+ return status;
+}
+
+static SANE_Status
+color_shuffle(SANE_Handle handle, int *new_length)
+{
+ Epson_Scanner *s = (Epson_Scanner *) handle;
+ SANE_Byte *buf = s->buf;
+ int length = s->end - s->buf;
+
+ SANE_Byte *data_ptr; /* ptr to data to process */
+ SANE_Byte *data_end; /* ptr to end of processed data */
+ SANE_Byte *out_data_ptr; /* ptr to memory when writing data */
+ int i; /* loop counter */
+
+ /*
+ * It looks like we are dealing with a scanner that has an odd way
+ * of dealing with colors... The red and blue scan lines are shifted
+ * up or down by a certain number of lines relative to the green line.
+ */
+ DBG(5, "%s\n", __func__);
+
+ /*
+ * Initialize the variables we are going to use for the
+ * copying of the data. data_ptr is the pointer to
+ * the currently worked on scan line. data_end is the
+ * end of the data area as calculated from adding *length
+ * to the start of data.
+ * out_data_ptr is used when writing out the processed data
+ * and always points to the beginning of the next line to
+ * write.
+ */
+ data_ptr = out_data_ptr = buf;
+ data_end = data_ptr + length;
+
+ /*
+ * The image data is in *buf, we know that the buffer contains s->end - s->buf ( = length)
+ * bytes of data. The width of one line is in s->params.bytes_per_line
+ *
+ * The buffer area is supposed to have a number of full scan
+ * lines, let's test if this is the case.
+ */
+
+ if (length % s->params.bytes_per_line != 0) {
+ DBG(1, "error in buffer size: %d / %d\n", length,
+ s->params.bytes_per_line);
+ return SANE_STATUS_INVAL;
+ }
+
+ while (data_ptr < data_end) {
+ SANE_Byte *source_ptr, *dest_ptr;
+ int loop;
+
+ /* copy the green information into the current line */
+
+ source_ptr = data_ptr + 1;
+ dest_ptr = s->line_buffer[s->color_shuffle_line] + 1;
+
+ for (i = 0; i < s->params.bytes_per_line / 3; i++) {
+ *dest_ptr = *source_ptr;
+ dest_ptr += 3;
+ source_ptr += 3;
+ }
+
+ /* copy the red information n lines back */
+
+ if (s->color_shuffle_line >= s->line_distance) {
+ source_ptr = data_ptr + 2;
+ dest_ptr =
+ s->line_buffer[s->color_shuffle_line -
+ s->line_distance] + 2;
+
+/* while (source_ptr < s->line_buffer[s->color_shuffle_line] + s->params.bytes_per_line) */
+ for (loop = 0;
+ loop < s->params.bytes_per_line / 3;
+ loop++) {
+ *dest_ptr = *source_ptr;
+ dest_ptr += 3;
+ source_ptr += 3;
+ }
+ }
+
+ /* copy the blue information n lines forward */
+
+ source_ptr = data_ptr;
+ dest_ptr =
+ s->line_buffer[s->color_shuffle_line +
+ s->line_distance];
+
+/* while (source_ptr < s->line_buffer[s->color_shuffle_line] + s->params.bytes_per_line) */
+ for (loop = 0; loop < s->params.bytes_per_line / 3;
+ loop++) {
+ *dest_ptr = *source_ptr;
+ dest_ptr += 3;
+ source_ptr += 3;
+ }
+
+ data_ptr += s->params.bytes_per_line;
+
+ if (s->color_shuffle_line == s->line_distance) {
+ /*
+ * We just finished the line in line_buffer[0] - write it to the
+ * output buffer and continue.
+ *
+ * The ouput buffer ist still "buf", but because we are
+ * only overwriting from the beginning of the memory area
+ * we are not interfering with the "still to shuffle" data
+ * in the same area.
+ */
+
+ /*
+ * Strip the first and last n lines and limit to
+ */
+ if ((s->current_output_line >=
+ s->line_distance)
+ && (s->current_output_line <
+ s->params.lines + s->line_distance)) {
+ memcpy(out_data_ptr,
+ s->line_buffer[0],
+ s->params.bytes_per_line);
+ out_data_ptr +=
+ s->params.bytes_per_line;
+
+ s->lines_written++;
+ }
+
+ s->current_output_line++;
+
+ /*
+ * Now remove the 0-entry and move all other
+ * lines up by one. There are 2*line_distance + 1
+ * buffers, * therefore the loop has to run from 0
+ * to * 2*line_distance, and because we want to
+ * copy every n+1st entry to n the loop runs
+ * from - to 2*line_distance-1!
+ */
+
+ free(s->line_buffer[0]);
+
+ for (i = 0; i < s->line_distance * 2; i++) {
+ s->line_buffer[i] =
+ s->line_buffer[i + 1];
+ }
+
+ /*
+ * and create one new buffer at the end
+ */
+
+ s->line_buffer[s->line_distance * 2] =
+ malloc(s->params.bytes_per_line);
+ if (s->line_buffer[s->line_distance * 2] ==
+ NULL) {
+ DBG(1, "out of memory (line %d)\n",
+ __LINE__);
+ return SANE_STATUS_NO_MEM;
+ }
+ } else {
+ s->color_shuffle_line++; /* increase the buffer number */
+ }
+ }
+
+ /*
+ * At this time we've used up all the new data from the scanner, some of
+ * it is still in the line_buffers, but we are ready to return some of it
+ * to the front end software. To do so we have to adjust the size of the
+ * data area and the *new_length variable.
+ */
+
+ *new_length = out_data_ptr - buf;
+
+ return SANE_STATUS_GOOD;
+}
+
+static inline int
+get_color(int status)
+{
+ switch ((status >> 2) & 0x03) {
+ case 1:
+ return 1;
+ case 2:
+ return 0;
+ case 3:
+ return 2;
+ default:
+ return 0; /* required to make the compiler happy */
+ }
+}
+
+
+SANE_Status
+e2_block_read(struct Epson_Scanner *s)
+{
+ SANE_Status status;
+ SANE_Bool reorder = SANE_FALSE;
+ SANE_Bool needStrangeReorder = SANE_FALSE;
+
+ START_READ:
+ DBG(18, "%s: begin\n", __func__);
+
+ if (s->ptr == s->end) {
+ EpsonDataRec result;
+ unsigned int buf_len;
+
+ if (s->eof) {
+ if (s->hw->color_shuffle) {
+ DBG(1,
+ "written %d lines after color shuffle\n",
+ s->lines_written);
+ DBG(1, "lines requested: %d\n",
+ s->params.lines);
+ }
+
+ return SANE_STATUS_EOF;
+ }
+
+ status = read_info_block(s, &result);
+ if (status != SANE_STATUS_GOOD) {
+ return status;
+ }
+
+ buf_len = result.buf[1] << 8 | result.buf[0];
+ buf_len *= (result.buf[3] << 8 | result.buf[2]);
+
+ DBG(18, "%s: buf len = %u\n", __func__, buf_len);
+
+ {
+ /* do we have to reorder the data ? */
+ if (get_color(result.status) == 0x01)
+ reorder = SANE_TRUE;
+
+ e2_recv(s, s->buf, buf_len, &status);
+ if (status != SANE_STATUS_GOOD) {
+ return status;
+ }
+ }
+
+ if (result.status & STATUS_AREA_END) {
+ DBG(1, "%s: EOF\n", __func__);
+ s->eof = SANE_TRUE;
+ } else {
+ if (s->canceling) {
+ e2_cancel(s);
+ return SANE_STATUS_CANCELLED;
+ } else {
+ status = e2_ack(s);
+ }
+ }
+
+ s->end = s->buf + buf_len;
+ s->ptr = s->buf;
+
+ /*
+ * if we have to re-order the color components (GRB->RGB) we
+ * are doing this here:
+ */
+
+ /*
+ * Some scanners (e.g. the Perfection 1640 and GT-2200) seem
+ * to have the R and G channels swapped.
+ * The GT-8700 is the Asian version of the Perfection 1640.
+ * If the scanner name is one of these and the scan mode is
+ * RGB then swap the colors.
+ */
+
+ needStrangeReorder =
+ (strstr(s->hw->model, "GT-2200") ||
+ ((strstr(s->hw->model, "1640")
+ && strstr(s->hw->model, "Perfection"))
+ || strstr(s->hw->model, "GT-8700")))
+ && s->params.format == SANE_FRAME_RGB;
+
+ /*
+ * Certain Perfection 1650 also need this re-ordering of the two
+ * color channels. These scanners are identified by the problem
+ * with the half vertical scanning area. When we corrected this,
+ * we also set the variable s->hw->need_color_reorder
+ */
+ if (s->hw->need_color_reorder)
+ reorder = SANE_FALSE; /* reordering once is enough */
+
+ if (reorder && s->params.format == SANE_FRAME_RGB) {
+ SANE_Byte *ptr;
+
+ ptr = s->buf;
+ while (ptr < s->end) {
+ if (s->params.depth > 8) {
+ SANE_Byte tmp;
+
+ /* R->G G->R */
+ tmp = ptr[0];
+ ptr[0] = ptr[2]; /* first Byte G */
+ ptr[2] = tmp; /* first Byte R */
+
+ tmp = ptr[1];
+ ptr[1] = ptr[3]; /* second Byte G */
+ ptr[3] = tmp; /* second Byte R */
+
+ ptr += 6; /* go to next pixel */
+ } else {
+ /* R->G G->R */
+ SANE_Byte tmp;
+
+ tmp = ptr[0];
+ ptr[0] = ptr[1]; /* G */
+ ptr[1] = tmp; /* R */
+ /* B stays the same */
+ ptr += 3; /* go to next pixel */
+ }
+ }
+ }
+
+ /*
+ * Do the color_shuffle if everything else is correct - at this time
+ * most of the stuff is hardcoded for the Perfection 610
+ */
+
+ if (s->hw->color_shuffle) {
+ int new_length = 0;
+
+ status = color_shuffle(s, &new_length);
+ /* XXX check status here */
+
+ /*
+ * If no bytes are returned, check if the scanner is already done, if so,
+ * we'll probably just return, but if there is more data to process get
+ * the next batch.
+ */
+ if (new_length == 0 && s->end != s->ptr)
+ goto START_READ;
+
+ s->end = s->buf + new_length;
+ s->ptr = s->buf;
+ }
+
+ DBG(18, "%s: begin scan2\n", __func__);
+ }
+
+ DBG(18, "%s: end\n", __func__);
+
+ return SANE_STATUS_GOOD;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 11:21:47 +0000