1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 2002 Sergey Vlasov <vsu@altlinux.ru>
4 Copyright (C) 2002-2007 Henning Geinitz <sane@geinitz.org>
5
6 This file is part of the SANE package.
7
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2 of the
11 License, or (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <https://www.gnu.org/licenses/>.
20
21 As a special exception, the authors of SANE give permission for
22 additional uses of the libraries contained in this release of SANE.
23
24 The exception is that, if you link a SANE library with other files
25 to produce an executable, this does not by itself cause the
26 resulting executable to be covered by the GNU General Public
27 License. Your use of that executable is in no way restricted on
28 account of linking the SANE library code into it.
29
30 This exception does not, however, invalidate any other reasons why
31 the executable file might be covered by the GNU General Public
32 License.
33
34 If you submit changes to SANE to the maintainers to be included in
35 a subsequent release, you agree by submitting the changes that
36 those changes may be distributed with this exception intact.
37
38 If you write modifications of your own for SANE, it is your choice
39 whether to permit this exception to apply to your modifications.
40 If you do not wish that, delete this exception notice.
41 */
42
43 #include "gt68xx_mid.h"
44 #include "gt68xx_low.c"
45
46 /** @file
47 * @brief Image data unpacking.
48 */
49
50 static SANE_Status
gt68xx_delay_buffer_init(GT68xx_Delay_Buffer * delay, SANE_Int pixels_per_line, SANE_Int delay_count)51 gt68xx_delay_buffer_init (GT68xx_Delay_Buffer * delay,
52 SANE_Int pixels_per_line, SANE_Int delay_count)
53 {
54 SANE_Int bytes_per_line;
55 SANE_Int line_count, i;
56
57 if (pixels_per_line <= 0)
58 {
59 DBG (3, "gt68xx_delay_buffer_init: BUG: pixels_per_line=%d\n",
60 pixels_per_line);
61 return SANE_STATUS_INVAL;
62 }
63
64 if (delay_count < 0)
65 {
66 DBG (3, "gt68xx_delay_buffer_init: BUG: delay_count=%d\n", delay_count);
67 return SANE_STATUS_INVAL;
68 }
69
70 bytes_per_line = pixels_per_line * sizeof (unsigned int);
71
72 delay->line_count = line_count = delay_count + 1;
73 delay->read_index = 0;
74 delay->write_index = delay_count;
75
76 delay->mem_block = (SANE_Byte *) malloc (bytes_per_line * line_count);
77 if (!delay->mem_block)
78 {
79 DBG (3, "gt68xx_delay_buffer_init: no memory for delay block\n");
80 return SANE_STATUS_NO_MEM;
81 }
82 /* make sure that we will see if one of the uninitialized lines get displayed */
83 for (i = 0; i < bytes_per_line * line_count; i++)
84 delay->mem_block[i] = i % 256;
85
86 delay->lines =
87 (unsigned int **) malloc (sizeof (unsigned int *) * line_count);
88 if (!delay->lines)
89 {
90 free (delay->mem_block);
91 DBG (3,
92 "gt68xx_delay_buffer_init: no memory for delay line pointers\n");
93 return SANE_STATUS_NO_MEM;
94 }
95
96 for (i = 0; i < line_count; ++i)
97 delay->lines[i] =
98 (unsigned int *) (delay->mem_block + i * bytes_per_line);
99
100 return SANE_STATUS_GOOD;
101 }
102
103 static SANE_Status
gt68xx_delay_buffer_done(GT68xx_Delay_Buffer * delay)104 gt68xx_delay_buffer_done (GT68xx_Delay_Buffer * delay)
105 {
106 if (delay->lines)
107 {
108 free (delay->lines);
109 delay->lines = NULL;
110 }
111
112 if (delay->mem_block)
113 {
114 free (delay->mem_block);
115 delay->mem_block = NULL;
116 }
117
118 return SANE_STATUS_GOOD;
119 }
120
121 #define DELAY_BUFFER_WRITE_PTR(delay) ( (delay)->lines[(delay)->write_index] )
122
123 #define DELAY_BUFFER_SELECT_PTR(delay,dist) \
124 ((delay)->lines[((delay)->read_index + (dist)) % (delay)->line_count])
125
126 #define DELAY_BUFFER_READ_PTR(delay) ( (delay)->lines[(delay)->read_index ] )
127
128 #define DELAY_BUFFER_STEP(delay) \
129 do \
130 { \
131 (delay)->read_index = ((delay)->read_index + 1) % (delay)->line_count; \
132 (delay)->write_index = ((delay)->write_index + 1) % (delay)->line_count; \
133 } \
134 while (SANE_FALSE)
135
136
137 static inline void
unpack_8_mono(SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)138 unpack_8_mono (SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)
139 {
140 for (; pixels_per_line > 0; ++src, ++dst, --pixels_per_line)
141 {
142 *dst = (((unsigned int) *src) << 8) | *src;
143 }
144 }
145
146 static inline void
unpack_8_rgb(SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)147 unpack_8_rgb (SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)
148 {
149 for (; pixels_per_line > 0; src += 3, ++dst, --pixels_per_line)
150 {
151 *dst = (((unsigned int) *src) << 8) | *src;
152 }
153 }
154
155 /* 12-bit routines use the fact that pixels_per_line is aligned */
156
157 static inline void
unpack_12_le_mono(SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)158 unpack_12_le_mono (SANE_Byte * src, unsigned int *dst,
159 SANE_Int pixels_per_line)
160 {
161 for (; pixels_per_line > 0; src += 3, dst += 2, pixels_per_line -= 2)
162 {
163 dst[0] = ((((unsigned int) (src[1] & 0x0f)) << 12)
164 | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
165 dst[1] = ((((unsigned int) src[2]) << 8)
166 | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
167 }
168 }
169
170 static inline void
unpack_12_le_rgb(SANE_Byte * src, unsigned int *dst1, unsigned int *dst2, unsigned int *dst3, SANE_Int pixels_per_line)171 unpack_12_le_rgb (SANE_Byte * src,
172 unsigned int *dst1,
173 unsigned int *dst2,
174 unsigned int *dst3, SANE_Int pixels_per_line)
175 {
176 for (; pixels_per_line > 0; pixels_per_line -= 2)
177 {
178 *dst1++ = ((((unsigned int) (src[1] & 0x0f)) << 12)
179 | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
180 *dst2++ = ((((unsigned int) src[2]) << 8)
181 | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
182 src += 3;
183
184 *dst3++ = ((((unsigned int) (src[1] & 0x0f)) << 12)
185 | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
186 *dst1++ = ((((unsigned int) src[2]) << 8)
187 | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
188 src += 3;
189
190 *dst2++ = ((((unsigned int) (src[1] & 0x0f)) << 12)
191 | (((unsigned int) src[0]) << 4) | (src[1] & 0x0f));
192 *dst3++ = ((((unsigned int) src[2]) << 8)
193 | (src[1] & 0xf0) | (((unsigned int) src[2]) >> 0x04));
194 src += 3;
195 }
196 }
197
198 static inline void
unpack_16_le_mono(SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)199 unpack_16_le_mono (SANE_Byte * src, unsigned int *dst,
200 SANE_Int pixels_per_line)
201 {
202 for (; pixels_per_line > 0; src += 2, dst++, --pixels_per_line)
203 {
204 *dst = (((unsigned int) src[1]) << 8) | src[0];
205 }
206 }
207
208 static inline void
unpack_16_le_rgb(SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)209 unpack_16_le_rgb (SANE_Byte * src, unsigned int *dst,
210 SANE_Int pixels_per_line)
211 {
212 for (; pixels_per_line > 0; src += 6, ++dst, --pixels_per_line)
213 {
214 *dst = (((unsigned int) src[1]) << 8) | src[0];
215 }
216 }
217
218
219 static SANE_Status
line_read_gray_8(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)220 line_read_gray_8 (GT68xx_Line_Reader * reader,
221 unsigned int **buffer_pointers_return)
222 {
223 SANE_Status status;
224 size_t size;
225 unsigned int *buffer;
226
227 size = reader->params.scan_bpl;
228
229 RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
230
231 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
232 buffer_pointers_return[0] = buffer;
233 unpack_8_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
234
235 return SANE_STATUS_GOOD;
236 }
237
238 static SANE_Status
line_read_gray_double_8(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)239 line_read_gray_double_8 (GT68xx_Line_Reader * reader,
240 unsigned int **buffer_pointers_return)
241 {
242 SANE_Status status;
243 size_t size;
244 unsigned int *buffer;
245 int i;
246
247 size = reader->params.scan_bpl;
248
249 RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
250 unpack_8_mono (reader->pixel_buffer,
251 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
252 reader->pixels_per_line);
253
254 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
255
256 for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
257 buffer[i] = DELAY_BUFFER_WRITE_PTR (&reader->g_delay)[i];
258
259 buffer_pointers_return[0] = buffer;
260 DELAY_BUFFER_STEP (&reader->g_delay);
261 return SANE_STATUS_GOOD;
262 }
263
264 static SANE_Status
line_read_gray_12(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)265 line_read_gray_12 (GT68xx_Line_Reader * reader,
266 unsigned int **buffer_pointers_return)
267 {
268 SANE_Status status;
269 size_t size;
270 unsigned int *buffer;
271
272 size = reader->params.scan_bpl;
273 RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
274
275 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
276 buffer_pointers_return[0] = buffer;
277 unpack_12_le_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
278
279 return SANE_STATUS_GOOD;
280 }
281
282 static SANE_Status
line_read_gray_double_12(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)283 line_read_gray_double_12 (GT68xx_Line_Reader * reader,
284 unsigned int **buffer_pointers_return)
285 {
286 SANE_Status status;
287 size_t size;
288 unsigned int *buffer;
289 int i;
290
291 size = reader->params.scan_bpl;
292
293 RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
294 unpack_12_le_mono (reader->pixel_buffer,
295 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
296 reader->pixels_per_line);
297
298 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
299
300 for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
301 buffer[i] = DELAY_BUFFER_WRITE_PTR (&reader->g_delay)[i];
302
303 buffer_pointers_return[0] = buffer;
304 DELAY_BUFFER_STEP (&reader->g_delay);
305 return SANE_STATUS_GOOD;
306 }
307
308 static SANE_Status
line_read_gray_16(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)309 line_read_gray_16 (GT68xx_Line_Reader * reader,
310 unsigned int **buffer_pointers_return)
311 {
312 SANE_Status status;
313 size_t size;
314 unsigned int *buffer;
315
316 size = reader->params.scan_bpl;
317 RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
318
319 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
320 buffer_pointers_return[0] = buffer;
321 unpack_16_le_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
322
323 return SANE_STATUS_GOOD;
324 }
325
326 static SANE_Status
line_read_gray_double_16(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)327 line_read_gray_double_16 (GT68xx_Line_Reader * reader,
328 unsigned int **buffer_pointers_return)
329 {
330 SANE_Status status;
331 size_t size;
332 unsigned int *buffer;
333 int i;
334
335 size = reader->params.scan_bpl;
336
337 RIE (gt68xx_device_read (reader->dev, reader->pixel_buffer, &size));
338 unpack_16_le_mono (reader->pixel_buffer,
339 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
340 reader->pixels_per_line);
341
342 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
343
344 for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
345 buffer[i] = DELAY_BUFFER_WRITE_PTR (&reader->g_delay)[i];
346
347 buffer_pointers_return[0] = buffer;
348 DELAY_BUFFER_STEP (&reader->g_delay);
349 return SANE_STATUS_GOOD;
350
351 }
352
353 static SANE_Status
line_read_rgb_8_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)354 line_read_rgb_8_line_mode (GT68xx_Line_Reader * reader,
355 unsigned int **buffer_pointers_return)
356 {
357 SANE_Status status;
358 size_t size;
359 SANE_Int pixels_per_line;
360 SANE_Byte *pixel_buffer = reader->pixel_buffer;
361
362 size = reader->params.scan_bpl * 3;
363
364 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
365
366 pixels_per_line = reader->pixels_per_line;
367 unpack_8_mono (pixel_buffer,
368 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
369 pixel_buffer += reader->params.scan_bpl;
370 unpack_8_mono (pixel_buffer,
371 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
372 pixel_buffer += reader->params.scan_bpl;
373 unpack_8_mono (pixel_buffer,
374 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
375
376 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
377 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
378 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
379
380 DELAY_BUFFER_STEP (&reader->r_delay);
381 DELAY_BUFFER_STEP (&reader->g_delay);
382 DELAY_BUFFER_STEP (&reader->b_delay);
383
384 return SANE_STATUS_GOOD;
385 }
386
387 static SANE_Status
line_read_rgb_double_8_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)388 line_read_rgb_double_8_line_mode (GT68xx_Line_Reader * reader,
389 unsigned int **buffer_pointers_return)
390 {
391 SANE_Status status;
392 size_t size;
393 SANE_Int pixels_per_line;
394 SANE_Byte *pixel_buffer = reader->pixel_buffer;
395 int i;
396
397 size = reader->params.scan_bpl * 3;
398 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
399
400 pixels_per_line = reader->pixels_per_line;
401 unpack_8_mono (pixel_buffer,
402 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
403 pixel_buffer += reader->params.scan_bpl;
404 unpack_8_mono (pixel_buffer,
405 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
406 pixel_buffer += reader->params.scan_bpl;
407 unpack_8_mono (pixel_buffer,
408 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
409
410 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
411 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
412 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
413
414 for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
415 {
416 DELAY_BUFFER_READ_PTR (&reader->r_delay)[i] =
417 DELAY_BUFFER_SELECT_PTR (&reader->r_delay,
418 reader->params.ld_shift_double)[i];
419 DELAY_BUFFER_READ_PTR (&reader->g_delay)[i] =
420 DELAY_BUFFER_SELECT_PTR (&reader->g_delay,
421 reader->params.ld_shift_double)[i];
422 DELAY_BUFFER_READ_PTR (&reader->b_delay)[i] =
423 DELAY_BUFFER_SELECT_PTR (&reader->b_delay,
424 reader->params.ld_shift_double)[i];
425 }
426 DELAY_BUFFER_STEP (&reader->r_delay);
427 DELAY_BUFFER_STEP (&reader->g_delay);
428 DELAY_BUFFER_STEP (&reader->b_delay);
429
430 return SANE_STATUS_GOOD;
431 }
432
433 static SANE_Status
line_read_bgr_8_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)434 line_read_bgr_8_line_mode (GT68xx_Line_Reader * reader,
435 unsigned int **buffer_pointers_return)
436 {
437 SANE_Status status;
438 size_t size;
439 SANE_Int pixels_per_line;
440 SANE_Byte *pixel_buffer = reader->pixel_buffer;
441
442 size = reader->params.scan_bpl * 3;
443 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
444
445 pixels_per_line = reader->pixels_per_line;
446 unpack_8_mono (pixel_buffer,
447 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
448 pixel_buffer += reader->params.scan_bpl;
449 unpack_8_mono (pixel_buffer,
450 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
451 pixel_buffer += reader->params.scan_bpl;
452 unpack_8_mono (pixel_buffer,
453 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
454
455 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
456 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
457 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
458
459 DELAY_BUFFER_STEP (&reader->r_delay);
460 DELAY_BUFFER_STEP (&reader->g_delay);
461 DELAY_BUFFER_STEP (&reader->b_delay);
462
463 return SANE_STATUS_GOOD;
464 }
465
466 static SANE_Status
line_read_rgb_12_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)467 line_read_rgb_12_line_mode (GT68xx_Line_Reader * reader,
468 unsigned int **buffer_pointers_return)
469 {
470 SANE_Status status;
471 size_t size;
472 SANE_Int pixels_per_line;
473 SANE_Byte *pixel_buffer = reader->pixel_buffer;
474
475 size = reader->params.scan_bpl * 3;
476 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
477
478 pixels_per_line = reader->pixels_per_line;
479 unpack_12_le_mono (pixel_buffer,
480 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
481 pixels_per_line);
482 pixel_buffer += reader->params.scan_bpl;
483 unpack_12_le_mono (pixel_buffer,
484 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
485 pixels_per_line);
486 pixel_buffer += reader->params.scan_bpl;
487 unpack_12_le_mono (pixel_buffer,
488 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
489 pixels_per_line);
490
491 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
492 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
493 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
494
495 DELAY_BUFFER_STEP (&reader->r_delay);
496 DELAY_BUFFER_STEP (&reader->g_delay);
497 DELAY_BUFFER_STEP (&reader->b_delay);
498
499 return SANE_STATUS_GOOD;
500 }
501
502 static SANE_Status
line_read_rgb_double_12_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)503 line_read_rgb_double_12_line_mode (GT68xx_Line_Reader * reader,
504 unsigned int **buffer_pointers_return)
505 {
506 SANE_Status status;
507 size_t size;
508 SANE_Int pixels_per_line;
509 SANE_Byte *pixel_buffer = reader->pixel_buffer;
510 int i;
511
512 size = reader->params.scan_bpl * 3;
513 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
514
515 pixels_per_line = reader->pixels_per_line;
516 unpack_12_le_mono (pixel_buffer,
517 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
518 pixels_per_line);
519 pixel_buffer += reader->params.scan_bpl;
520 unpack_12_le_mono (pixel_buffer,
521 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
522 pixels_per_line);
523 pixel_buffer += reader->params.scan_bpl;
524 unpack_12_le_mono (pixel_buffer,
525 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
526 pixels_per_line);
527
528 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
529 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
530 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
531
532 for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
533 {
534 DELAY_BUFFER_READ_PTR (&reader->r_delay)[i] =
535 DELAY_BUFFER_SELECT_PTR (&reader->r_delay,
536 reader->params.ld_shift_double)[i];
537 DELAY_BUFFER_READ_PTR (&reader->g_delay)[i] =
538 DELAY_BUFFER_SELECT_PTR (&reader->g_delay,
539 reader->params.ld_shift_double)[i];
540 DELAY_BUFFER_READ_PTR (&reader->b_delay)[i] =
541 DELAY_BUFFER_SELECT_PTR (&reader->b_delay,
542 reader->params.ld_shift_double)[i];
543 }
544 DELAY_BUFFER_STEP (&reader->r_delay);
545 DELAY_BUFFER_STEP (&reader->g_delay);
546 DELAY_BUFFER_STEP (&reader->b_delay);
547
548 return SANE_STATUS_GOOD;
549 }
550
551 static SANE_Status
line_read_rgb_16_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)552 line_read_rgb_16_line_mode (GT68xx_Line_Reader * reader,
553 unsigned int **buffer_pointers_return)
554 {
555 SANE_Status status;
556 size_t size;
557 SANE_Int pixels_per_line;
558 SANE_Byte *pixel_buffer = reader->pixel_buffer;
559
560 size = reader->params.scan_bpl * 3;
561 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
562
563 pixels_per_line = reader->pixels_per_line;
564 unpack_16_le_mono (pixel_buffer,
565 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
566 pixels_per_line);
567 pixel_buffer += reader->params.scan_bpl;
568 unpack_16_le_mono (pixel_buffer,
569 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
570 pixels_per_line);
571 pixel_buffer += reader->params.scan_bpl;
572 unpack_16_le_mono (pixel_buffer,
573 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
574 pixels_per_line);
575
576 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
577 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
578 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
579
580 DELAY_BUFFER_STEP (&reader->r_delay);
581 DELAY_BUFFER_STEP (&reader->g_delay);
582 DELAY_BUFFER_STEP (&reader->b_delay);
583
584 return SANE_STATUS_GOOD;
585 }
586
587 static SANE_Status
line_read_rgb_double_16_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)588 line_read_rgb_double_16_line_mode (GT68xx_Line_Reader * reader,
589 unsigned int **buffer_pointers_return)
590 {
591 SANE_Status status;
592 size_t size;
593 SANE_Int pixels_per_line;
594 SANE_Byte *pixel_buffer = reader->pixel_buffer;
595 int i;
596
597 size = reader->params.scan_bpl * 3;
598 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
599
600 pixels_per_line = reader->pixels_per_line;
601 unpack_16_le_mono (pixel_buffer,
602 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
603 pixels_per_line);
604 pixel_buffer += reader->params.scan_bpl;
605 unpack_16_le_mono (pixel_buffer,
606 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
607 pixels_per_line);
608 pixel_buffer += reader->params.scan_bpl;
609 unpack_16_le_mono (pixel_buffer,
610 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
611 pixels_per_line);
612
613 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
614 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
615 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
616
617 for (i = reader->params.double_column; i < reader->pixels_per_line; i += 2)
618 {
619 DELAY_BUFFER_READ_PTR (&reader->r_delay)[i] =
620 DELAY_BUFFER_SELECT_PTR (&reader->r_delay,
621 reader->params.ld_shift_double)[i];
622 DELAY_BUFFER_READ_PTR (&reader->g_delay)[i] =
623 DELAY_BUFFER_SELECT_PTR (&reader->g_delay,
624 reader->params.ld_shift_double)[i];
625 DELAY_BUFFER_READ_PTR (&reader->b_delay)[i] =
626 DELAY_BUFFER_SELECT_PTR (&reader->b_delay,
627 reader->params.ld_shift_double)[i];
628 }
629 DELAY_BUFFER_STEP (&reader->r_delay);
630 DELAY_BUFFER_STEP (&reader->g_delay);
631 DELAY_BUFFER_STEP (&reader->b_delay);
632
633 return SANE_STATUS_GOOD;
634 }
635
636 static SANE_Status
line_read_bgr_12_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)637 line_read_bgr_12_line_mode (GT68xx_Line_Reader * reader,
638 unsigned int **buffer_pointers_return)
639 {
640 SANE_Status status;
641 size_t size;
642 SANE_Int pixels_per_line;
643 SANE_Byte *pixel_buffer = reader->pixel_buffer;
644
645 size = reader->params.scan_bpl * 3;
646 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
647
648 pixels_per_line = reader->pixels_per_line;
649 unpack_12_le_mono (pixel_buffer,
650 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
651 pixels_per_line);
652 pixel_buffer += reader->params.scan_bpl;
653 unpack_12_le_mono (pixel_buffer,
654 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
655 pixels_per_line);
656 pixel_buffer += reader->params.scan_bpl;
657 unpack_12_le_mono (pixel_buffer,
658 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
659 pixels_per_line);
660
661 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
662 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
663 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
664
665 DELAY_BUFFER_STEP (&reader->r_delay);
666 DELAY_BUFFER_STEP (&reader->g_delay);
667 DELAY_BUFFER_STEP (&reader->b_delay);
668
669 return SANE_STATUS_GOOD;
670 }
671
672 static SANE_Status
line_read_bgr_16_line_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)673 line_read_bgr_16_line_mode (GT68xx_Line_Reader * reader,
674 unsigned int **buffer_pointers_return)
675 {
676 SANE_Status status;
677 size_t size;
678 SANE_Int pixels_per_line;
679 SANE_Byte *pixel_buffer = reader->pixel_buffer;
680
681 size = reader->params.scan_bpl * 3;
682 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
683
684 pixels_per_line = reader->pixels_per_line;
685 unpack_16_le_mono (pixel_buffer,
686 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
687 pixels_per_line);
688 pixel_buffer += reader->params.scan_bpl;
689 unpack_16_le_mono (pixel_buffer,
690 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
691 pixels_per_line);
692 pixel_buffer += reader->params.scan_bpl;
693 unpack_16_le_mono (pixel_buffer,
694 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
695 pixels_per_line);
696
697 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
698 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
699 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
700
701 DELAY_BUFFER_STEP (&reader->r_delay);
702 DELAY_BUFFER_STEP (&reader->g_delay);
703 DELAY_BUFFER_STEP (&reader->b_delay);
704
705 return SANE_STATUS_GOOD;
706 }
707
708 static SANE_Status
line_read_rgb_8_pixel_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)709 line_read_rgb_8_pixel_mode (GT68xx_Line_Reader * reader,
710 unsigned int **buffer_pointers_return)
711 {
712 SANE_Status status;
713 size_t size;
714 SANE_Int pixels_per_line;
715 SANE_Byte *pixel_buffer = reader->pixel_buffer;
716
717 size = reader->params.scan_bpl;
718 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
719
720 pixels_per_line = reader->pixels_per_line;
721 unpack_8_rgb (pixel_buffer,
722 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
723 ++pixel_buffer;
724 unpack_8_rgb (pixel_buffer,
725 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
726 ++pixel_buffer;
727 unpack_8_rgb (pixel_buffer,
728 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
729
730 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
731 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
732 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
733
734 DELAY_BUFFER_STEP (&reader->r_delay);
735 DELAY_BUFFER_STEP (&reader->g_delay);
736 DELAY_BUFFER_STEP (&reader->b_delay);
737
738 return SANE_STATUS_GOOD;
739 }
740
741
742 static SANE_Status
line_read_rgb_12_pixel_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)743 line_read_rgb_12_pixel_mode (GT68xx_Line_Reader * reader,
744 unsigned int **buffer_pointers_return)
745 {
746 SANE_Status status;
747 size_t size;
748 SANE_Byte *pixel_buffer = reader->pixel_buffer;
749
750 size = reader->params.scan_bpl;
751 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
752
753 unpack_12_le_rgb (pixel_buffer,
754 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
755 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
756 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
757 reader->pixels_per_line);
758
759 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
760 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
761 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
762
763 DELAY_BUFFER_STEP (&reader->r_delay);
764 DELAY_BUFFER_STEP (&reader->g_delay);
765 DELAY_BUFFER_STEP (&reader->b_delay);
766
767 return SANE_STATUS_GOOD;
768 }
769
770 static SANE_Status
line_read_rgb_16_pixel_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)771 line_read_rgb_16_pixel_mode (GT68xx_Line_Reader * reader,
772 unsigned int **buffer_pointers_return)
773 {
774 SANE_Status status;
775 size_t size;
776 SANE_Int pixels_per_line;
777 SANE_Byte *pixel_buffer = reader->pixel_buffer;
778
779 size = reader->params.scan_bpl;
780 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
781
782 pixels_per_line = reader->pixels_per_line;
783 unpack_16_le_rgb (pixel_buffer,
784 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
785 pixels_per_line);
786 pixel_buffer += 2;
787 unpack_16_le_rgb (pixel_buffer,
788 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
789 pixels_per_line);
790 pixel_buffer += 2;
791 unpack_16_le_rgb (pixel_buffer,
792 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
793 pixels_per_line);
794
795 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
796 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
797 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
798
799 DELAY_BUFFER_STEP (&reader->r_delay);
800 DELAY_BUFFER_STEP (&reader->g_delay);
801 DELAY_BUFFER_STEP (&reader->b_delay);
802
803 return SANE_STATUS_GOOD;
804 }
805
806 static SANE_Status
line_read_bgr_8_pixel_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)807 line_read_bgr_8_pixel_mode (GT68xx_Line_Reader * reader,
808 unsigned int **buffer_pointers_return)
809 {
810 SANE_Status status;
811 size_t size;
812 SANE_Int pixels_per_line;
813 SANE_Byte *pixel_buffer = reader->pixel_buffer;
814
815 size = reader->params.scan_bpl;
816 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
817
818 pixels_per_line = reader->pixels_per_line;
819 unpack_8_rgb (pixel_buffer,
820 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
821 ++pixel_buffer;
822 unpack_8_rgb (pixel_buffer,
823 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
824 ++pixel_buffer;
825 unpack_8_rgb (pixel_buffer,
826 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
827
828 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
829 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
830 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
831
832 DELAY_BUFFER_STEP (&reader->r_delay);
833 DELAY_BUFFER_STEP (&reader->g_delay);
834 DELAY_BUFFER_STEP (&reader->b_delay);
835
836 return SANE_STATUS_GOOD;
837 }
838
839
840 static SANE_Status
line_read_bgr_12_pixel_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)841 line_read_bgr_12_pixel_mode (GT68xx_Line_Reader * reader,
842 unsigned int **buffer_pointers_return)
843 {
844 SANE_Status status;
845 size_t size;
846 SANE_Byte *pixel_buffer = reader->pixel_buffer;
847
848 size = reader->params.scan_bpl;
849 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
850
851 unpack_12_le_rgb (pixel_buffer,
852 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
853 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
854 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
855 reader->pixels_per_line);
856
857 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
858 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
859 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
860
861 DELAY_BUFFER_STEP (&reader->r_delay);
862 DELAY_BUFFER_STEP (&reader->g_delay);
863 DELAY_BUFFER_STEP (&reader->b_delay);
864
865 return SANE_STATUS_GOOD;
866 }
867
868 static SANE_Status
line_read_bgr_16_pixel_mode(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)869 line_read_bgr_16_pixel_mode (GT68xx_Line_Reader * reader,
870 unsigned int **buffer_pointers_return)
871 {
872 SANE_Status status;
873 size_t size;
874 SANE_Int pixels_per_line;
875 SANE_Byte *pixel_buffer = reader->pixel_buffer;
876
877 size = reader->params.scan_bpl;
878 RIE (gt68xx_device_read (reader->dev, pixel_buffer, &size));
879
880 pixels_per_line = reader->pixels_per_line;
881 unpack_16_le_rgb (pixel_buffer,
882 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
883 pixels_per_line);
884 pixel_buffer += 2;
885 unpack_16_le_rgb (pixel_buffer,
886 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
887 pixels_per_line);
888 pixel_buffer += 2;
889 unpack_16_le_rgb (pixel_buffer,
890 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
891 pixels_per_line);
892
893 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
894 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
895 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
896
897 DELAY_BUFFER_STEP (&reader->r_delay);
898 DELAY_BUFFER_STEP (&reader->g_delay);
899 DELAY_BUFFER_STEP (&reader->b_delay);
900
901 return SANE_STATUS_GOOD;
902 }
903
904 static SANE_Status
gt68xx_line_reader_init_delays(GT68xx_Line_Reader * reader)905 gt68xx_line_reader_init_delays (GT68xx_Line_Reader * reader)
906 {
907 SANE_Status status;
908
909 if (reader->params.color)
910 {
911 status = gt68xx_delay_buffer_init (&reader->r_delay,
912 reader->params.scan_xs,
913 reader->params.ld_shift_r +
914 reader->params.ld_shift_double);
915 if (status != SANE_STATUS_GOOD)
916 return status;
917
918 status = gt68xx_delay_buffer_init (&reader->g_delay,
919 reader->params.scan_xs,
920 reader->params.ld_shift_g +
921 reader->params.ld_shift_double);
922 if (status != SANE_STATUS_GOOD)
923 {
924 gt68xx_delay_buffer_done (&reader->r_delay);
925 return status;
926 }
927
928 status = gt68xx_delay_buffer_init (&reader->b_delay,
929 reader->params.scan_xs,
930 reader->params.ld_shift_b +
931 reader->params.ld_shift_double);
932 if (status != SANE_STATUS_GOOD)
933 {
934 gt68xx_delay_buffer_done (&reader->g_delay);
935 gt68xx_delay_buffer_done (&reader->r_delay);
936 return status;
937 }
938 }
939 else
940 {
941 status = gt68xx_delay_buffer_init (&reader->g_delay,
942 reader->params.scan_xs,
943 reader->params.ld_shift_double);
944 if (status != SANE_STATUS_GOOD)
945 return status;
946 }
947 reader->delays_initialized = SANE_TRUE;
948
949 return SANE_STATUS_GOOD;
950 }
951
952 static void
gt68xx_line_reader_free_delays(GT68xx_Line_Reader * reader)953 gt68xx_line_reader_free_delays (GT68xx_Line_Reader * reader)
954 {
955 if (reader->delays_initialized)
956 {
957 if (reader->params.color)
958 {
959 gt68xx_delay_buffer_done (&reader->b_delay);
960 gt68xx_delay_buffer_done (&reader->g_delay);
961 gt68xx_delay_buffer_done (&reader->r_delay);
962 }
963 else
964 {
965 gt68xx_delay_buffer_done (&reader->g_delay);
966 }
967 reader->delays_initialized = SANE_FALSE;
968 }
969 }
970
971 SANE_Status
gt68xx_line_reader_new(GT68xx_Device * dev, GT68xx_Scan_Parameters * params, SANE_Bool final_scan, GT68xx_Line_Reader ** reader_return)972 gt68xx_line_reader_new (GT68xx_Device * dev,
973 GT68xx_Scan_Parameters * params,
974 SANE_Bool final_scan,
975 GT68xx_Line_Reader ** reader_return)
976 {
977 SANE_Status status;
978 GT68xx_Line_Reader *reader;
979 SANE_Int image_size;
980 SANE_Int scan_bpl_full;
981
982 DBG (6, "gt68xx_line_reader_new: enter\n");
983
984 *reader_return = NULL;
985
986 reader = (GT68xx_Line_Reader *) malloc (sizeof (GT68xx_Line_Reader));
987 if (!reader)
988 {
989 DBG (3, "gt68xx_line_reader_new: cannot allocate GT68xx_Line_Reader\n");
990 return SANE_STATUS_NO_MEM;
991 }
992 memset (reader, 0, sizeof (GT68xx_Line_Reader));
993
994 reader->dev = dev;
995 memcpy (&reader->params, params, sizeof (GT68xx_Scan_Parameters));
996 reader->pixel_buffer = 0;
997 reader->delays_initialized = SANE_FALSE;
998
999 reader->read = NULL;
1000
1001 status = gt68xx_line_reader_init_delays (reader);
1002 if (status != SANE_STATUS_GOOD)
1003 {
1004 DBG (3, "gt68xx_line_reader_new: cannot allocate line buffers: %s\n",
1005 sane_strstatus (status));
1006 free (reader);
1007 reader = NULL;
1008 return status;
1009 }
1010
1011 reader->pixels_per_line = reader->params.pixel_xs;
1012
1013 if (!reader->params.color)
1014 {
1015 if (reader->params.depth == 8)
1016 {
1017 if (reader->params.ld_shift_double > 0)
1018 reader->read = line_read_gray_double_8;
1019 else
1020 reader->read = line_read_gray_8;
1021 }
1022 else if (reader->params.depth == 12)
1023 {
1024 if (reader->params.ld_shift_double > 0)
1025 reader->read = line_read_gray_double_12;
1026 else
1027 reader->read = line_read_gray_12;
1028 }
1029 else if (reader->params.depth == 16)
1030 {
1031 if (reader->params.ld_shift_double > 0)
1032 reader->read = line_read_gray_double_16;
1033 else
1034 reader->read = line_read_gray_16;
1035 }
1036 }
1037 else if (reader->params.line_mode)
1038 {
1039 if (reader->params.depth == 8)
1040 {
1041 if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
1042 {
1043 if (reader->params.ld_shift_double > 0)
1044 reader->read = line_read_rgb_double_8_line_mode;
1045 else
1046 reader->read = line_read_rgb_8_line_mode;
1047 }
1048 else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
1049 reader->read = line_read_bgr_8_line_mode;
1050 }
1051 else if (reader->params.depth == 12)
1052 {
1053 if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
1054 {
1055 if (reader->params.ld_shift_double > 0)
1056 reader->read = line_read_rgb_double_12_line_mode;
1057 else
1058 reader->read = line_read_rgb_12_line_mode;
1059 }
1060 else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
1061 reader->read = line_read_bgr_12_line_mode;
1062 }
1063 else if (reader->params.depth == 16)
1064 {
1065 if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
1066 {
1067 if (reader->params.ld_shift_double > 0)
1068 reader->read = line_read_rgb_double_16_line_mode;
1069 else
1070 reader->read = line_read_rgb_16_line_mode;
1071 }
1072 else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
1073 reader->read = line_read_bgr_16_line_mode;
1074 }
1075 }
1076 else
1077 {
1078 if (reader->params.depth == 8)
1079 {
1080 if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
1081 reader->read = line_read_rgb_8_pixel_mode;
1082 else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
1083 reader->read = line_read_bgr_8_pixel_mode;
1084 }
1085 else if (reader->params.depth == 12)
1086 {
1087 if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
1088 reader->read = line_read_rgb_12_pixel_mode;
1089 else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
1090 reader->read = line_read_bgr_12_pixel_mode;
1091 }
1092 else if (reader->params.depth == 16)
1093 {
1094 if (dev->model->line_mode_color_order == COLOR_ORDER_RGB)
1095 reader->read = line_read_rgb_16_pixel_mode;
1096 else if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
1097 reader->read = line_read_bgr_16_pixel_mode;
1098 }
1099 }
1100
1101 if (reader->read == NULL)
1102 {
1103 DBG (3, "gt68xx_line_reader_new: unsupported bit depth (%d)\n",
1104 reader->params.depth);
1105 gt68xx_line_reader_free_delays (reader);
1106 free (reader);
1107 reader = NULL;
1108 return SANE_STATUS_UNSUPPORTED;
1109 }
1110
1111 scan_bpl_full = reader->params.scan_bpl;
1112
1113 if (reader->params.color && reader->params.line_mode)
1114 scan_bpl_full *= 3;
1115
1116 reader->pixel_buffer = malloc (scan_bpl_full);
1117 if (!reader->pixel_buffer)
1118 {
1119 DBG (3, "gt68xx_line_reader_new: cannot allocate pixel buffer\n");
1120 gt68xx_line_reader_free_delays (reader);
1121 free (reader);
1122 reader = NULL;
1123 return SANE_STATUS_NO_MEM;
1124 }
1125
1126 gt68xx_device_set_read_buffer_size (reader->dev,
1127 scan_bpl_full /* * 200 */ );
1128
1129 image_size = reader->params.scan_bpl * reader->params.scan_ys;
1130 status = gt68xx_device_read_prepare (reader->dev, image_size, final_scan);
1131 if (status != SANE_STATUS_GOOD)
1132 {
1133 DBG (3,
1134 "gt68xx_line_reader_new: gt68xx_device_read_prepare failed: %s\n",
1135 sane_strstatus (status));
1136 free (reader->pixel_buffer);
1137 gt68xx_line_reader_free_delays (reader);
1138 free (reader);
1139 reader = NULL;
1140 return status;
1141 }
1142
1143 DBG (6, "gt68xx_line_reader_new: leave: ok\n");
1144 *reader_return = reader;
1145 return SANE_STATUS_GOOD;
1146 }
1147
1148 SANE_Status
gt68xx_line_reader_free(GT68xx_Line_Reader * reader)1149 gt68xx_line_reader_free (GT68xx_Line_Reader * reader)
1150 {
1151 SANE_Status status;
1152
1153 DBG (6, "gt68xx_line_reader_free: enter\n");
1154
1155 if (reader == NULL)
1156 {
1157 DBG (3, "gt68xx_line_reader_free: already freed\n");
1158 DBG (6, "gt68xx_line_reader_free: leave\n");
1159 return SANE_STATUS_INVAL;
1160 }
1161
1162 gt68xx_line_reader_free_delays (reader);
1163
1164 if (reader->pixel_buffer)
1165 {
1166 free (reader->pixel_buffer);
1167 reader->pixel_buffer = NULL;
1168 }
1169
1170 status = gt68xx_device_read_finish (reader->dev);
1171 if (status != SANE_STATUS_GOOD)
1172 {
1173 DBG (3,
1174 "gt68xx_line_reader_free: gt68xx_device_read_finish failed: %s\n",
1175 sane_strstatus (status));
1176 }
1177
1178 free (reader);
1179 reader = NULL;
1180
1181 DBG (6, "gt68xx_line_reader_free: leave\n");
1182 return status;
1183 }
1184
1185 SANE_Status
gt68xx_line_reader_read(GT68xx_Line_Reader * reader, unsigned int **buffer_pointers_return)1186 gt68xx_line_reader_read (GT68xx_Line_Reader * reader,
1187 unsigned int **buffer_pointers_return)
1188 {
1189 SANE_Status status;
1190
1191 status = (*reader->read) (reader, buffer_pointers_return);
1192 return status;
1193 }
1194
1195 /* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
1196