summaryrefslogtreecommitdiff
path: root/backend/gt68xx_mid.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/gt68xx_mid.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/gt68xx_mid.c')
-rw-r--r--backend/gt68xx_mid.c1185
1 files changed, 1185 insertions, 0 deletions
diff --git a/backend/gt68xx_mid.c b/backend/gt68xx_mid.c
new file mode 100644
index 0000000..1301139
--- /dev/null
+++ b/backend/gt68xx_mid.c
@@ -0,0 +1,1185 @@
+/* sane - Scanner Access Now Easy.
+
+ Copyright (C) 2002 Sergey Vlasov <vsu@altlinux.ru>
+ Copyright (C) 2002-2007 Henning Geinitz <sane@geinitz.org>
+
+ 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.
+*/
+
+#include "gt68xx_mid.h"
+#include "gt68xx_low.c"
+
+/** @file
+ * @brief Image data unpacking.
+ */
+
+static SANE_Status
+gt68xx_delay_buffer_init (GT68xx_Delay_Buffer * delay,
+ SANE_Int pixels_per_line, SANE_Int delay_count)
+{
+ SANE_Int bytes_per_line;
+ SANE_Int line_count, i;
+
+ if (pixels_per_line <= 0)
+ {
+ DBG (3, "gt68xx_delay_buffer_init: BUG: pixels_per_line=%d\n",
+ pixels_per_line);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (delay_count < 0)
+ {
+ DBG (3, "gt68xx_delay_buffer_init: BUG: delay_count=%d\n", delay_count);
+ return SANE_STATUS_INVAL;
+ }
+
+ bytes_per_line = pixels_per_line * sizeof (unsigned int);
+
+ delay->line_count = line_count = delay_count + 1;
+ delay->read_index = 0;
+ delay->write_index = delay_count;
+
+ delay->mem_block = (SANE_Byte *) malloc (bytes_per_line * line_count);
+ if (!delay->mem_block)
+ {
+ DBG (3, "gt68xx_delay_buffer_init: no memory for delay block\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ /* make sure that we will see if one of the unitialized lines get displayed */
+ for (i = 0; i < bytes_per_line * line_count; i++)
+ delay->mem_block[i] = i % 256;
+
+ delay->lines =
+ (unsigned int **) malloc (sizeof (unsigned int *) * line_count);
+ if (!delay->lines)
+ {
+ free (delay->mem_block);
+ DBG (3,
+ "gt68xx_delay_buffer_init: no memory for delay line pointers\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ for (i = 0; i < line_count; ++i)
+ delay->lines[i] =
+ (unsigned int *) (delay->mem_block + i * bytes_per_line);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+gt68xx_delay_buffer_done (GT68xx_Delay_Buffer * delay)
+{
+ if (delay->lines)
+ {
+ free (delay->lines);
+ delay->lines = NULL;
+ }
+
+ if (delay->mem_block)
+ {
+ free (delay->mem_block);
+ delay->mem_block = NULL;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+#define DELAY_BUFFER_WRITE_PTR(delay) ( (delay)->lines[(delay)->write_index] )
+
+#define DELAY_BUFFER_SELECT_PTR(delay,dist) \
+ ((delay)->lines[((delay)->read_index + (dist)) % (delay)->line_count])
+
+#define DELAY_BUFFER_READ_PTR(delay) ( (delay)->lines[(delay)->read_index ] )
+
+#define DELAY_BUFFER_STEP(delay) \
+ do \
+ { \
+ (delay)->read_index = ((delay)->read_index + 1) % (delay)->line_count; \
+ (delay)->write_index = ((delay)->write_index + 1) % (delay)->line_count; \
+ } \
+ while (SANE_FALSE)
+
+
+static inline void
+unpack_8_mono (SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)
+{
+ for (; pixels_per_line > 0; ++src, ++dst, --pixels_per_line)
+ {
+ *dst = (((unsigned int) *src) << 8) | *src;
+ }
+}
+
+static inline void
+unpack_8_rgb (SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)
+{
+ for (; pixels_per_line > 0; src += 3, ++dst, --pixels_per_line)
+ {
+ *dst = (((unsigned int) *src) << 8) | *src;
+ }
+}
+
+/* 12-bit routines use the fact that pixels_per_line is aligned */
+
+static inline void
+unpack_12_le_mono (SANE_Byte * src, unsigned int *dst,
+ SANE_Int pixels_per_line)
+{
+ for (; pixels_per_line > 0; src += 3, dst += 2, pixels_per_line -= 2)
+ {
+ dst[0] = ((((unsigned int) (src[1] & 0x0f)) << 12)
+ | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
+ dst[1] = ((((unsigned int) src[2]) << 8)
+ | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
+ }
+}
+
+static inline void
+unpack_12_le_rgb (SANE_Byte * src,
+ unsigned int *dst1,
+ unsigned int *dst2,
+ unsigned int *dst3, SANE_Int pixels_per_line)
+{
+ for (; pixels_per_line > 0; pixels_per_line -= 2)
+ {
+ *dst1++ = ((((unsigned int) (src[1] & 0x0f)) << 12)
+ | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
+ *dst2++ = ((((unsigned int) src[2]) << 8)
+ | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
+ src += 3;
+
+ *dst3++ = ((((unsigned int) (src[1] & 0x0f)) << 12)
+ | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
+ *dst1++ = ((((unsigned int) src[2]) << 8)
+ | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
+ src += 3;
+
+ *dst2++ = ((((unsigned int) (src[1] & 0x0f)) << 12)
+ | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
+ *dst3++ = ((((unsigned int) src[2]) << 8)
+ | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
+ src += 3;
+ }
+}
+
+static inline void
+unpack_16_le_mono (SANE_Byte * src, unsigned int *dst,
+ SANE_Int pixels_per_line)
+{
+ for (; pixels_per_line > 0; src += 2, dst++, --pixels_per_line)
+ {
+ *dst = (((unsigned int) src[1]) << 8) | src[0];
+ }
+}
+
+static inline void
+unpack_16_le_rgb (SANE_Byte * src, unsigned int *dst,
+ SANE_Int pixels_per_line)
+{
+ for (; pixels_per_line > 0; src += 6, ++dst, --pixels_per_line)
+ {
+ *dst = (((unsigned int) src[1]) << 8) | src[0];
+ }
+}
+
+
+static SANE_Status
+line_read_gray_8 (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ unsigned int *buffer;
+
+ size = reader->params.scan_bpl;
+
+ RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
+
+ buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[0] = buffer;
+ unpack_8_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_gray_double_8 (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ unsigned int *buffer;
+ int i;
+
+ size = reader->params.scan_bpl;
+
+ RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
+ unpack_8_mono (reader->pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ reader->pixels_per_line);
+
+ buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+
+ for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
+ buffer[i] = DELAY_BUFFER_WRITE_PTR (&reader->g_delay)[i];
+
+ buffer_pointers_return[0] = buffer;
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_gray_12 (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ unsigned int *buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
+
+ buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[0] = buffer;
+ unpack_12_le_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_gray_double_12 (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ unsigned int *buffer;
+ int i;
+
+ size = reader->params.scan_bpl;
+
+ RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
+ unpack_12_le_mono (reader->pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ reader->pixels_per_line);
+
+ buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+
+ for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
+ buffer[i] = DELAY_BUFFER_WRITE_PTR (&reader->g_delay)[i];
+
+ buffer_pointers_return[0] = buffer;
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_gray_16 (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ unsigned int *buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
+
+ buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[0] = buffer;
+ unpack_16_le_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_gray_double_16 (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ unsigned int *buffer;
+ int i;
+
+ size = reader->params.scan_bpl;
+
+ RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
+ unpack_16_le_mono (reader->pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ reader->pixels_per_line);
+
+ buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+
+ for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
+ buffer[i] = DELAY_BUFFER_WRITE_PTR (&reader->g_delay)[i];
+
+ buffer_pointers_return[0] = buffer;
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ return SANE_STATUS_GOOD;
+
+}
+
+static SANE_Status
+line_read_rgb_8_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl * 3;
+
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_double_8_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+ int i;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
+ {
+ DELAY_BUFFER_READ_PTR (&reader->r_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->r_delay,
+ reader->params.ld_shift_double)[i];
+ DELAY_BUFFER_READ_PTR (&reader->g_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->g_delay,
+ reader->params.ld_shift_double)[i];
+ DELAY_BUFFER_READ_PTR (&reader->b_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->b_delay,
+ reader->params.ld_shift_double)[i];
+ }
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_bgr_8_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_8_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_12_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_double_12_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+ int i;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
+ {
+ DELAY_BUFFER_READ_PTR (&reader->r_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->r_delay,
+ reader->params.ld_shift_double)[i];
+ DELAY_BUFFER_READ_PTR (&reader->g_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->g_delay,
+ reader->params.ld_shift_double)[i];
+ DELAY_BUFFER_READ_PTR (&reader->b_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->b_delay,
+ reader->params.ld_shift_double)[i];
+ }
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_16_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_double_16_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+ int i;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
+ {
+ DELAY_BUFFER_READ_PTR (&reader->r_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->r_delay,
+ reader->params.ld_shift_double)[i];
+ DELAY_BUFFER_READ_PTR (&reader->g_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->g_delay,
+ reader->params.ld_shift_double)[i];
+ DELAY_BUFFER_READ_PTR (&reader->b_delay)[i] =
+ DELAY_BUFFER_SELECT_PTR (&reader->b_delay,
+ reader->params.ld_shift_double)[i];
+ }
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_bgr_12_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_12_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_bgr_16_line_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl * 3;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += reader->params.scan_bpl;
+ unpack_16_le_mono (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_8_pixel_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_8_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
+ ++pixel_buffer;
+ unpack_8_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
+ ++pixel_buffer;
+ unpack_8_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+line_read_rgb_12_pixel_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ unpack_12_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ reader->pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_rgb_16_pixel_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_16_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+ pixel_buffer += 2;
+ unpack_16_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += 2;
+ unpack_16_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_bgr_8_pixel_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_8_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
+ ++pixel_buffer;
+ unpack_8_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
+ ++pixel_buffer;
+ unpack_8_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+line_read_bgr_12_pixel_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ unpack_12_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ reader->pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+line_read_bgr_16_pixel_mode (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+ size_t size;
+ SANE_Int pixels_per_line;
+ SANE_Byte *pixel_buffer = reader->pixel_buffer;
+
+ size = reader->params.scan_bpl;
+ RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
+
+ pixels_per_line = reader->pixels_per_line;
+ unpack_16_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
+ pixels_per_line);
+ pixel_buffer += 2;
+ unpack_16_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
+ pixels_per_line);
+ pixel_buffer += 2;
+ unpack_16_le_rgb (pixel_buffer,
+ DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
+ pixels_per_line);
+
+ buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
+ buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
+ buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
+
+ DELAY_BUFFER_STEP (&reader->r_delay);
+ DELAY_BUFFER_STEP (&reader->g_delay);
+ DELAY_BUFFER_STEP (&reader->b_delay);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+gt68xx_line_reader_init_delays (GT68xx_Line_Reader * reader)
+{
+ SANE_Status status;
+
+ if (reader->params.color)
+ {
+ status = gt68xx_delay_buffer_init (&reader->r_delay,
+ reader->params.scan_xs,
+ reader->params.ld_shift_r +
+ reader->params.ld_shift_double);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ status = gt68xx_delay_buffer_init (&reader->g_delay,
+ reader->params.scan_xs,
+ reader->params.ld_shift_g +
+ reader->params.ld_shift_double);
+ if (status != SANE_STATUS_GOOD)
+ {
+ gt68xx_delay_buffer_done (&reader->r_delay);
+ return status;
+ }
+
+ status = gt68xx_delay_buffer_init (&reader->b_delay,
+ reader->params.scan_xs,
+ reader->params.ld_shift_b +
+ reader->params.ld_shift_double);
+ if (status != SANE_STATUS_GOOD)
+ {
+ gt68xx_delay_buffer_done (&reader->g_delay);
+ gt68xx_delay_buffer_done (&reader->r_delay);
+ return status;
+ }
+ }
+ else
+ {
+ status = gt68xx_delay_buffer_init (&reader->g_delay,
+ reader->params.scan_xs,
+ reader->params.ld_shift_double);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+ reader->delays_initialized = SANE_TRUE;
+
+ return SANE_STATUS_GOOD;
+}
+
+static void
+gt68xx_line_reader_free_delays (GT68xx_Line_Reader * reader)
+{
+ if (reader->delays_initialized)
+ {
+ if (reader->params.color)
+ {
+ gt68xx_delay_buffer_done (&reader->b_delay);
+ gt68xx_delay_buffer_done (&reader->g_delay);
+ gt68xx_delay_buffer_done (&reader->r_delay);
+ }
+ else
+ {
+ gt68xx_delay_buffer_done (&reader->g_delay);
+ }
+ reader->delays_initialized = SANE_FALSE;
+ }
+}
+
+SANE_Status
+gt68xx_line_reader_new (GT68xx_Device * dev,
+ GT68xx_Scan_Parameters * params,
+ SANE_Bool final_scan,
+ GT68xx_Line_Reader ** reader_return)
+{
+ SANE_Status status;
+ GT68xx_Line_Reader *reader;
+ SANE_Int image_size;
+ SANE_Int scan_bpl_full;
+
+ DBG (6, "gt68xx_line_reader_new: enter\n");
+
+ *reader_return = NULL;
+
+ reader = (GT68xx_Line_Reader *) malloc (sizeof (GT68xx_Line_Reader));
+ if (!reader)
+ {
+ DBG (3, "gt68xx_line_reader_new: cannot allocate GT68xx_Line_Reader\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ memset (reader, 0, sizeof (GT68xx_Line_Reader));
+
+ reader->dev = dev;
+ memcpy (&reader->params, params, sizeof (GT68xx_Scan_Parameters));
+ reader->pixel_buffer = 0;
+ reader->delays_initialized = SANE_FALSE;
+
+ reader->read = NULL;
+
+ status = gt68xx_line_reader_init_delays (reader);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (3, "gt68xx_line_reader_new: cannot allocate line buffers: %s\n",
+ sane_strstatus (status));
+ free (reader);
+ return status;
+ }
+
+ reader->pixels_per_line = reader->params.pixel_xs;
+
+ if (!reader->params.color)
+ {
+ if (reader->params.depth == 8)
+ {
+ if (reader->params.ld_shift_double > 0)
+ reader->read = line_read_gray_double_8;
+ else
+ reader->read = line_read_gray_8;
+ }
+ else if (reader->params.depth == 12)
+ {
+ if (reader->params.ld_shift_double > 0)
+ reader->read = line_read_gray_double_12;
+ else
+ reader->read = line_read_gray_12;
+ }
+ else if (reader->params.depth == 16)
+ {
+ if (reader->params.ld_shift_double > 0)
+ reader->read = line_read_gray_double_16;
+ else
+ reader->read = line_read_gray_16;
+ }
+ }
+ else if (reader->params.line_mode)
+ {
+ if (reader->params.depth == 8)
+ {
+ if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+ {
+ if (reader->params.ld_shift_double > 0)
+ reader->read = line_read_rgb_double_8_line_mode;
+ else
+ reader->read = line_read_rgb_8_line_mode;
+ }
+ else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+ reader->read = line_read_bgr_8_line_mode;
+ }
+ else if (reader->params.depth == 12)
+ {
+ if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+ {
+ if (reader->params.ld_shift_double > 0)
+ reader->read = line_read_rgb_double_12_line_mode;
+ else
+ reader->read = line_read_rgb_12_line_mode;
+ }
+ else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+ reader->read = line_read_bgr_12_line_mode;
+ }
+ else if (reader->params.depth == 16)
+ {
+ if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+ {
+ if (reader->params.ld_shift_double > 0)
+ reader->read = line_read_rgb_double_16_line_mode;
+ else
+ reader->read = line_read_rgb_16_line_mode;
+ }
+ else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+ reader->read = line_read_bgr_16_line_mode;
+ }
+ }
+ else
+ {
+ if (reader->params.depth == 8)
+ {
+ if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+ reader->read = line_read_rgb_8_pixel_mode;
+ else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+ reader->read = line_read_bgr_8_pixel_mode;
+ }
+ else if (reader->params.depth == 12)
+ {
+ if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+ reader->read = line_read_rgb_12_pixel_mode;
+ else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+ reader->read = line_read_bgr_12_pixel_mode;
+ }
+ else if (reader->params.depth == 16)
+ {
+ if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+ reader->read = line_read_rgb_16_pixel_mode;
+ else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+ reader->read = line_read_bgr_16_pixel_mode;
+ }
+ }
+
+ if (reader->read == NULL)
+ {
+ DBG (3, "gt68xx_line_reader_new: unsupported bit depth (%d)\n",
+ reader->params.depth);
+ gt68xx_line_reader_free_delays (reader);
+ free (reader);
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ scan_bpl_full = reader->params.scan_bpl;
+
+ if (reader->params.color && reader->params.line_mode)
+ scan_bpl_full *= 3;
+
+ reader->pixel_buffer = malloc (scan_bpl_full);
+ if (!reader->pixel_buffer)
+ {
+ DBG (3, "gt68xx_line_reader_new: cannot allocate pixel buffer\n");
+ gt68xx_line_reader_free_delays (reader);
+ free (reader);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ gt68xx_device_set_read_buffer_size (reader->dev,
+ scan_bpl_full /* * 200 */ );
+
+ image_size = reader->params.scan_bpl * reader->params.scan_ys;
+ status = gt68xx_device_read_prepare (reader->dev, image_size, final_scan);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (3,
+ "gt68xx_line_reader_new: gt68xx_device_read_prepare failed: %s\n",
+ sane_strstatus (status));
+ free (reader->pixel_buffer);
+ gt68xx_line_reader_free_delays (reader);
+ free (reader);
+ return status;
+ }
+
+ DBG (6, "gt68xx_line_reader_new: leave: ok\n");
+ *reader_return = reader;
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+gt68xx_line_reader_free (GT68xx_Line_Reader * reader)
+{
+ SANE_Status status;
+
+ DBG (6, "gt68xx_line_reader_free: enter\n");
+
+ gt68xx_line_reader_free_delays (reader);
+
+ if (reader->pixel_buffer)
+ {
+ free (reader->pixel_buffer);
+ reader->pixel_buffer = NULL;
+ }
+
+ status = gt68xx_device_read_finish (reader->dev);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (3,
+ "gt68xx_line_reader_free: gt68xx_device_read_finish failed: %s\n",
+ sane_strstatus (status));
+ }
+
+ free (reader);
+
+ DBG (6, "gt68xx_line_reader_free: leave\n");
+ return status;
+}
+
+SANE_Status
+gt68xx_line_reader_read (GT68xx_Line_Reader * reader,
+ unsigned int **buffer_pointers_return)
+{
+ SANE_Status status;
+
+ status = (*reader->read) (reader, buffer_pointers_return);
+ return status;
+}
+
+/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */