1 /* sane - Scanner Access Now Easy.
2 Copyright (C) 2002 Michael Herder <crapsite@gmx.net>
3
4 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6 This backend is based on the "gt68xxtest" program written by the following
7 persons:
8 Sergey Vlasov <vsu@mivlgu.murom.ru>
9 - Main backend code.
10
11 Andreas Nowack <nowack.andreas@gmx.de>
12 - Support for GT6801 (Mustek ScanExpress 1200 UB Plus).
13
14 David Stevenson <david.stevenson@zoom.co.uk>
15 - Automatic AFE gain and offset setting.
16 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 Please note:
18 The calibration code from the gt68xxtest program isn't used here, since I
19 couldn't get it working. I'm using my own calibration code, which is based
20 on wild assumptions based on the USB logs from the windoze driver.
21 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
22 It also contains code from the plustek backend
23
24 Copyright (C) 2000-2002 Gerhard Jaeger <g.jaeger@earthling.net>
25
26 and from the mustek_usb backend
27
28 Copyright (C) 2000 Mustek.
29 Maintained by Tom Wang <tom.wang@mustek.com.tw>
30 Updates (C) 2001 by Henning Meier-Geinitz.
31 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
32 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License as
36 published by the Free Software Foundation; either version 2 of the
37 License, or (at your option) any later version.
38
39 This program is distributed in the hope that it will be useful, but
40 WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
42 General Public License for more details.
43
44 You should have received a copy of the GNU General Public License
45 along with this program. If not, see <https://www.gnu.org/licenses/>.
46
47 As a special exception, the authors of SANE give permission for
48 additional uses of the libraries contained in this release of SANE.
49
50 The exception is that, if you link a SANE library with other files
51 to produce an executable, this does not by itself cause the
52 resulting executable to be covered by the GNU General Public
53 License. Your use of that executable is in no way restricted on
54 account of linking the SANE library code into it.
55
56 This exception does not, however, invalidate any other reasons why
57 the executable file might be covered by the GNU General Public
58 License.
59
60 If you submit changes to SANE to the maintainers to be included in
61 a subsequent release, you agree by submitting the changes that
62 those changes may be distributed with this exception intact.
63
64 If you write modifications of your own for SANE, it is your choice
65 whether to permit this exception to apply to your modifications.
66 If you do not wish that, delete this exception notice. */
67
68 #define BUILD 12
69
70 #include "../include/sane/config.h"
71
72 #include <errno.h>
73 #include <fcntl.h>
74 #include <limits.h>
75 #include <signal.h>
76 #include <stdlib.h>
77 #include <string.h>
78 #include <ctype.h>
79 #include <unistd.h>
80 #include <time.h>
81 #include <math.h>
82
83 #include <sys/time.h>
84 #include <sys/stat.h>
85 #include <sys/types.h>
86 #include <sys/ioctl.h>
87
88
89 #include "../include/sane/sane.h"
90 #include "../include/sane/sanei.h"
91 #include "../include/sane/saneopts.h"
92
93 #define BACKEND_NAME artec_eplus48u
94 #include "../include/sane/sanei_backend.h"
95 #include "../include/sane/sanei_config.h"
96
97 #include "artec_eplus48u.h"
98
99 #ifndef PATH_MAX
100 # define PATH_MAX 1024
101 #endif
102
103 #define _DEFAULT_DEVICE "/dev/usbscanner"
104 #define ARTEC48U_CONFIG_FILE "artec_eplus48u.conf"
105
106 #define _SHADING_FILE_BLACK "artec48ushading_black"
107 #define _SHADING_FILE_WHITE "artec48ushading_white"
108 #define _EXPOSURE_FILE "artec48uexposure"
109 #define _OFFSET_FILE "artec48uoffset"
110
111 #define _BYTE 3
112 #define _STRING 2
113 #define _FLOAT 1
114 #define _INT 0
115
116 /*for calibration*/
117 #define WHITE_MIN 243*257
118 #define WHITE_MAX 253*257
119 #define BLACK_MIN 8*257
120 #define BLACK_MAX 18*257
121 #define EXPOSURE_STEP 280
122
123 static Artec48U_Device *first_dev = 0;
124 static Artec48U_Scanner *first_handle = 0;
125 static SANE_Int num_devices = 0;
126 static char devName[PATH_MAX];
127 static char firmwarePath[PATH_MAX];
128 static char vendor_string[PATH_MAX];
129 static char model_string[PATH_MAX];
130
131 static SANE_Bool cancelRead;
132 static int isEPro;
133 static int eProMult;
134 static SANE_Auth_Callback auth = NULL;
135 static double gamma_master_default = 1.7;
136 static double gamma_r_default = 1.0;
137 static double gamma_g_default = 1.0;
138 static double gamma_b_default = 1.0;
139
140 static SANE_Word memory_read_value = 0x200c; /**< Memory read - wValue */
141 static SANE_Word memory_write_value = 0x200b; /**< Memory write - wValue */
142 static SANE_Word send_cmd_value = 0x2010; /**< Send normal command - wValue */
143 static SANE_Word send_cmd_index = 0x3f40; /**< Send normal command - wIndex */
144 static SANE_Word recv_res_value = 0x2011; /**< Receive normal result - wValue */
145 static SANE_Word recv_res_index = 0x3f00; /**< Receive normal result - wIndex */
146 static SANE_Word send_small_cmd_value = 0x2012; /**< Send small command - wValue */
147 static SANE_Word send_small_cmd_index = 0x3f40; /**< Send small command - wIndex */
148 static SANE_Word recv_small_res_value = 0x2013; /**< Receive small result - wValue */
149 static SANE_Word recv_small_res_index = 0x3f00; /**< Receive small result - wIndex */
150
151 static SANE_String_Const mode_list[] = {
152 SANE_VALUE_SCAN_MODE_LINEART,
153 SANE_VALUE_SCAN_MODE_GRAY,
154 SANE_VALUE_SCAN_MODE_COLOR,
155 NULL
156 };
157
158 static SANE_Word resbit_list[] = {
159 6,
160 50, 100, 200, 300, 600, 1200
161 };
162
163 static SANE_Range brightness_contrast_range = {
164 -127,
165 127,
166 0
167 };
168
169 static SANE_Range blacklevel_range = {
170 20,
171 240,
172 1
173 };
174
175 static SANE_Range gamma_range = {
176 0, /* minimum */
177 SANE_FIX (4.0), /* maximum */
178 0 /* quantization */
179 };
180
181 static SANE_Range scan_range_x = {
182 0, /* minimum */
183 SANE_FIX (216.0), /* maximum */
184 0 /* quantization */
185 };
186
187 static SANE_Range scan_range_y = {
188 0, /* minimum */
189 SANE_FIX (297.0), /* maximum */
190 0 /* quantization */
191 };
192
193
194 static SANE_Word bitdepth_list[] = {
195 2, 8, 16
196 };
197
198 static SANE_Word bitdepth_list2[] = {
199 1, 8
200 };
201
202 static Artec48U_Exposure_Parameters exp_params;
203 static Artec48U_Exposure_Parameters default_exp_params =
204 { 0x009f, 0x0109, 0x00cb };
205 static Artec48U_AFE_Parameters afe_params;
206 static Artec48U_AFE_Parameters default_afe_params =
207 { 0x28, 0x0a, 0x2e, 0x03, 0x2e, 0x03 };
208
209 static SANE_Status
download_firmware_file(Artec48U_Device * chip)210 download_firmware_file (Artec48U_Device * chip)
211 {
212 SANE_Status status = SANE_STATUS_GOOD;
213 SANE_Byte *buf = NULL;
214 int size = -1;
215 FILE *f;
216
217 XDBG ((2, "Try to open firmware file: \"%s\"\n", chip->firmware_path));
218 f = fopen (chip->firmware_path, "rb");
219 if (!f)
220 {
221 XDBG ((2, "Cannot open firmware file \"%s\"\n", firmwarePath));
222 status = SANE_STATUS_INVAL;
223 }
224
225 if (status == SANE_STATUS_GOOD)
226 {
227 fseek (f, 0, SEEK_END);
228 size = ftell (f);
229 fseek (f, 0, SEEK_SET);
230 if (size == -1)
231 {
232 XDBG ((2, "Error getting size of firmware file \"%s\"\n",
233 chip->firmware_path));
234 status = SANE_STATUS_INVAL;
235 }
236 }
237
238 if (status == SANE_STATUS_GOOD)
239 {
240 XDBG ((3, "firmware size: %d\n", size));
241 buf = (SANE_Byte *) malloc (size);
242 if (!buf)
243 {
244 XDBG ((2, "Cannot allocate %d bytes for firmware\n", size));
245 status = SANE_STATUS_NO_MEM;
246 }
247 }
248
249 if (status == SANE_STATUS_GOOD)
250 {
251 int bytes_read = fread (buf, 1, size, f);
252 if (bytes_read != size)
253 {
254 XDBG ((2, "Problem reading firmware file \"%s\"\n",
255 chip->firmware_path));
256 status = SANE_STATUS_INVAL;
257 }
258 }
259
260 if (f)
261 fclose (f);
262
263 if (status == SANE_STATUS_GOOD)
264 {
265 status = artec48u_download_firmware (chip, buf, size);
266 if (status != SANE_STATUS_GOOD)
267 {
268 XDBG ((2, "Firmware download failed\n"));
269 }
270 }
271
272 if (buf)
273 free (buf);
274 return status;
275 }
276
277 static SANE_Status
init_calibrator(Artec48U_Scanner * s)278 init_calibrator (Artec48U_Scanner * s)
279 {
280 XDBG ((2, "Init calibrator size %d\n",30720 * s->dev->epro_mult));
281 s->shading_buffer_w = (unsigned char *) malloc (30720 * s->dev->epro_mult); /*epro*/
282 s->shading_buffer_b = (unsigned char *) malloc (30720 * s->dev->epro_mult); /*epro*/
283 s->shading_buffer_white[0] =
284 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof(unsigned int));/*epro*/
285 s->shading_buffer_black[0] =
286 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/
287 s->shading_buffer_white[1] =
288 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/
289 s->shading_buffer_black[1] =
290 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/
291 s->shading_buffer_white[2] =
292 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/
293 s->shading_buffer_black[2] =
294 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/
295
296 if (!s->shading_buffer_w || !s->shading_buffer_b
297 || !s->shading_buffer_white[0] || !s->shading_buffer_black[0]
298 || !s->shading_buffer_white[1] || !s->shading_buffer_black[1]
299 || !s->shading_buffer_white[2] || !s->shading_buffer_black[2])
300 {
301 if (s->shading_buffer_w)
302 free (s->shading_buffer_w);
303 if (s->shading_buffer_b)
304 free (s->shading_buffer_b);
305 if (s->shading_buffer_white[0])
306 free (s->shading_buffer_white[0]);
307 if (s->shading_buffer_black[0])
308 free (s->shading_buffer_black[0]);
309 if (s->shading_buffer_white[1])
310 free (s->shading_buffer_white[1]);
311 if (s->shading_buffer_black[1])
312 free (s->shading_buffer_black[1]);
313 if (s->shading_buffer_white[2])
314 free (s->shading_buffer_white[2]);
315 if (s->shading_buffer_black[2])
316 free (s->shading_buffer_black[2]);
317 return SANE_STATUS_NO_MEM;
318 }
319 return SANE_STATUS_GOOD;
320 }
321
322 static void
init_shading_buffer(Artec48U_Scanner * s)323 init_shading_buffer (Artec48U_Scanner * s)
324 {
325 unsigned int i, j;
326
327 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/
328 {
329 for (j = 0; j < 3; j++)
330 {
331 s->temp_shading_buffer[j][i] = 0;
332 }
333 }
334 }
335
336 static void
add_to_shading_buffer(Artec48U_Scanner * s,unsigned int ** buffer_pointers)337 add_to_shading_buffer (Artec48U_Scanner * s, unsigned int **buffer_pointers)
338 {
339 unsigned int i, j;
340
341 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/
342 {
343 for (j = 0; j < 3; j++)
344 {
345 s->temp_shading_buffer[j][i] += buffer_pointers[j][i];
346 }
347 }
348 }
349
350 static void
finish_shading_buffer(Artec48U_Scanner * s,SANE_Bool white)351 finish_shading_buffer (Artec48U_Scanner * s, SANE_Bool white)
352 {
353 unsigned int i, j, cnt, c, div;
354 unsigned char *shading_buffer;
355 cnt = 0;
356
357 if (white)
358 {
359 shading_buffer = s->shading_buffer_w;
360 div = s->dev->shading_lines_w;
361 }
362 else
363 {
364 shading_buffer = s->shading_buffer_b;
365 div = s->dev->shading_lines_b;
366 }
367
368 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/
369 {
370 for (j = 0; j < 3; j++)
371 {
372 int value = s->temp_shading_buffer[j][i] / (div);
373 shading_buffer[cnt] = (SANE_Byte) (value & 0xff);
374 ++cnt;
375 shading_buffer[cnt] = (SANE_Byte) ((value >> 8) & 0xff);
376 ++cnt;
377 }
378 }
379
380 for (c = 0; c < (30720 * s->dev->epro_mult) - 5; c += 6) /*epro*/
381 {
382 i = (int) shading_buffer[c] + ((int) shading_buffer[c + 1] << 8);
383 i = (int) shading_buffer[c + 2] + ((int) shading_buffer[c + 3] << 8);
384 i = (int) shading_buffer[c + 4] + ((int) shading_buffer[c + 5] << 8);
385 }
386 }
387
388 static void
finish_exposure_buffer(Artec48U_Scanner * s,int * avg_r,int * avg_g,int * avg_b)389 finish_exposure_buffer (Artec48U_Scanner * s, int *avg_r, int *avg_g,
390 int *avg_b)
391 {
392 unsigned int i, j, cnt, c, div;
393 unsigned int max_r;
394 unsigned int max_g;
395 unsigned int max_b;
396 unsigned char *shading_buffer;
397 cnt = 0;
398
399 shading_buffer = s->shading_buffer_w;
400 div = s->dev->shading_lines_w;
401
402 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/
403 {
404 for (j = 0; j < 3; j++)
405 {
406 int value = s->temp_shading_buffer[j][i] / (div);
407 shading_buffer[cnt] = (SANE_Byte) (value & 0xff);
408 ++cnt;
409 shading_buffer[cnt] = (SANE_Byte) ((value >> 8) & 0xff);
410 ++cnt;
411 }
412 }
413 max_r = 0;
414 max_g = 0;
415 max_b = 0;
416 for (c = 0; c < (30720 * s->dev->epro_mult) - 5; c += 6) /*epro*/
417 {
418 i = (int) shading_buffer[c] + ((int) shading_buffer[c + 1] << 8);
419 if (i > max_r)
420 max_r = i;
421 i = (int) shading_buffer[c + 2] + ((int) shading_buffer[c + 3] << 8);
422 if (i > max_g)
423 max_g = i;
424 i = (int) shading_buffer[c + 4] + ((int) shading_buffer[c + 5] << 8);
425 if (i > max_b)
426 max_b = i;
427 }
428 *avg_r = max_r;
429 *avg_g = max_g;
430 *avg_b = max_b;
431 }
432
433 static void
finish_offset_buffer(Artec48U_Scanner * s,int * avg_r,int * avg_g,int * avg_b)434 finish_offset_buffer (Artec48U_Scanner * s, int *avg_r, int *avg_g,
435 int *avg_b)
436 {
437 unsigned int i, j, cnt, c, div;
438 unsigned int min_r;
439 unsigned int min_g;
440 unsigned int min_b;
441 unsigned char *shading_buffer;
442 cnt = 0;
443
444 shading_buffer = s->shading_buffer_b;
445 div = s->dev->shading_lines_b;
446
447 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/
448 {
449 for (j = 0; j < 3; j++)
450 {
451 int value = s->temp_shading_buffer[j][i] / (div);
452 shading_buffer[cnt] = (SANE_Byte) (value & 0xff);
453 ++cnt;
454 shading_buffer[cnt] = (SANE_Byte) ((value >> 8) & 0xff);
455 ++cnt;
456 }
457 }
458 min_r = 65535;
459 min_g = 65535;
460 min_b = 65535;
461 for (c = 0; c < (30720 * s->dev->epro_mult) - 5; c += 6) /*epro*/
462 {
463 i = (int) shading_buffer[c] + ((int) shading_buffer[c + 1] << 8);
464 if (i < min_r)
465 min_r = i;
466 i = (int) shading_buffer[c + 2] + ((int) shading_buffer[c + 3] << 8);
467 if (i < min_g)
468 min_g = i;
469 i = (int) shading_buffer[c + 4] + ((int) shading_buffer[c + 5] << 8);
470 if (i < min_b)
471 min_b = i;
472 }
473 *avg_r = min_r;
474 *avg_g = min_g;
475 *avg_b = min_b;
476 }
477
478 static SANE_Status
artec48u_wait_for_positioning(Artec48U_Device * chip)479 artec48u_wait_for_positioning (Artec48U_Device * chip)
480 {
481 SANE_Status status;
482 SANE_Bool moving;
483
484 while (SANE_TRUE)
485 {
486 status = artec48u_is_moving (chip, &moving);
487 if (status != SANE_STATUS_GOOD)
488 return status;
489 if (!moving)
490 break;
491 usleep (100000);
492 }
493
494 return SANE_STATUS_GOOD;
495 }
496
497 static void
copy_scan_line(Artec48U_Scanner * s)498 copy_scan_line (Artec48U_Scanner * s)
499 {
500 /*For resolution of 1200 dpi we have to interpolate
501 horizontally, because the optical horizontal resolution is
502 limited to 600 dpi. We simply use the average value of two pixels. */
503 int cnt, i, j;
504 int xs = s->params.pixel_xs;
505 int interpolate = 0;
506 int value;
507 int value1;
508 int value2;
509 if ((s->reader->params.ydpi == 1200) && (s->dev->is_epro == 0)) /*epro*/
510 interpolate = 1;
511 cnt = 0;
512 if (s->params.color)
513 {
514 if (s->params.depth > 8)
515 {
516 for (i = xs - 1; i >= 0; i--)
517 {
518 for (j = 0; j < 3; j++)
519 {
520 value = s->buffer_pointers[j][i];
521 s->line_buffer[cnt] = LOBYTE (value);
522 ++cnt;
523 s->line_buffer[cnt] = HIBYTE (value);
524 ++cnt;
525 }
526 if (interpolate == 1) /*1200 dpi */
527 cnt += 6;
528 }
529 if (interpolate == 1)
530 {
531 for (i = 0; i < (xs * 12) - 12; i += 12)
532 {
533 value1 = (int) s->line_buffer[i];
534 value1 += (int) (s->line_buffer[i + 1] << 8);
535 value2 = (int) s->line_buffer[i + 12];
536 value2 += (int) (s->line_buffer[i + 13] << 8);
537 value = (value1 + value2) / 2;
538 if (value < 0)
539 value = 0;
540 if (value > 65535)
541 value = 65535;
542 s->line_buffer[i + 6] = LOBYTE (value);
543 s->line_buffer[i + 7] = HIBYTE (value);
544
545 value1 = (int) s->line_buffer[i + 2];
546 value1 += (int) (s->line_buffer[i + 3] << 8);
547 value2 = (int) s->line_buffer[i + 14];
548 value2 += (int) (s->line_buffer[i + 15] << 8);
549 value = (value1 + value2) / 2;
550 if (value < 0)
551 value = 0;
552 if (value > 65535)
553 value = 65535;
554 s->line_buffer[i + 8] = LOBYTE (value);
555 s->line_buffer[i + 9] = HIBYTE (value);
556
557 value1 = (int) s->line_buffer[i + 4];
558 value1 += (int) (s->line_buffer[i + 5] << 8);
559 value2 = (int) s->line_buffer[i + 16];
560 value2 += (int) (s->line_buffer[i + 17] << 8);
561 value = (value1 + value2) / 2;
562 if (value < 0)
563 value = 0;
564 if (value > 65535)
565 value = 65535;
566 s->line_buffer[i + 10] = LOBYTE (value);
567 s->line_buffer[i + 11] = HIBYTE (value);
568 }
569 }
570 }
571 else
572 {
573 for (i = xs - 1; i >= 0; i--)
574 {
575 for (j = 0; j < 3; j++)
576 {
577 value = s->buffer_pointers[j][i];
578 s->line_buffer[cnt] = (SANE_Byte) (value / 257);
579 cnt += 1;
580 }
581 if (interpolate == 1) /*1200 dpi */
582 cnt += 3;
583 }
584 if (interpolate == 1)
585 {
586 for (i = 0; i < (xs * 6) - 6; i += 6)
587 {
588 value1 = (int) s->line_buffer[i];
589 value2 = (int) s->line_buffer[i + 6];
590 value = (value1 + value2) / 2;
591 if (value < 0)
592 value = 0;
593 if (value > 255)
594 value = 255;
595 s->line_buffer[i + 3] = (SANE_Byte) (value);
596
597 value1 = (int) s->line_buffer[i + 1];
598 value2 = (int) s->line_buffer[i + 7];
599 value = (value1 + value2) / 2;
600 if (value < 0)
601 value = 0;
602 if (value > 255)
603 value = 255;
604 s->line_buffer[i + 4] = (SANE_Byte) (value);
605
606 value1 = (int) s->line_buffer[i + 2];
607 value2 = (int) s->line_buffer[i + 8];
608 value = (value1 + value2) / 2;
609 if (value < 0)
610 value = 0;
611 if (value > 255)
612 value = 255;
613 s->line_buffer[i + 5] = (SANE_Byte) (value);
614 }
615 }
616 }
617 }
618 else
619 {
620 if (s->params.depth > 8)
621 {
622 for (i = xs - 1; i >= 0; --i)
623 {
624 value = s->buffer_pointers[0][i];
625 s->line_buffer[cnt] = LOBYTE (value);
626 ++cnt;
627 s->line_buffer[cnt] = HIBYTE (value);
628 ++cnt;
629 if (interpolate == 1) /*1200 dpi */
630 cnt += 2;
631 }
632 if (interpolate == 1)
633 {
634 for (i = 0; i < (xs * 4) - 4; i += 4)
635 {
636 value1 = (int) s->line_buffer[i];
637 value1 += (int) (s->line_buffer[i + 1] << 8);
638 value2 = (int) s->line_buffer[i + 4];
639 value2 += (int) (s->line_buffer[i + 5] << 8);
640 value = (value1 + value2) / 2;
641 if (value < 0)
642 value = 0;
643 if (value > 65535)
644 value = 65535;
645 s->line_buffer[i + 2] = LOBYTE (value);
646 s->line_buffer[i + 3] = HIBYTE (value);
647 }
648 }
649 }
650 else
651 {
652 if (s->params.lineart == SANE_FALSE)
653 {
654 for (i = xs - 1; i >= 0; --i)
655 {
656 value = s->buffer_pointers[0][i];
657 s->line_buffer[cnt] = (SANE_Byte) (value / 257);
658 ++cnt;
659 if (interpolate == 1) /*1200 dpi */
660 ++cnt;
661 }
662 if (interpolate == 1)
663 {
664 for (i = 0; i < (xs * 2) - 2; i += 2)
665 {
666 value1 = (int) s->line_buffer[i];
667 value2 = (int) s->line_buffer[i + 2];
668 value = (value1 + value2) / 2;
669 if (value < 0)
670 value = 0;
671 if (value > 255)
672 value = 255;
673 s->line_buffer[i + 1] = (SANE_Byte) (value);
674 }
675 }
676 }
677 else
678 {
679 int cnt2;
680 int bit_cnt = 0;
681 int black_level = s->val[OPT_BLACK_LEVEL].w;
682 /*copy to lineart_buffer */
683 for (i = xs - 1; i >= 0; --i)
684 {
685 s->lineart_buffer[cnt] =
686 (SANE_Byte) (s->buffer_pointers[0][i] / 257);
687 ++cnt;
688 if (interpolate == 1) /*1200 dpi */
689 ++cnt;
690 }
691 cnt2 = cnt - 1;
692 cnt = 0;
693 if (interpolate == 1)
694 {
695 for (i = 0; i < cnt2 - 2; i += 2)
696 {
697 value1 = (int) s->lineart_buffer[i];
698 value2 = (int) s->lineart_buffer[i + 2];
699 value = (value1 + value2) / 2;
700 if (value < 0)
701 value = 0;
702 if (value > 255)
703 value = 255;
704 s->lineart_buffer[i + 1] = (SANE_Byte) (value);
705 }
706 }
707 /* in this case, every value in buffer_pointers represents a bit */
708 for (i = 0; i < cnt2; i++)
709 {
710 SANE_Byte temp;
711 if (bit_cnt == 0)
712 s->line_buffer[cnt] = 0; /*clear */
713 temp = s->lineart_buffer[i];
714 if (temp <= black_level)
715 s->line_buffer[cnt] |= 1 << (7 - bit_cnt);
716 ++bit_cnt;
717 if (bit_cnt > 7)
718 {
719 bit_cnt = 0;
720 ++cnt;
721 }
722 }
723
724 }
725 }
726 }
727 }
728
729 /*.............................................................................
730 * attach a device to the backend
731 */
732 static SANE_Status
attach(const char * dev_name,Artec48U_Device ** devp)733 attach (const char *dev_name, Artec48U_Device ** devp)
734 {
735 SANE_Status status;
736 Artec48U_Device *dev;
737
738 XDBG ((1, "attach (%s, %p)\n", dev_name, (void *) devp));
739
740 if (!dev_name)
741 {
742 XDBG ((1, "attach: devname == NULL\n"));
743 return SANE_STATUS_INVAL;
744 }
745 /* already attached ? */
746 for (dev = first_dev; dev; dev = dev->next)
747 {
748 if (0 == strcmp (dev->name, dev_name))
749 {
750 if (devp)
751 *devp = dev;
752 XDBG ((3, "attach: device %s already attached\n", dev_name));
753 return SANE_STATUS_GOOD;
754 }
755 }
756 XDBG ((3, "attach: device %s NOT attached\n", dev_name));
757 /* allocate some memory for the device */
758 artec48u_device_new (&dev);
759 if (NULL == dev)
760 return SANE_STATUS_NO_MEM;
761
762 dev->fd = -1;
763 dev->name = strdup (dev_name);
764 dev->sane.name = strdup (dev_name);
765 /*
766 * go ahead and open the scanner device
767 */
768 status = artec48u_device_open (dev);
769 if (status != SANE_STATUS_GOOD)
770 {
771 XDBG ((3, "Could not open device!!\n"));
772 artec48u_device_free (dev);
773 return status;
774 }
775 /*limit the size of vendor and model string to 40 */
776 vendor_string[40] = 0;
777 model_string[40] = 0;
778
779 /* assign all the stuff we need for this device... */
780 dev->sane.vendor = strdup (vendor_string);
781 XDBG ((3, "attach: setting vendor string: %s\n", vendor_string));
782 dev->sane.model = strdup (model_string);
783 XDBG ((3, "attach: setting model string: %s\n", model_string));
784 dev->sane.type = "flatbed scanner";
785 dev->firmware_path = strdup (firmwarePath);
786
787 dev->epro_mult = eProMult;
788 dev->is_epro = isEPro;
789 XDBG ((1, "attach eProMult %d\n", eProMult));
790 XDBG ((1, "attach isEPro %d\n", isEPro));
791 dev->optical_xdpi = 600 * dev->epro_mult; /*epro*/
792 dev->optical_ydpi = 1200 * dev->epro_mult; /*epro*/
793 dev->base_ydpi = 600 * dev->epro_mult; /*epro*/
794 dev->xdpi_offset = 0; /* in optical_xdpi units */
795 dev->ydpi_offset = 280 * dev->epro_mult; /* in optical_ydpi units */
796 dev->x_size = 5120 * dev->epro_mult; /*epro*/ /* in optical_xdpi units */
797 dev->y_size = 14100 * dev->epro_mult; /*epro*/ /* in optical_ydpi units */
798 dev->shading_offset = 10 * dev->epro_mult;
799 dev->shading_lines_b = 70 * dev->epro_mult;
800 dev->shading_lines_w = 70 * dev->epro_mult;
801
802 dev->gamma_master = gamma_master_default;
803 dev->gamma_r = gamma_r_default;
804 dev->gamma_g = gamma_g_default;
805 dev->gamma_b = gamma_b_default;
806
807 dev->afe_params.r_offset = afe_params.r_offset;
808 dev->afe_params.g_offset = afe_params.g_offset;
809 dev->afe_params.b_offset = afe_params.b_offset;
810
811 dev->afe_params.r_pga = default_afe_params.r_pga;
812 dev->afe_params.g_pga = default_afe_params.g_pga;
813 dev->afe_params.b_pga = default_afe_params.b_pga;
814
815 dev->exp_params.r_time = exp_params.r_time;
816 dev->exp_params.g_time = exp_params.g_time;
817 dev->exp_params.b_time = exp_params.b_time;
818
819
820 ++num_devices;
821 dev->next = first_dev;
822 first_dev = dev;
823
824 if (devp)
825 *devp = first_dev;
826 status = artec48u_device_close (dev);
827 return SANE_STATUS_GOOD;
828 }
829
830 static SANE_Status
attach_one_device(SANE_String_Const devname)831 attach_one_device (SANE_String_Const devname)
832 {
833 Artec48U_Device *dev;
834 SANE_Status status;
835
836 status = attach (devname, &dev);
837 if (SANE_STATUS_GOOD != status)
838 return status;
839 return SANE_STATUS_GOOD;
840 }
841
842 /**
843 * function to decode an value and give it back to the caller.
844 * @param src - pointer to the source string to check
845 * @param opt - string that keeps the option name to check src for
846 * @param what - _FLOAT or _INT
847 * @param result - pointer to the var that should receive our result
848 * @param def - default value that result should be in case of any error
849 * @return The function returns SANE_TRUE if the option has been found,
850 * if not, it returns SANE_FALSE
851 */
852 static SANE_Bool
decodeVal(char * src,char * opt,int what,void * result,void * def)853 decodeVal (char *src, char *opt, int what, void *result, void *def)
854 {
855 char *tmp, *tmp2;
856 const char *name;
857
858 /* skip the option string */
859 name = (const char *) &src[strlen ("option")];
860
861 /* get the name of the option */
862 name = sanei_config_get_string (name, &tmp);
863
864 if (tmp)
865 {
866 /* on success, compare with the given one */
867 if (0 == strcmp (tmp, opt))
868 {
869 XDBG ((1, "Decoding option >%s<\n", opt));
870 if (_INT == what)
871 {
872 /* assign the default value for this option... */
873 *((int *) result) = *((int *) def);
874 if (*name)
875 {
876 /* get the configuration value and decode it */
877 name = sanei_config_get_string (name, &tmp2);
878 if (tmp2)
879 {
880 *((int *) result) = strtol (tmp2, 0, 0);
881 free (tmp2);
882 }
883 }
884 free (tmp);
885 return SANE_TRUE;
886 }
887 else if (_FLOAT == what)
888 {
889 /* assign the default value for this option... */
890 *((double *) result) = *((double *) def);
891 if (*name)
892 {
893 /* get the configuration value and decode it */
894 name = sanei_config_get_string (name, &tmp2);
895 if (tmp2)
896 {
897 *((double *) result) = strtod (tmp2, 0);
898 free (tmp2);
899 }
900 }
901 free (tmp);
902 return SANE_TRUE;
903 }
904 else if (_BYTE == what)
905 {
906 /* assign the default value for this option... */
907 *((SANE_Byte *) result) = *((SANE_Byte *) def);
908 if (*name)
909 {
910 /* get the configuration value and decode it */
911 name = sanei_config_get_string (name, &tmp2);
912 if (tmp2)
913 {
914 *((SANE_Byte *) result) =
915 (SANE_Byte) strtol (tmp2, 0, 0);
916 free (tmp2);
917 }
918 }
919 free (tmp);
920 return SANE_TRUE;
921 }
922 else if (_STRING == what)
923 {
924 if (*name)
925 {
926 /* get the configuration value and decode it */
927 sanei_config_get_string (name, &tmp2);
928 if (tmp2)
929 {
930 strcpy ((char *) result, (char *) tmp2);
931 free (tmp2);
932 }
933 }
934 free (tmp);
935 return SANE_TRUE;
936 }
937 }
938 free (tmp);
939 }
940 return SANE_FALSE;
941 }
942
943 /**
944 * function to retrieve the device name of a given string
945 * @param src - string that keeps the option name to check src for
946 * @param dest - pointer to the string, that should receive the detected
947 * devicename
948 * @return The function returns SANE_TRUE if the devicename has been found,
949 * if not, it returns SANE_FALSE
950 */
951 static SANE_Bool
decodeDevName(char * src,char * dest)952 decodeDevName (char *src, char *dest)
953 {
954 char *tmp;
955 const char *name;
956
957 if (0 == strncmp ("device", src, 6))
958 {
959 name = (const char *) &src[strlen ("device")];
960 name = sanei_config_skip_whitespace (name);
961
962 XDBG ((1, "Decoding device name >%s<\n", name));
963
964 if (*name)
965 {
966 name = sanei_config_get_string (name, &tmp);
967 if (tmp)
968 {
969 strcpy (dest, tmp);
970 free (tmp);
971 return SANE_TRUE;
972 }
973 }
974 }
975 return SANE_FALSE;
976 }
977
978 #ifdef ARTEC48U_USE_BUTTONS
979 static SANE_Status
artec48u_check_buttons(Artec48U_Device * dev,SANE_Int * value)980 artec48u_check_buttons (Artec48U_Device * dev, SANE_Int * value)
981 {
982 SANE_Status status;
983 Artec48U_Packet req;
984
985 memset (req, 0, sizeof (req));
986 req[0] = 0x74;
987 req[1] = 0x01;
988
989 status = artec48u_device_small_req (dev, req, req);
990 if (status != SANE_STATUS_GOOD)
991 return status;
992
993 *value = (SANE_Int) req[2];
994 return SANE_STATUS_GOOD;
995 }
996 #endif
997
998 #define MAX_DOWNLOAD_BLOCK_SIZE 64
999 static SANE_Status
artec48u_generic_start_scan(Artec48U_Device * dev)1000 artec48u_generic_start_scan (Artec48U_Device * dev)
1001 {
1002 Artec48U_Packet req;
1003
1004 memset (req, 0, sizeof (req));
1005 req[0] = 0x43;
1006 req[1] = 0x01;
1007
1008 return artec48u_device_req (dev, req, req);
1009
1010 }
1011
1012 static SANE_Status
artec48u_generic_read_scanned_data(Artec48U_Device * dev,SANE_Bool * ready)1013 artec48u_generic_read_scanned_data (Artec48U_Device * dev, SANE_Bool * ready)
1014 {
1015 SANE_Status status;
1016 Artec48U_Packet req;
1017
1018 memset (req, 0, sizeof (req));
1019 req[0] = 0x35;
1020 req[1] = 0x01;
1021
1022 status = artec48u_device_req (dev, req, req);
1023 if (status != SANE_STATUS_GOOD)
1024 return status;
1025
1026 if (req[1] == 0x35)
1027 {
1028 if (req[0] == 0)
1029 *ready = SANE_TRUE;
1030 else
1031 *ready = SANE_FALSE;
1032 }
1033 else
1034 return SANE_STATUS_IO_ERROR;
1035
1036 return SANE_STATUS_GOOD;
1037 }
1038
1039 static SANE_Status
artec48u_download_firmware(Artec48U_Device * dev,SANE_Byte * data,SANE_Word size)1040 artec48u_download_firmware (Artec48U_Device * dev,
1041 SANE_Byte * data, SANE_Word size)
1042 {
1043 SANE_Status status;
1044 SANE_Byte download_buf[MAX_DOWNLOAD_BLOCK_SIZE];
1045 SANE_Byte check_buf[MAX_DOWNLOAD_BLOCK_SIZE];
1046 SANE_Byte *block;
1047 SANE_Word addr, bytes_left;
1048 Artec48U_Packet boot_req;
1049 SANE_Word block_size = MAX_DOWNLOAD_BLOCK_SIZE;
1050
1051 CHECK_DEV_ACTIVE ((Artec48U_Device *) dev,
1052 (char *) "artec48u_device_download_firmware");
1053
1054 for (addr = 0; addr < size; addr += block_size)
1055 {
1056 bytes_left = size - addr;
1057 if (bytes_left > block_size)
1058 block = data + addr;
1059 else
1060 {
1061 memset (download_buf, 0, block_size);
1062 memcpy (download_buf, data + addr, bytes_left);
1063 block = download_buf;
1064 }
1065 status = artec48u_device_memory_write (dev, addr, block_size, block);
1066 if (status != SANE_STATUS_GOOD)
1067 return status;
1068 status = artec48u_device_memory_read (dev, addr, block_size, check_buf);
1069 if (status != SANE_STATUS_GOOD)
1070 return status;
1071 if (memcmp (block, check_buf, block_size) != 0)
1072 {
1073 XDBG ((3,
1074 "artec48u_device_download_firmware: mismatch at block 0x%0x\n",
1075 addr));
1076 return SANE_STATUS_IO_ERROR;
1077 }
1078 }
1079
1080 memset (boot_req, 0, sizeof (boot_req));
1081 boot_req[0] = 0x69;
1082 boot_req[1] = 0x01;
1083 boot_req[2] = LOBYTE (addr);
1084 boot_req[3] = HIBYTE (addr);
1085 status = artec48u_device_req (dev, boot_req, boot_req);
1086 if (status != SANE_STATUS_GOOD)
1087 return status;
1088 return SANE_STATUS_GOOD;
1089 }
1090
1091 static SANE_Status
artec48u_is_moving(Artec48U_Device * dev,SANE_Bool * moving)1092 artec48u_is_moving (Artec48U_Device * dev, SANE_Bool * moving)
1093 {
1094 SANE_Status status;
1095 Artec48U_Packet req;
1096 memset (req, 0, sizeof (req));
1097 req[0] = 0x17;
1098 req[1] = 0x01;
1099
1100 status = artec48u_device_req (dev, req, req);
1101 if (status != SANE_STATUS_GOOD)
1102 return status;
1103
1104 if (req[0] == 0x00 && req[1] == 0x17)
1105 {
1106 if (req[2] == 0 && (req[3] == 0 || req[3] == 2))
1107 *moving = SANE_FALSE;
1108 else
1109 *moving = SANE_TRUE;
1110 }
1111 else
1112 return SANE_STATUS_IO_ERROR;
1113 return SANE_STATUS_GOOD;
1114 }
1115
1116 static SANE_Status
artec48u_carriage_home(Artec48U_Device * dev)1117 artec48u_carriage_home (Artec48U_Device * dev)
1118 {
1119 Artec48U_Packet req;
1120
1121 memset (req, 0, sizeof (req));
1122 req[0] = 0x24;
1123 req[1] = 0x01;
1124
1125 return artec48u_device_req (dev, req, req);
1126 }
1127
1128
1129 static SANE_Status
artec48u_stop_scan(Artec48U_Device * dev)1130 artec48u_stop_scan (Artec48U_Device * dev)
1131 {
1132 Artec48U_Packet req;
1133
1134 memset (req, 0, sizeof (req));
1135 req[0] = 0x41;
1136 req[1] = 0x01;
1137 return artec48u_device_small_req (dev, req, req);
1138 }
1139
1140
1141 static SANE_Status
artec48u_setup_scan(Artec48U_Scanner * s,Artec48U_Scan_Request * request,Artec48U_Scan_Action action,SANE_Bool calculate_only,Artec48U_Scan_Parameters * params)1142 artec48u_setup_scan (Artec48U_Scanner * s,
1143 Artec48U_Scan_Request * request,
1144 Artec48U_Scan_Action action,
1145 SANE_Bool calculate_only,
1146 Artec48U_Scan_Parameters * params)
1147 {
1148 DECLARE_FUNCTION_NAME ("artec48u_setup_scan") SANE_Status status;
1149 SANE_Int xdpi, ydpi;
1150 SANE_Bool color;
1151 SANE_Int depth;
1152 SANE_Int pixel_x0, pixel_y0, pixel_xs, pixel_ys;
1153 SANE_Int pixel_align;
1154
1155 SANE_Int abs_x0, abs_y0, abs_xs, abs_ys, base_xdpi, base_ydpi;
1156 SANE_Int scan_xs, scan_ys, scan_bpl;
1157 SANE_Int bits_per_line;
1158 SANE_Byte color_mode_code;
1159
1160 /*If we scan a black line, we use these exposure values */
1161 Artec48U_Exposure_Parameters exp_params_black = { 4, 4, 4 };
1162
1163 XDBG ((6, "%s: enter\n", function_name));
1164 XDBG ((1,"setup scan is_epro %d\n",s->dev->is_epro));
1165 XDBG ((1,"setup scan epro_mult %d\n",s->dev->epro_mult));
1166
1167 xdpi = request->xdpi;
1168 ydpi = request->ydpi;
1169 color = request->color;
1170 depth = request->depth;
1171
1172 switch (action)
1173 {
1174 case SA_CALIBRATE_SCAN_WHITE:
1175 {
1176 /*move a bit inside scan mark -
1177 the value for the offset was found by trial and error */
1178 pixel_y0 = s->dev->shading_offset;
1179 pixel_ys = s->dev->shading_lines_w;
1180 pixel_x0 = 0;
1181 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/
1182 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/
1183 color = SANE_TRUE;
1184 depth = 8;
1185 break;
1186 }
1187 case SA_CALIBRATE_SCAN_OFFSET_1:
1188 case SA_CALIBRATE_SCAN_OFFSET_2:
1189 {
1190 pixel_y0 = s->dev->shading_offset;
1191 pixel_ys = s->dev->shading_lines_b;
1192 pixel_x0 = 0;
1193 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/
1194 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/
1195 color = SANE_TRUE;
1196 depth = 8;
1197 break;
1198 }
1199 case SA_CALIBRATE_SCAN_EXPOSURE_1:
1200 case SA_CALIBRATE_SCAN_EXPOSURE_2:
1201 {
1202 pixel_y0 = s->dev->shading_offset;
1203 pixel_ys = s->dev->shading_lines_w;
1204 pixel_x0 = 0;
1205 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/
1206 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/
1207 color = SANE_TRUE;
1208 depth = 8;
1209 break;
1210 }
1211 case SA_CALIBRATE_SCAN_BLACK:
1212 {
1213 pixel_y0 = s->dev->shading_offset;
1214 pixel_ys = s->dev->shading_lines_w;
1215 pixel_x0 = 0;
1216 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/
1217 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/
1218 color = SANE_TRUE;
1219 depth = 8;
1220 break;
1221 }
1222 case SA_SCAN:
1223 {
1224 SANE_Fixed x0 = request->x0 + s->dev->xdpi_offset;
1225 SANE_Fixed y0;
1226 /*epro*/
1227 if ((ydpi == 1200) && (s->dev->is_epro == 0))
1228 xdpi = 600;
1229 y0 = request->y0 + s->dev->ydpi_offset;
1230 pixel_ys = SANE_UNFIX (request->ys) * ydpi / MM_PER_INCH + 0.5;
1231 pixel_x0 = SANE_UNFIX (x0) * xdpi / MM_PER_INCH + 0.5;
1232 pixel_y0 = SANE_UNFIX (y0) * ydpi / MM_PER_INCH + 0.5;
1233 pixel_xs = SANE_UNFIX (request->xs) * xdpi / MM_PER_INCH + 0.5;
1234 break;
1235 }
1236
1237 default:
1238 XDBG ((6, "%s: invalid action=%d\n", function_name, (int) action));
1239 return SANE_STATUS_INVAL;
1240 }
1241
1242 XDBG ((6, "%s: xdpi=%d, ydpi=%d\n", function_name, xdpi, ydpi));
1243 XDBG ((6, "%s: color=%s, depth=%d\n", function_name,
1244 color ? "TRUE" : "FALSE", depth));
1245 XDBG ((6, "%s: pixel_x0=%d, pixel_y0=%d\n", function_name,
1246 pixel_x0, pixel_y0));
1247 XDBG ((6, "%s: pixel_xs=%d, pixel_ys=%d\n", function_name,
1248 pixel_xs, pixel_ys));
1249
1250 switch (depth)
1251 {
1252 case 8:
1253 color_mode_code = color ? 0x84 : 0x82;
1254 break;
1255
1256 case 16:
1257 color_mode_code = color ? 0xa4 : 0xa2;
1258 break;
1259
1260 default:
1261 XDBG ((6, "%s: unsupported depth=%d\n", function_name, depth));
1262 return SANE_STATUS_UNSUPPORTED;
1263 }
1264
1265 base_xdpi = s->dev->optical_xdpi;
1266 base_ydpi = s->dev->base_ydpi;
1267
1268 XDBG ((6, "%s: base_xdpi=%d, base_ydpi=%d\n", function_name,
1269 base_xdpi, base_ydpi));
1270
1271 abs_x0 = pixel_x0 * base_xdpi / xdpi;
1272 abs_y0 = pixel_y0 * base_ydpi / ydpi;
1273
1274 /* Calculate minimum number of pixels which span an integral multiple of 64
1275 * bytes. */
1276 pixel_align = 32; /* best case for depth = 16 */
1277 while ((depth * pixel_align) % (64 * 8) != 0)
1278 pixel_align *= 2;
1279 XDBG ((6, "%s: pixel_align=%d\n", function_name, pixel_align));
1280
1281 if (pixel_xs % pixel_align == 0)
1282 scan_xs = pixel_xs;
1283 else
1284 scan_xs = (pixel_xs / pixel_align + 1) * pixel_align;
1285 scan_ys = pixel_ys;
1286 XDBG ((6, "%s: scan_xs=%d, scan_ys=%d\n", function_name, scan_xs, scan_ys));
1287
1288 abs_xs = scan_xs * base_xdpi / xdpi;
1289 abs_ys = scan_ys * base_ydpi / ydpi;
1290 XDBG ((6, "%s: abs_xs=%d, abs_ys=%d\n", function_name, abs_xs, abs_ys));
1291
1292 bits_per_line = depth * scan_xs;
1293 if (bits_per_line % 8) /* impossible */
1294 {
1295 XDBG ((1, "%s: BUG: unaligned bits_per_line=%d\n", function_name,
1296 bits_per_line));
1297 return SANE_STATUS_INVAL;
1298 }
1299 scan_bpl = bits_per_line / 8;
1300
1301 if (scan_bpl % 64) /* impossible */
1302 {
1303 XDBG ((1, "%s: BUG: unaligned scan_bpl=%d\n", function_name, scan_bpl));
1304 return SANE_STATUS_INVAL;
1305 }
1306
1307 if (scan_bpl > 15600)
1308 {
1309 XDBG ((6, "%s: scan_bpl=%d, too large\n", function_name, scan_bpl));
1310 return SANE_STATUS_INVAL;
1311 }
1312
1313 XDBG ((6, "%s: scan_bpl=%d\n", function_name, scan_bpl));
1314
1315 if (!calculate_only)
1316 {
1317 Artec48U_Packet req;
1318 char motor_mode_1, motor_mode_2;
1319 switch (action)
1320 {
1321 case SA_CALIBRATE_SCAN_WHITE:
1322 motor_mode_1 = 0x01;
1323 motor_mode_2 = 0x00;
1324 break;
1325
1326 case SA_CALIBRATE_SCAN_BLACK:
1327 motor_mode_1 = 0x04;
1328 motor_mode_2 = 0x00;
1329 break;
1330
1331 case SA_SCAN:
1332 motor_mode_1 = 0x01;
1333 motor_mode_2 = 0x00;
1334 break;
1335
1336 default:
1337 XDBG ((6, "%s: invalid action=%d\n", function_name, (int) action));
1338 return SANE_STATUS_INVAL;
1339 }
1340
1341 /* Fill in the setup command */
1342 memset (req, 0, sizeof (req));
1343 req[0x00] = 0x20;
1344 req[0x01] = 0x01;
1345 req[0x02] = LOBYTE (abs_y0);
1346 req[0x03] = HIBYTE (abs_y0);
1347 req[0x04] = LOBYTE (abs_ys);
1348 req[0x05] = HIBYTE (abs_ys);
1349 req[0x06] = LOBYTE (abs_x0);
1350 req[0x07] = HIBYTE (abs_x0);
1351 req[0x08] = LOBYTE (abs_xs);
1352 req[0x09] = HIBYTE (abs_xs);
1353 req[0x0a] = color_mode_code;
1354 req[0x0b] = 0x60;
1355 req[0x0c] = LOBYTE (xdpi);
1356 req[0x0d] = HIBYTE (xdpi);
1357 req[0x0e] = 0x12;
1358 req[0x0f] = 0x00;
1359 req[0x10] = LOBYTE (scan_bpl);
1360 req[0x11] = HIBYTE (scan_bpl);
1361 req[0x12] = LOBYTE (scan_ys);
1362 req[0x13] = HIBYTE (scan_ys);
1363 req[0x14] = motor_mode_1;
1364 req[0x15] = motor_mode_2;
1365 req[0x16] = LOBYTE (ydpi);
1366 req[0x17] = HIBYTE (ydpi);
1367 req[0x18] = 0x00;
1368
1369 status = artec48u_device_req (s->dev, req, req);
1370 if (status != SANE_STATUS_GOOD)
1371 {
1372 XDBG ((3, "%s: setup request failed: %s\n", function_name,
1373 sane_strstatus (status)));
1374 return status;
1375 }
1376
1377 if (action == SA_SCAN)
1378 {
1379 artec48u_calculate_shading_buffer (s, pixel_x0, pixel_xs + pixel_x0,
1380 xdpi, color);
1381 artec48u_generic_set_exposure_time (s->dev,
1382 &(s->dev->
1383 artec_48u_exposure_params));
1384 artec48u_generic_set_afe (s->dev, &(s->dev->artec_48u_afe_params));
1385 }
1386 else if (action == SA_CALIBRATE_SCAN_BLACK)
1387 {
1388 artec48u_generic_set_exposure_time (s->dev, &exp_params_black);
1389 artec48u_generic_set_afe (s->dev, &(s->dev->afe_params));
1390 }
1391 else if (action == SA_CALIBRATE_SCAN_WHITE)
1392 {
1393 artec48u_generic_set_exposure_time (s->dev, &(s->dev->exp_params));
1394 artec48u_generic_set_afe (s->dev, &(s->dev->afe_params));
1395 }
1396 }
1397 /* Fill in calculated values */
1398 params->xdpi = xdpi;
1399 params->ydpi = ydpi;
1400 params->depth = depth;
1401 params->color = color;
1402 params->pixel_xs = pixel_xs;
1403 params->pixel_ys = pixel_ys;
1404 params->scan_xs = scan_xs;
1405 params->scan_ys = scan_ys;
1406 params->scan_bpl = scan_bpl;
1407
1408 XDBG ((6, "%s: leave: ok\n", function_name));
1409 return SANE_STATUS_GOOD;
1410 }
1411
1412 static SANE_Status
artec48u_generic_set_afe(Artec48U_Device * dev,Artec48U_AFE_Parameters * params)1413 artec48u_generic_set_afe (Artec48U_Device * dev,
1414 Artec48U_AFE_Parameters * params)
1415 {
1416 Artec48U_Packet req;
1417 memset (req, 0, sizeof (req));
1418 req[0] = 0x22;
1419 req[1] = 0x01;
1420 req[2] = params->r_offset;
1421 req[3] = params->r_pga;
1422 req[4] = params->g_offset;
1423 req[5] = params->g_pga;
1424 req[6] = params->b_offset;
1425 req[7] = params->b_pga;
1426
1427 return artec48u_device_req (dev, req, req);
1428 }
1429
1430
1431 static SANE_Status
artec48u_generic_set_exposure_time(Artec48U_Device * dev,Artec48U_Exposure_Parameters * params)1432 artec48u_generic_set_exposure_time (Artec48U_Device * dev,
1433 Artec48U_Exposure_Parameters * params)
1434 {
1435 Artec48U_Packet req;
1436 memset (req, 0, sizeof (req));
1437 req[0] = 0x76;
1438 req[1] = 0x01;
1439 req[2] = req[6] = req[10] = 0x04;
1440 req[4] = LOBYTE (params->r_time);
1441 req[5] = HIBYTE (params->r_time);
1442 req[8] = LOBYTE (params->g_time);
1443 req[9] = HIBYTE (params->g_time);
1444 req[12] = LOBYTE (params->b_time);
1445 req[13] = HIBYTE (params->b_time);
1446 return artec48u_device_req (dev, req, req);
1447 }
1448
1449 static SANE_Status
artec48u_device_new(Artec48U_Device ** dev_return)1450 artec48u_device_new (Artec48U_Device ** dev_return)
1451 {
1452 DECLARE_FUNCTION_NAME ("artec48u_device_new") Artec48U_Device *dev;
1453
1454 XDBG ((7, "%s: enter\n", function_name));
1455 if (!dev_return)
1456 return SANE_STATUS_INVAL;
1457
1458 dev = (Artec48U_Device *) malloc (sizeof (Artec48U_Device));
1459
1460 if (!dev)
1461 {
1462 XDBG ((3, "%s: couldn't malloc %lu bytes for device\n",
1463 function_name, (u_long) sizeof (Artec48U_Device)));
1464 *dev_return = 0;
1465 return SANE_STATUS_NO_MEM;
1466 }
1467 *dev_return = dev;
1468
1469 memset (dev, 0, sizeof (Artec48U_Device));
1470
1471 dev->fd = -1;
1472 dev->active = SANE_FALSE;
1473
1474 dev->read_buffer = NULL;
1475 dev->requested_buffer_size = 32768;
1476
1477 XDBG ((7, "%s: leave: ok\n", function_name));
1478 return SANE_STATUS_GOOD;
1479 }
1480
1481 static SANE_Status
artec48u_device_free(Artec48U_Device * dev)1482 artec48u_device_free (Artec48U_Device * dev)
1483 {
1484 DECLARE_FUNCTION_NAME ("artec48u_device_free")
1485 XDBG ((7, "%s: enter: dev=%p\n", function_name, (void *) dev));
1486 if (dev)
1487 {
1488 if (dev->active)
1489 artec48u_device_deactivate (dev);
1490
1491 if (dev->fd != -1)
1492 artec48u_device_close (dev);
1493
1494 XDBG ((7, "%s: freeing dev\n", function_name));
1495 free (dev);
1496 }
1497 XDBG ((7, "%s: leave: ok\n", function_name));
1498 return SANE_STATUS_GOOD;
1499 }
1500
1501 static SANE_Status
artec48u_device_open(Artec48U_Device * dev)1502 artec48u_device_open (Artec48U_Device * dev)
1503 {
1504 DECLARE_FUNCTION_NAME ("artec48u_device_open")
1505 SANE_Status status;
1506 SANE_Int fd;
1507
1508 XDBG ((7, "%s: enter: dev=%p\n", function_name, (void *) dev));
1509
1510 CHECK_DEV_NOT_NULL (dev, function_name);
1511
1512 if (dev->fd != -1)
1513 {
1514 XDBG ((3, "%s: device already open\n", function_name));
1515 return SANE_STATUS_INVAL;
1516 }
1517
1518 status = sanei_usb_open (dev->sane.name, &fd);
1519 if (status != SANE_STATUS_GOOD)
1520 {
1521 XDBG ((3, "%s: sanei_usb_open failed: %s\n",
1522 function_name, sane_strstatus (status)));
1523 return status;
1524 }
1525
1526 dev->fd = fd;
1527
1528 XDBG ((7, "%s: leave: ok\n", function_name));
1529 return SANE_STATUS_GOOD;
1530 }
1531
1532 static SANE_Status
artec48u_device_close(Artec48U_Device * dev)1533 artec48u_device_close (Artec48U_Device * dev)
1534 {
1535 DECLARE_FUNCTION_NAME ("artec48u_device_close")
1536 XDBG ((7, "%s: enter: dev=%p\n", function_name, (void *) dev));
1537
1538 CHECK_DEV_OPEN (dev, function_name);
1539
1540 if (dev->active)
1541 artec48u_device_deactivate (dev);
1542
1543 sanei_usb_close (dev->fd);
1544 dev->fd = -1;
1545
1546 XDBG ((7, "%s: leave: ok\n", function_name));
1547 return SANE_STATUS_GOOD;
1548 }
1549
1550 static SANE_Status
artec48u_device_activate(Artec48U_Device * dev)1551 artec48u_device_activate (Artec48U_Device * dev)
1552 {
1553 DECLARE_FUNCTION_NAME ("artec48u_device_activate")
1554 CHECK_DEV_OPEN (dev, function_name);
1555
1556 if (dev->active)
1557 {
1558 XDBG ((3, "%s: device already active\n", function_name));
1559 return SANE_STATUS_INVAL;
1560 }
1561
1562 XDBG ((7, "%s: model \"%s\"\n", function_name, dev->sane.model));
1563
1564 dev->xdpi_offset = SANE_FIX (dev->xdpi_offset *
1565 MM_PER_INCH / dev->optical_xdpi);
1566 dev->ydpi_offset = SANE_FIX (dev->ydpi_offset *
1567 MM_PER_INCH / dev->optical_ydpi);
1568
1569 dev->active = SANE_TRUE;
1570
1571 return SANE_STATUS_GOOD;
1572 }
1573
1574 static SANE_Status
artec48u_device_deactivate(Artec48U_Device * dev)1575 artec48u_device_deactivate (Artec48U_Device * dev)
1576 {
1577 DECLARE_FUNCTION_NAME ("artec48u_device_deactivate")
1578 SANE_Status status = SANE_STATUS_GOOD;
1579
1580 CHECK_DEV_ACTIVE (dev, function_name);
1581
1582 if (dev->read_active)
1583 artec48u_device_read_finish (dev);
1584
1585 dev->active = SANE_FALSE;
1586
1587 return status;
1588 }
1589
1590 static SANE_Status
artec48u_device_memory_write(Artec48U_Device * dev,SANE_Word addr,SANE_Word size,SANE_Byte * data)1591 artec48u_device_memory_write (Artec48U_Device * dev,
1592 SANE_Word addr,
1593 SANE_Word size, SANE_Byte * data)
1594 {
1595 DECLARE_FUNCTION_NAME ("artec48u_device_memory_write")
1596 SANE_Status status;
1597
1598 XDBG ((8, "%s: dev=%p, addr=0x%x, size=0x%x, data=%p\n",
1599 function_name, (void *) dev, addr, size, (void *) data));
1600 CHECK_DEV_ACTIVE (dev, function_name);
1601
1602 status = sanei_usb_control_msg (dev->fd, 0x40, 0x01,
1603 memory_write_value, addr, size, data);
1604
1605 if (status != SANE_STATUS_GOOD)
1606 {
1607 XDBG ((3, "%s: sanei_usb_control_msg failed: %s\n",
1608 function_name, sane_strstatus (status)));
1609 }
1610
1611 return status;
1612 }
1613
1614 static SANE_Status
artec48u_device_memory_read(Artec48U_Device * dev,SANE_Word addr,SANE_Word size,SANE_Byte * data)1615 artec48u_device_memory_read (Artec48U_Device * dev,
1616 SANE_Word addr, SANE_Word size, SANE_Byte * data)
1617 {
1618 DECLARE_FUNCTION_NAME ("artec48u_device_memory_read")
1619 SANE_Status status;
1620
1621 XDBG ((8, "%s: dev=%p, addr=0x%x, size=0x%x, data=%p\n",
1622 function_name, (void *) dev, addr, size, (void *) data));
1623 CHECK_DEV_ACTIVE (dev, function_name);
1624
1625 status = sanei_usb_control_msg (dev->fd, 0xc0, 0x01,
1626 memory_read_value, addr, size, data);
1627
1628 if (status != SANE_STATUS_GOOD)
1629 {
1630 XDBG ((3, "%s: sanei_usb_control_msg failed: %s\n",
1631 function_name, sane_strstatus (status)));
1632 }
1633
1634 return status;
1635 }
1636
1637 static SANE_Status
artec48u_device_generic_req(Artec48U_Device * dev,SANE_Word cmd_value,SANE_Word cmd_index,SANE_Word res_value,SANE_Word res_index,Artec48U_Packet cmd,Artec48U_Packet res)1638 artec48u_device_generic_req (Artec48U_Device * dev,
1639 SANE_Word cmd_value, SANE_Word cmd_index,
1640 SANE_Word res_value, SANE_Word res_index,
1641 Artec48U_Packet cmd, Artec48U_Packet res)
1642 {
1643 DECLARE_FUNCTION_NAME ("artec48u_device_generic_req")
1644 SANE_Status status;
1645
1646 XDBG ((7, "%s: command=0x%02x\n", function_name, cmd[0]));
1647 CHECK_DEV_ACTIVE (dev, function_name);
1648
1649 status = sanei_usb_control_msg (dev->fd,
1650 0x40, 0x01, cmd_value, cmd_index,
1651 ARTEC48U_PACKET_SIZE, cmd);
1652 if (status != SANE_STATUS_GOOD)
1653 {
1654 XDBG ((3, "%s: writing command failed: %s\n",
1655 function_name, sane_strstatus (status)));
1656 return status;
1657 }
1658
1659 memset (res, 0, sizeof (Artec48U_Packet));
1660
1661 status = sanei_usb_control_msg (dev->fd,
1662 0xc0, 0x01, res_value, res_index,
1663 ARTEC48U_PACKET_SIZE, res);
1664 if (status != SANE_STATUS_GOOD)
1665 {
1666 XDBG ((3, "%s: reading response failed: %s\n",
1667 function_name, sane_strstatus (status)));
1668 return status;
1669 }
1670 return status;
1671 }
1672
1673 static SANE_Status
artec48u_device_req(Artec48U_Device * dev,Artec48U_Packet cmd,Artec48U_Packet res)1674 artec48u_device_req (Artec48U_Device * dev, Artec48U_Packet cmd,
1675 Artec48U_Packet res)
1676 {
1677 return artec48u_device_generic_req (dev,
1678 send_cmd_value,
1679 send_cmd_index,
1680 recv_res_value,
1681 recv_res_index, cmd, res);
1682 }
1683
1684 static SANE_Status
artec48u_device_small_req(Artec48U_Device * dev,Artec48U_Packet cmd,Artec48U_Packet res)1685 artec48u_device_small_req (Artec48U_Device * dev, Artec48U_Packet cmd,
1686 Artec48U_Packet res)
1687 {
1688 Artec48U_Packet fixed_cmd;
1689 int i;
1690
1691 for (i = 0; i < 8; ++i)
1692 memcpy (fixed_cmd + i * 8, cmd, 8);
1693
1694 return artec48u_device_generic_req (dev,
1695 send_small_cmd_value,
1696 send_small_cmd_index,
1697 recv_small_res_value,
1698 recv_small_res_index, fixed_cmd, res);
1699 }
1700
1701 static SANE_Status
artec48u_device_read_raw(Artec48U_Device * dev,SANE_Byte * buffer,size_t * size)1702 artec48u_device_read_raw (Artec48U_Device * dev, SANE_Byte * buffer,
1703 size_t * size)
1704 {
1705 DECLARE_FUNCTION_NAME ("artec48u_device_read_raw")
1706 SANE_Status status;
1707
1708 CHECK_DEV_ACTIVE (dev, function_name);
1709
1710 XDBG ((7, "%s: enter: size=0x%lx\n", function_name, (unsigned long) *size));
1711
1712 status = sanei_usb_read_bulk (dev->fd, buffer, size);
1713
1714 if (status != SANE_STATUS_GOOD)
1715 {
1716 XDBG ((3, "%s: bulk read failed: %s\n",
1717 function_name, sane_strstatus (status)));
1718 return status;
1719 }
1720
1721 XDBG ((7, "%s: leave: size=0x%lx\n", function_name, (unsigned long) *size));
1722
1723 return SANE_STATUS_GOOD;
1724 }
1725
1726 static SANE_Status
artec48u_device_set_read_buffer_size(Artec48U_Device * dev,size_t buffer_size)1727 artec48u_device_set_read_buffer_size (Artec48U_Device * dev,
1728 size_t buffer_size)
1729 {
1730 DECLARE_FUNCTION_NAME ("gt68xx_device_set_read_buffer_size")
1731 CHECK_DEV_NOT_NULL (dev, function_name);
1732
1733 if (dev->read_active)
1734 {
1735 XDBG ((3, "%s: BUG: read already active\n", function_name));
1736 return SANE_STATUS_INVAL;
1737 }
1738
1739 buffer_size = (buffer_size + 63UL) & ~63UL;
1740 if (buffer_size > 0)
1741 {
1742 dev->requested_buffer_size = buffer_size;
1743 return SANE_STATUS_GOOD;
1744 }
1745
1746 XDBG ((3, "%s: bad buffer size\n", function_name));
1747 return SANE_STATUS_INVAL;
1748 }
1749
1750 static SANE_Status
artec48u_device_read_prepare(Artec48U_Device * dev,size_t expected_count)1751 artec48u_device_read_prepare (Artec48U_Device * dev, size_t expected_count)
1752 {
1753 DECLARE_FUNCTION_NAME ("artec48u_device_read_prepare")
1754 CHECK_DEV_ACTIVE (dev, function_name);
1755
1756 if (dev->read_active)
1757 {
1758 XDBG ((3, "%s: read already active\n", function_name));
1759 return SANE_STATUS_INVAL;
1760 }
1761
1762 dev->read_buffer = (SANE_Byte *) malloc (dev->requested_buffer_size);
1763 if (!dev->read_buffer)
1764 {
1765 XDBG ((3, "%s: not enough memory for the read buffer (%lu bytes)\n",
1766 function_name, (unsigned long) dev->requested_buffer_size));
1767 return SANE_STATUS_NO_MEM;
1768 }
1769
1770 dev->read_active = SANE_TRUE;
1771 dev->read_pos = dev->read_bytes_in_buffer = 0;
1772 dev->read_bytes_left = expected_count;
1773
1774 return SANE_STATUS_GOOD;
1775 }
1776
1777 static void
reader_process_sigterm_handler(int signal)1778 reader_process_sigterm_handler (int signal)
1779 {
1780 XDBG ((1, "reader_process: terminated by signal %d\n", signal));
1781 _exit (SANE_STATUS_GOOD);
1782 }
1783
1784 static void
usb_reader_process_sigterm_handler(int signal)1785 usb_reader_process_sigterm_handler (int signal)
1786 {
1787 XDBG ((1, "reader_process (usb): terminated by signal %d\n", signal));
1788 cancelRead = SANE_TRUE;
1789 }
1790
1791 static SANE_Status
artec48u_device_read_start(Artec48U_Device * dev)1792 artec48u_device_read_start (Artec48U_Device * dev)
1793 {
1794 CHECK_DEV_ACTIVE (dev, "artec48u_device_read_start");
1795
1796 return SANE_STATUS_GOOD;
1797 }
1798
1799 static SANE_Status
artec48u_device_read(Artec48U_Device * dev,SANE_Byte * buffer,size_t * size)1800 artec48u_device_read (Artec48U_Device * dev, SANE_Byte * buffer,
1801 size_t * size)
1802 {
1803 DECLARE_FUNCTION_NAME ("artec48u_device_read") SANE_Status status;
1804 size_t byte_count = 0;
1805 size_t left_to_read = *size;
1806 size_t transfer_size, block_size, raw_block_size;
1807
1808 CHECK_DEV_ACTIVE (dev, function_name);
1809
1810 if (!dev->read_active)
1811 {
1812 XDBG ((3, "%s: read not active\n", function_name));
1813 return SANE_STATUS_INVAL;
1814 }
1815
1816 while (left_to_read > 0)
1817 {
1818 if (dev->read_bytes_in_buffer == 0)
1819 {
1820 block_size = dev->requested_buffer_size;
1821 if (block_size > dev->read_bytes_left)
1822 block_size = dev->read_bytes_left;
1823 if (block_size == 0)
1824 break;
1825 raw_block_size = (block_size + 63UL) & ~63UL;
1826 status = artec48u_device_read_raw (dev, dev->read_buffer,
1827 &raw_block_size);
1828 if (status != SANE_STATUS_GOOD)
1829 {
1830 XDBG ((3, "%s: read failed\n", function_name));
1831 return status;
1832 }
1833 dev->read_pos = 0;
1834 dev->read_bytes_in_buffer = block_size;
1835 dev->read_bytes_left -= block_size;
1836 }
1837
1838 transfer_size = left_to_read;
1839 if (transfer_size > dev->read_bytes_in_buffer)
1840 transfer_size = dev->read_bytes_in_buffer;
1841 if (transfer_size > 0)
1842 {
1843 memcpy (buffer, dev->read_buffer + dev->read_pos, transfer_size);
1844 dev->read_pos += transfer_size;
1845 dev->read_bytes_in_buffer -= transfer_size;
1846 byte_count += transfer_size;
1847 left_to_read -= transfer_size;
1848 buffer += transfer_size;
1849 }
1850 }
1851
1852 *size = byte_count;
1853
1854 if (byte_count == 0)
1855 return SANE_STATUS_EOF;
1856 else
1857 return SANE_STATUS_GOOD;
1858 }
1859
1860 static SANE_Status
artec48u_device_read_finish(Artec48U_Device * dev)1861 artec48u_device_read_finish (Artec48U_Device * dev)
1862 {
1863 DECLARE_FUNCTION_NAME ("artec48u_device_read_finish")
1864 CHECK_DEV_ACTIVE (dev, function_name);
1865
1866 if (!dev->read_active)
1867 {
1868 XDBG ((3, "%s: read not active\n", function_name));
1869 return SANE_STATUS_INVAL;
1870 }
1871
1872 XDBG ((7, "%s: read_bytes_left = %ld\n",
1873 function_name, (long) dev->read_bytes_left));
1874
1875 free (dev->read_buffer);
1876 dev->read_buffer = NULL;
1877
1878 dev->read_active = SANE_FALSE;
1879
1880 return SANE_STATUS_GOOD;
1881 }
1882
1883 static SANE_Status
artec48u_delay_buffer_init(Artec48U_Delay_Buffer * delay,SANE_Int pixels_per_line)1884 artec48u_delay_buffer_init (Artec48U_Delay_Buffer * delay,
1885 SANE_Int pixels_per_line)
1886 {
1887 DECLARE_FUNCTION_NAME ("artec48u_delay_buffer_init")
1888 SANE_Int bytes_per_line;
1889 SANE_Int line_count, i;
1890
1891 if (pixels_per_line <= 0)
1892 {
1893 XDBG ((3, "%s: BUG: pixels_per_line=%d\n",
1894 function_name, pixels_per_line));
1895 return SANE_STATUS_INVAL;
1896 }
1897
1898 bytes_per_line = pixels_per_line * sizeof (unsigned int);
1899
1900 delay->line_count = line_count = 1;
1901 delay->read_index = 0;
1902 delay->write_index = 0;
1903
1904 delay->mem_block = (SANE_Byte *) malloc (bytes_per_line * line_count);
1905 if (!delay->mem_block)
1906 {
1907 XDBG ((3, "%s: no memory for delay block\n", function_name));
1908 return SANE_STATUS_NO_MEM;
1909 }
1910
1911 delay->lines =
1912 (unsigned int **) malloc (sizeof (unsigned int *) * line_count);
1913 if (!delay->lines)
1914 {
1915 free (delay->mem_block);
1916 XDBG ((3, "%s: no memory for delay line pointers\n", function_name));
1917 return SANE_STATUS_NO_MEM;
1918 }
1919
1920 for (i = 0; i < line_count; ++i)
1921 delay->lines[i] =
1922 (unsigned int *) (delay->mem_block + i * bytes_per_line);
1923
1924 return SANE_STATUS_GOOD;
1925 }
1926
1927 static SANE_Status
artec48u_delay_buffer_done(Artec48U_Delay_Buffer * delay)1928 artec48u_delay_buffer_done (Artec48U_Delay_Buffer * delay)
1929 {
1930 if (delay->lines)
1931 {
1932 free (delay->lines);
1933 delay->lines = NULL;
1934 }
1935
1936 if (delay->mem_block)
1937 {
1938 free (delay->mem_block);
1939 delay->mem_block = NULL;
1940 }
1941
1942 return SANE_STATUS_GOOD;
1943 }
1944
1945 #define DELAY_BUFFER_WRITE_PTR(delay) ( (delay)->lines[(delay)->write_index] )
1946
1947 #define DELAY_BUFFER_READ_PTR(delay) ( (delay)->lines[(delay)->read_index ] )
1948
1949 #define DELAY_BUFFER_STEP(delay) \
1950 do { \
1951 (delay)->read_index = ((delay)->read_index + 1) % (delay)->line_count; \
1952 (delay)->write_index = ((delay)->write_index + 1) % (delay)->line_count; \
1953 } while (SANE_FALSE)
1954
1955
1956 static inline void
unpack_8_mono(SANE_Byte * src,unsigned int * dst,SANE_Int pixels_per_line)1957 unpack_8_mono (SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line)
1958 {
1959 XDBG ((3, "unpack_8_mono\n"));
1960 for (; pixels_per_line > 0; ++src, ++dst, --pixels_per_line)
1961 {
1962 *dst = (((unsigned int) *src) << 8) | *src;
1963 }
1964 }
1965
1966 static inline void
unpack_16_le_mono(SANE_Byte * src,unsigned int * dst,SANE_Int pixels_per_line)1967 unpack_16_le_mono (SANE_Byte * src, unsigned int *dst,
1968 SANE_Int pixels_per_line)
1969 {
1970 XDBG ((3, "unpack_16_le_mono\n"));
1971 for (; pixels_per_line > 0; src += 2, dst++, --pixels_per_line)
1972 {
1973 *dst = (((unsigned int) src[1]) << 8) | src[0];
1974 }
1975 }
1976
1977 static SANE_Status
line_read_gray_8(Artec48U_Line_Reader * reader,unsigned int ** buffer_pointers_return)1978 line_read_gray_8 (Artec48U_Line_Reader * reader,
1979 unsigned int **buffer_pointers_return)
1980 {
1981 SANE_Status status;
1982 size_t size;
1983 unsigned int *buffer;
1984 XDBG ((3, "line_read_gray_8\n"));
1985
1986 size = reader->params.scan_bpl;
1987 status = artec48u_device_read (reader->dev, reader->pixel_buffer, &size);
1988 if (status != SANE_STATUS_GOOD)
1989 return status;
1990
1991 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
1992 buffer_pointers_return[0] = buffer;
1993 unpack_8_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
1994
1995 return SANE_STATUS_GOOD;
1996 }
1997
1998 static SANE_Status
line_read_gray_16(Artec48U_Line_Reader * reader,unsigned int ** buffer_pointers_return)1999 line_read_gray_16 (Artec48U_Line_Reader * reader,
2000 unsigned int **buffer_pointers_return)
2001 {
2002 SANE_Status status;
2003 size_t size;
2004 unsigned int *buffer;
2005
2006 XDBG ((3, "line_read_gray_16\n"));
2007 size = reader->params.scan_bpl;
2008 status = artec48u_device_read (reader->dev, reader->pixel_buffer, &size);
2009 if (status != SANE_STATUS_GOOD)
2010 return status;
2011
2012 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay);
2013 buffer_pointers_return[0] = buffer;
2014 unpack_16_le_mono (reader->pixel_buffer, buffer, reader->pixels_per_line);
2015
2016 return SANE_STATUS_GOOD;
2017 }
2018
2019 static SANE_Status
line_read_bgr_8_line_mode(Artec48U_Line_Reader * reader,unsigned int ** buffer_pointers_return)2020 line_read_bgr_8_line_mode (Artec48U_Line_Reader * reader,
2021 unsigned int **buffer_pointers_return)
2022 {
2023 SANE_Status status;
2024 size_t size;
2025 SANE_Int pixels_per_line;
2026 SANE_Byte *pixel_buffer = reader->pixel_buffer;
2027 XDBG ((3, "line_read_bgr_8_line_mode\n"));
2028
2029 size = reader->params.scan_bpl * 3;
2030 status = artec48u_device_read (reader->dev, pixel_buffer, &size);
2031 if (status != SANE_STATUS_GOOD)
2032 return status;
2033
2034 pixels_per_line = reader->pixels_per_line;
2035 unpack_8_mono (pixel_buffer,
2036 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line);
2037 pixel_buffer += reader->params.scan_bpl;
2038 unpack_8_mono (pixel_buffer,
2039 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line);
2040 pixel_buffer += reader->params.scan_bpl;
2041 unpack_8_mono (pixel_buffer,
2042 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line);
2043
2044 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
2045 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
2046 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
2047
2048 DELAY_BUFFER_STEP (&reader->r_delay);
2049 DELAY_BUFFER_STEP (&reader->g_delay);
2050 DELAY_BUFFER_STEP (&reader->b_delay);
2051
2052 return SANE_STATUS_GOOD;
2053 }
2054
2055 static SANE_Status
line_read_bgr_16_line_mode(Artec48U_Line_Reader * reader,unsigned int ** buffer_pointers_return)2056 line_read_bgr_16_line_mode (Artec48U_Line_Reader * reader,
2057 unsigned int **buffer_pointers_return)
2058 {
2059 SANE_Status status;
2060 size_t size;
2061 SANE_Int pixels_per_line;
2062 SANE_Byte *pixel_buffer = reader->pixel_buffer;
2063
2064 XDBG ((3, "line_read_bgr_16_line_mode\n"));
2065 size = reader->params.scan_bpl * 3;
2066 status = artec48u_device_read (reader->dev, pixel_buffer, &size);
2067 if (status != SANE_STATUS_GOOD)
2068 return status;
2069
2070 pixels_per_line = reader->pixels_per_line;
2071 unpack_16_le_mono (pixel_buffer,
2072 DELAY_BUFFER_WRITE_PTR (&reader->b_delay),
2073 pixels_per_line);
2074 pixel_buffer += reader->params.scan_bpl;
2075 unpack_16_le_mono (pixel_buffer,
2076 DELAY_BUFFER_WRITE_PTR (&reader->g_delay),
2077 pixels_per_line);
2078 pixel_buffer += reader->params.scan_bpl;
2079 unpack_16_le_mono (pixel_buffer,
2080 DELAY_BUFFER_WRITE_PTR (&reader->r_delay),
2081 pixels_per_line);
2082
2083 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay);
2084 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay);
2085 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay);
2086
2087 DELAY_BUFFER_STEP (&reader->r_delay);
2088 DELAY_BUFFER_STEP (&reader->g_delay);
2089 DELAY_BUFFER_STEP (&reader->b_delay);
2090
2091 return SANE_STATUS_GOOD;
2092 }
2093
2094 static SANE_Status
artec48u_line_reader_init_delays(Artec48U_Line_Reader * reader)2095 artec48u_line_reader_init_delays (Artec48U_Line_Reader * reader)
2096 {
2097 SANE_Status status;
2098
2099 if (reader->params.color)
2100 {
2101 status = artec48u_delay_buffer_init (&reader->r_delay,
2102 reader->params.pixel_xs);
2103 if (status != SANE_STATUS_GOOD)
2104 return status;
2105
2106 status = artec48u_delay_buffer_init (&reader->g_delay,
2107 reader->params.pixel_xs);
2108 if (status != SANE_STATUS_GOOD)
2109 {
2110 artec48u_delay_buffer_done (&reader->r_delay);
2111 return status;
2112 }
2113
2114 status = artec48u_delay_buffer_init (&reader->b_delay,
2115 reader->params.pixel_xs);
2116 if (status != SANE_STATUS_GOOD)
2117 {
2118 artec48u_delay_buffer_done (&reader->g_delay);
2119 artec48u_delay_buffer_done (&reader->r_delay);
2120 return status;
2121 }
2122 }
2123 else
2124 {
2125 status = artec48u_delay_buffer_init (&reader->g_delay,
2126 reader->params.pixel_xs);
2127 if (status != SANE_STATUS_GOOD)
2128 return status;
2129 }
2130
2131 reader->delays_initialized = SANE_TRUE;
2132
2133 return SANE_STATUS_GOOD;
2134 }
2135
2136 static void
artec48u_line_reader_free_delays(Artec48U_Line_Reader * reader)2137 artec48u_line_reader_free_delays (Artec48U_Line_Reader * reader)
2138 {
2139 if (!reader)
2140 {
2141 return;
2142 }
2143 if (reader->delays_initialized)
2144 {
2145 if (reader->params.color)
2146 {
2147 artec48u_delay_buffer_done (&reader->b_delay);
2148 artec48u_delay_buffer_done (&reader->g_delay);
2149 artec48u_delay_buffer_done (&reader->r_delay);
2150 }
2151 else
2152 {
2153 artec48u_delay_buffer_done (&reader->g_delay);
2154 }
2155 reader->delays_initialized = SANE_FALSE;
2156 }
2157 }
2158
2159 static SANE_Status
artec48u_line_reader_new(Artec48U_Device * dev,Artec48U_Scan_Parameters * params,Artec48U_Line_Reader ** reader_return)2160 artec48u_line_reader_new (Artec48U_Device * dev,
2161 Artec48U_Scan_Parameters * params,
2162 Artec48U_Line_Reader ** reader_return)
2163 {
2164 DECLARE_FUNCTION_NAME ("artec48u_line_reader_new") SANE_Status status;
2165 Artec48U_Line_Reader *reader;
2166 SANE_Int image_size;
2167 SANE_Int scan_bpl_full;
2168
2169 XDBG ((6, "%s: enter\n", function_name));
2170 XDBG ((6, "%s: enter params xdpi: %i\n", function_name, params->xdpi));
2171 XDBG ((6, "%s: enter params ydpi: %i\n", function_name, params->ydpi));
2172 XDBG ((6, "%s: enter params depth: %i\n", function_name, params->depth));
2173 XDBG ((6, "%s: enter params color: %i\n", function_name, params->color));
2174 XDBG ((6, "%s: enter params pixel_xs: %i\n", function_name, params->pixel_xs));
2175 XDBG ((6, "%s: enter params pixel_ys: %i\n", function_name, params->pixel_ys));
2176 XDBG ((6, "%s: enter params scan_xs: %i\n", function_name, params->scan_xs));
2177 XDBG ((6, "%s: enter params scan_ys: %i\n", function_name, params->scan_ys));
2178 XDBG ((6, "%s: enter params scan_bpl: %i\n", function_name, params->scan_bpl));
2179 *reader_return = NULL;
2180
2181 reader = (Artec48U_Line_Reader *) malloc (sizeof (Artec48U_Line_Reader));
2182 if (!reader)
2183 {
2184 XDBG ((3, "%s: cannot allocate Artec48U_Line_Reader\n", function_name));
2185 return SANE_STATUS_NO_MEM;
2186 }
2187 memset (reader, 0, sizeof (Artec48U_Line_Reader));
2188
2189 reader->dev = dev;
2190 memcpy (&reader->params, params, sizeof (Artec48U_Scan_Parameters));
2191 reader->pixel_buffer = 0;
2192 reader->delays_initialized = SANE_FALSE;
2193
2194 reader->read = NULL;
2195
2196 status = artec48u_line_reader_init_delays (reader);
2197 if (status != SANE_STATUS_GOOD)
2198 {
2199 XDBG ((3, "%s: cannot allocate line buffers: %s\n",
2200 function_name, sane_strstatus (status)));
2201 free (reader);
2202 return status;
2203 }
2204
2205 reader->pixels_per_line = reader->params.pixel_xs;
2206
2207 if (!reader->params.color)
2208 {
2209 XDBG ((2, "!reader->params.color\n"));
2210 if (reader->params.depth == 8)
2211 reader->read = line_read_gray_8;
2212 else if (reader->params.depth == 16)
2213 reader->read = line_read_gray_16;
2214 }
2215 else
2216 {
2217 XDBG ((2, "reader line mode\n"));
2218 if (reader->params.depth == 8)
2219 {
2220 XDBG ((2, "depth 8\n"));
2221 reader->read = line_read_bgr_8_line_mode;
2222 }
2223 else if (reader->params.depth == 16)
2224 {
2225 XDBG ((2, "depth 16\n"));
2226 reader->read = line_read_bgr_16_line_mode;
2227 }
2228 }
2229
2230 if (reader->read == NULL)
2231 {
2232 XDBG ((3, "%s: unsupported bit depth (%d)\n",
2233 function_name, reader->params.depth));
2234 artec48u_line_reader_free_delays (reader);
2235 free (reader);
2236 return SANE_STATUS_UNSUPPORTED;
2237 }
2238
2239 scan_bpl_full = reader->params.scan_bpl;
2240 if (reader->params.color)
2241 scan_bpl_full *= 3;
2242
2243 reader->pixel_buffer = malloc (scan_bpl_full);
2244 if (!reader->pixel_buffer)
2245 {
2246 XDBG ((3, "%s: cannot allocate pixel buffer\n", function_name));
2247 artec48u_line_reader_free_delays (reader);
2248 free (reader);
2249 return SANE_STATUS_NO_MEM;
2250 }
2251
2252 artec48u_device_set_read_buffer_size (reader->dev,
2253 scan_bpl_full /* 200 */ );
2254
2255 image_size = scan_bpl_full * reader->params.scan_ys;
2256 status = artec48u_device_read_prepare (reader->dev, image_size);
2257 if (status != SANE_STATUS_GOOD)
2258 {
2259 XDBG ((3, "%s: artec48u_device_read_prepare failed: %s\n",
2260 function_name, sane_strstatus (status)));
2261 free (reader->pixel_buffer);
2262 artec48u_line_reader_free_delays (reader);
2263 free (reader);
2264 return status;
2265 }
2266
2267 XDBG ((6, "%s: leave: ok\n", function_name));
2268 *reader_return = reader;
2269 return SANE_STATUS_GOOD;
2270 }
2271
2272 static SANE_Status
artec48u_line_reader_free(Artec48U_Line_Reader * reader)2273 artec48u_line_reader_free (Artec48U_Line_Reader * reader)
2274 {
2275 DECLARE_FUNCTION_NAME ("artec48u_line_reader_free") SANE_Status status;
2276
2277 XDBG ((6, "%s: enter\n", function_name));
2278
2279 if (!reader)
2280 {
2281 return SANE_STATUS_GOOD;
2282 }
2283 artec48u_line_reader_free_delays (reader);
2284
2285 if (reader->pixel_buffer)
2286 {
2287 free (reader->pixel_buffer);
2288 reader->pixel_buffer = NULL;
2289 }
2290
2291 status = artec48u_device_read_finish (reader->dev);
2292 if (status != SANE_STATUS_GOOD)
2293 {
2294 XDBG ((3, "%s: artec48u_device_read_finish failed: %s\n",
2295 function_name, sane_strstatus (status)));
2296 }
2297
2298 if (reader)
2299 free (reader);
2300
2301 XDBG ((6, "%s: leave\n", function_name));
2302 return status;
2303 }
2304
2305 static SANE_Status
artec48u_line_reader_read(Artec48U_Line_Reader * reader,unsigned int ** buffer_pointers_return)2306 artec48u_line_reader_read (Artec48U_Line_Reader * reader,
2307 unsigned int **buffer_pointers_return)
2308 {
2309 return (*reader->read) (reader, buffer_pointers_return);
2310 }
2311
2312 static SANE_Status
artec48u_scanner_new(Artec48U_Device * dev,Artec48U_Scanner ** scanner_return)2313 artec48u_scanner_new (Artec48U_Device * dev,
2314 Artec48U_Scanner ** scanner_return)
2315 {
2316 DECLARE_FUNCTION_NAME ("artec48u_scanner_new") Artec48U_Scanner *s;
2317
2318 *scanner_return = NULL;
2319
2320 s = (Artec48U_Scanner *) malloc (sizeof (Artec48U_Scanner));
2321 if (!s)
2322 {
2323 XDBG ((5, "%s: no memory for Artec48U_Scanner\n", function_name));
2324 return SANE_STATUS_NO_MEM;
2325 }
2326 s->dev = dev;
2327 s->reader = NULL;
2328 s->scanning = SANE_FALSE;
2329 s->line_buffer = NULL;
2330 s->lineart_buffer = NULL;
2331 s->next = NULL;
2332 s->pipe_handle = NULL;
2333 s->buffer_pointers[0] = NULL;
2334 s->buffer_pointers[1] = NULL;
2335 s->buffer_pointers[2] = NULL;
2336 s->shading_buffer_w = NULL;
2337 s->shading_buffer_b = NULL;
2338 s->shading_buffer_white[0] = NULL;
2339 s->shading_buffer_white[1] = NULL;
2340 s->shading_buffer_white[2] = NULL;
2341 s->shading_buffer_black[0] = NULL;
2342 s->shading_buffer_black[1] = NULL;
2343 s->shading_buffer_black[2] = NULL;
2344 *scanner_return = s;
2345 return SANE_STATUS_GOOD;
2346 }
2347
2348 static SANE_Status
artec48u_scanner_read_line(Artec48U_Scanner * s,unsigned int ** buffer_pointers,SANE_Bool shading)2349 artec48u_scanner_read_line (Artec48U_Scanner * s,
2350 unsigned int **buffer_pointers, SANE_Bool shading)
2351 {
2352 DECLARE_FUNCTION_NAME ("artec48u_scanner_read_line") SANE_Status status;
2353 int i, j, c;
2354
2355 status = artec48u_line_reader_read (s->reader, buffer_pointers);
2356
2357 if (status != SANE_STATUS_GOOD)
2358 {
2359 XDBG ((5, "%s: artec48u_line_reader_read failed: %s\n",
2360 function_name, sane_strstatus (status)));
2361 return status;
2362 }
2363 if (shading != SANE_TRUE)
2364 return status;
2365
2366 c = s->reader->pixels_per_line;
2367 if (s->reader->params.color == SANE_TRUE)
2368 {
2369 for (i = c - 1; i >= 0; i--)
2370 {
2371 for (j = 0; j < 3; j++)
2372 {
2373 int new_value;
2374 unsigned int value = buffer_pointers[j][i];
2375 if (value < s->shading_buffer_black[j][i])
2376 value = s->shading_buffer_black[j][i];
2377 if (value > s->shading_buffer_white[j][i])
2378 value = s->shading_buffer_white[j][i];
2379 new_value =
2380 (double) (value -
2381 s->shading_buffer_black[j][i]) * 65535.0 /
2382 (double) (s->shading_buffer_white[j][i] -
2383 s->shading_buffer_black[j][i]);
2384 if (new_value < 0)
2385 new_value = 0;
2386 if (new_value > 65535)
2387 new_value = 65535;
2388 new_value =
2389 s->gamma_array[j +
2390 1][s->contrast_array[s->
2391 brightness_array
2392 [new_value]]];
2393 new_value = s->gamma_array[0][new_value];
2394 buffer_pointers[j][i] = new_value;
2395 }
2396 }
2397 }
2398 else
2399 {
2400 for (i = c - 1; i >= 0; i--)
2401 {
2402 int new_value;
2403 unsigned int value = buffer_pointers[0][i];
2404 new_value =
2405 (double) (value -
2406 s->shading_buffer_black[1][i]) * 65535.0 /
2407 (double) (s->shading_buffer_white[1][i] -
2408 s->shading_buffer_black[1][i]);
2409 if (new_value < 0)
2410 new_value = 0;
2411 if (new_value > 65535)
2412 new_value = 65535;
2413 new_value =
2414 s->gamma_array[0][s->
2415 contrast_array[s->brightness_array[new_value]]];
2416 buffer_pointers[0][i] = new_value;
2417 }
2418 }
2419 return status;
2420 }
2421
2422 static SANE_Status
artec48u_scanner_free(Artec48U_Scanner * s)2423 artec48u_scanner_free (Artec48U_Scanner * s)
2424 {
2425 DECLARE_FUNCTION_NAME ("artec48u_scanner_free") if (!s)
2426 {
2427 XDBG ((5, "%s: scanner==NULL\n", function_name));
2428 return SANE_STATUS_INVAL;
2429 }
2430
2431 if (s->reader)
2432 {
2433 artec48u_line_reader_free (s->reader);
2434 s->reader = NULL;
2435 }
2436
2437 free (s->shading_buffer_w);
2438 free (s->shading_buffer_b);
2439 free (s->shading_buffer_white[0]);
2440 free (s->shading_buffer_black[0]);
2441 free (s->shading_buffer_white[1]);
2442 free (s->shading_buffer_black[1]);
2443 free (s->shading_buffer_white[2]);
2444 free (s->shading_buffer_black[2]);
2445
2446 if (s->line_buffer)
2447 free (s->line_buffer);
2448 if (s->lineart_buffer)
2449 free (s->lineart_buffer);
2450
2451 free (s);
2452
2453 return SANE_STATUS_GOOD;
2454 }
2455
2456 static SANE_Status
artec48u_scanner_internal_start_scan(Artec48U_Scanner * s)2457 artec48u_scanner_internal_start_scan (Artec48U_Scanner * s)
2458 {
2459 DECLARE_FUNCTION_NAME ("artec48u_scanner_internal_start_scan")
2460 SANE_Status status;
2461 SANE_Bool ready;
2462 SANE_Int repeat_count;
2463
2464 status = artec48u_wait_for_positioning (s->dev);
2465 if (status != SANE_STATUS_GOOD)
2466 {
2467 XDBG ((2, "%s: artec48u_scanner_wait_for_positioning error: %s\n",
2468 function_name, sane_strstatus (status)));
2469 return status;
2470 }
2471
2472 status = artec48u_generic_start_scan (s->dev);
2473 if (status != SANE_STATUS_GOOD)
2474 {
2475 XDBG ((2, "%s: artec48u_device_start_scan error: %s\n",
2476 function_name, sane_strstatus (status)));
2477 return status;
2478 }
2479
2480 for (repeat_count = 0; repeat_count < 30 * 10; ++repeat_count)
2481 {
2482 status = artec48u_generic_read_scanned_data (s->dev, &ready);
2483 if (status != SANE_STATUS_GOOD)
2484 {
2485 XDBG ((2, "%s: artec48u_device_read_scanned_data error: %s\n",
2486 function_name, sane_strstatus (status)));
2487 return status;
2488 }
2489 if (ready)
2490 break;
2491 usleep (100000);
2492 }
2493
2494 if (!ready)
2495 {
2496 XDBG ((2, "%s: scanner still not ready - giving up\n", function_name));
2497 return SANE_STATUS_DEVICE_BUSY;
2498 }
2499
2500 status = artec48u_device_read_start (s->dev);
2501 if (status != SANE_STATUS_GOOD)
2502 {
2503 XDBG ((2, "%s: artec48u_device_read_start error: %s\n",
2504 function_name, sane_strstatus (status)));
2505 return status;
2506 }
2507
2508 return SANE_STATUS_GOOD;
2509 }
2510
2511 static SANE_Status
artec48u_scanner_start_scan_extended(Artec48U_Scanner * s,Artec48U_Scan_Request * request,Artec48U_Scan_Action action,Artec48U_Scan_Parameters * params)2512 artec48u_scanner_start_scan_extended (Artec48U_Scanner * s,
2513 Artec48U_Scan_Request * request,
2514 Artec48U_Scan_Action action,
2515 Artec48U_Scan_Parameters * params)
2516 {
2517 DECLARE_FUNCTION_NAME ("artec48u_scanner_start_scan_extended")
2518 SANE_Status status;
2519
2520 status = artec48u_wait_for_positioning (s->dev);
2521 if (status != SANE_STATUS_GOOD)
2522 {
2523 XDBG ((2, "%s: artec48u_scanner_wait_for_positioning error: %s\n",
2524 function_name, sane_strstatus (status)));
2525 return status;
2526 }
2527
2528 if (action == SA_SCAN)
2529 status = artec48u_setup_scan (s, request, action, SANE_FALSE, params);
2530 if (status != SANE_STATUS_GOOD)
2531 {
2532 XDBG ((2, "%s: artec48u_device_setup_scan failed: %s\n", function_name,
2533 sane_strstatus (status)));
2534 return status;
2535 }
2536 status = artec48u_line_reader_new (s->dev, params, &s->reader);
2537 if (status != SANE_STATUS_GOOD)
2538 {
2539 XDBG ((2, "%s: artec48u_line_reader_new failed: %s\n", function_name,
2540 sane_strstatus (status)));
2541 return status;
2542 }
2543
2544 status = artec48u_scanner_internal_start_scan (s);
2545
2546 if (status != SANE_STATUS_GOOD)
2547 {
2548 XDBG ((2, "%s: artec48u_scanner_internal_start_scan failed: %s\n",
2549 function_name, sane_strstatus (status)));
2550 return status;
2551 }
2552
2553 return SANE_STATUS_GOOD;
2554 }
2555
2556 static SANE_Status
artec48u_scanner_start_scan(Artec48U_Scanner * s,Artec48U_Scan_Request * request,Artec48U_Scan_Parameters * params)2557 artec48u_scanner_start_scan (Artec48U_Scanner * s,
2558 Artec48U_Scan_Request * request,
2559 Artec48U_Scan_Parameters * params)
2560 {
2561 return artec48u_scanner_start_scan_extended (s, request, SA_SCAN, params);
2562 }
2563
2564
2565 static SANE_Status
artec48u_scanner_stop_scan(Artec48U_Scanner * s)2566 artec48u_scanner_stop_scan (Artec48U_Scanner * s)
2567 {
2568 XDBG ((1, "artec48u_scanner_stop_scan begin: \n"));
2569 artec48u_line_reader_free (s->reader);
2570 s->reader = NULL;
2571
2572 return artec48u_stop_scan (s->dev);
2573 }
2574
2575 static void
calculateGamma(Artec48U_Scanner * s)2576 calculateGamma (Artec48U_Scanner * s)
2577 {
2578 double d;
2579 int gval;
2580 unsigned int i;
2581
2582 double gamma = SANE_UNFIX (s->val[OPT_GAMMA].w);
2583
2584 d = 65536.0 / pow (65536.0, 1.0 / gamma);
2585 for (i = 0; i < 65536; i++)
2586 {
2587 gval = (int) (pow ((double) i, 1.0 / gamma) * d);
2588 s->gamma_array[0][i] = gval;
2589 }
2590 }
2591
2592 static void
calculateGammaRed(Artec48U_Scanner * s)2593 calculateGammaRed (Artec48U_Scanner * s)
2594 {
2595 double d;
2596 int gval;
2597 unsigned int i;
2598
2599 double gamma = SANE_UNFIX (s->val[OPT_GAMMA_R].w);
2600
2601 d = 65536.0 / pow (65536.0, 1.0 / gamma);
2602 for (i = 0; i < 65536; i++)
2603 {
2604 gval = (int) (pow ((double) i, 1.0 / gamma) * d);
2605 s->gamma_array[1][i] = gval;
2606 }
2607 }
2608
2609 static void
calculateGammaGreen(Artec48U_Scanner * s)2610 calculateGammaGreen (Artec48U_Scanner * s)
2611 {
2612 double d;
2613 int gval;
2614 unsigned int i;
2615
2616 double gamma = SANE_UNFIX (s->val[OPT_GAMMA_G].w);
2617
2618 d = 65536.0 / pow (65536.0, 1.0 / gamma);
2619 for (i = 0; i < 65536; i++)
2620 {
2621 gval = (int) (pow ((double) i, 1.0 / gamma) * d);
2622 s->gamma_array[2][i] = gval;
2623 }
2624 }
2625
2626 static void
calculateGammaBlue(Artec48U_Scanner * s)2627 calculateGammaBlue (Artec48U_Scanner * s)
2628 {
2629 double d;
2630 int gval;
2631 unsigned int i;
2632
2633 double gamma = SANE_UNFIX (s->val[OPT_GAMMA_B].w);
2634
2635 d = 65536.0 / pow (65536.0, 1.0 / gamma);
2636 for (i = 0; i < 65536; i++)
2637 {
2638 gval = (int) (pow ((double) i, 1.0 / gamma) * d);
2639 s->gamma_array[3][i] = gval;
2640 }
2641 }
2642
2643 static SANE_Status
artec48u_calculate_shading_buffer(Artec48U_Scanner * s,int start,int end,int resolution,SANE_Bool color)2644 artec48u_calculate_shading_buffer (Artec48U_Scanner * s, int start, int end,
2645 int resolution, SANE_Bool color)
2646 {
2647 int i;
2648 int c;
2649 int bpp;
2650 c = 0;
2651 bpp = 6;
2652 switch (resolution)
2653 {
2654 case 50:
2655 bpp = 72;
2656 break;
2657 case 100:
2658 bpp = 36;
2659 break;
2660 case 200:
2661 bpp = 18;
2662 break;
2663 case 300:
2664 bpp = 12;
2665 break;
2666 case 600:
2667 bpp = 6;
2668 break;
2669 case 1200:
2670 if(s->dev->is_epro == 0)
2671 bpp = 6;
2672 else
2673 bpp = 3;
2674 }
2675
2676 for (i = start * bpp; i < end * bpp; i += bpp)
2677 {
2678 if (color)
2679 {
2680 s->shading_buffer_white[0][c] =
2681 (unsigned int) s->shading_buffer_w[i] +
2682 ((((unsigned int) s->shading_buffer_w[i + 1]) << 8));
2683 s->shading_buffer_white[2][c] =
2684 (unsigned int) s->shading_buffer_w[i + 4] +
2685 ((((unsigned int) s->shading_buffer_w[i + 5]) << 8));
2686 s->shading_buffer_black[0][c] =
2687 (unsigned int) s->shading_buffer_b[i] +
2688 ((((unsigned int) s->shading_buffer_b[i + 1]) << 8));
2689 s->shading_buffer_black[2][c] =
2690 (unsigned int) s->shading_buffer_b[i + 4] +
2691 ((((unsigned int) s->shading_buffer_b[i + 5]) << 8));
2692 }
2693 s->shading_buffer_white[1][c] =
2694 (unsigned int) s->shading_buffer_w[i + 2] +
2695 ((((unsigned int) s->shading_buffer_w[i + 3]) << 8));
2696 s->shading_buffer_black[1][c] =
2697 (unsigned int) s->shading_buffer_b[i + 2] +
2698 ((((unsigned int) s->shading_buffer_b[i + 3]) << 8));
2699 ++c;
2700 }
2701 return SANE_STATUS_GOOD;
2702 }
2703
2704 static size_t
max_string_size(const SANE_String_Const strings[])2705 max_string_size (const SANE_String_Const strings[])
2706 {
2707 size_t size, max_size = 0;
2708 SANE_Int i;
2709
2710 for (i = 0; strings[i]; ++i)
2711 {
2712 size = strlen (strings[i]) + 1;
2713 if (size > max_size)
2714 max_size = size;
2715 }
2716 return max_size;
2717 }
2718
2719 static SANE_Status
init_options(Artec48U_Scanner * s)2720 init_options (Artec48U_Scanner * s)
2721 {
2722 int i;
2723
2724 XDBG ((5, "init_options: scanner %p\n", (void *) s));
2725 XDBG ((5, "init_options: start\n"));
2726 XDBG ((5, "init_options: num options %i\n", NUM_OPTIONS));
2727
2728 memset (s->val, 0, sizeof (s->val));
2729 memset (s->opt, 0, sizeof (s->opt));
2730
2731 for (i = 0; i < NUM_OPTIONS; ++i)
2732 {
2733 s->opt[i].size = sizeof (SANE_Word);
2734 s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
2735 }
2736 s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
2737 s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
2738 s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
2739 s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
2740 s->opt[OPT_NUM_OPTS].unit = SANE_UNIT_NONE;
2741 s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
2742 s->opt[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE;
2743 s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
2744
2745 s->opt[OPT_MODE_GROUP].name = "scanmode-group";
2746 s->opt[OPT_MODE_GROUP].title = SANE_TITLE_SCAN_MODE;
2747 s->opt[OPT_MODE_GROUP].desc = "";
2748 s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
2749 s->opt[OPT_MODE_GROUP].size = 0;
2750 s->opt[OPT_MODE_GROUP].unit = SANE_UNIT_NONE;
2751 s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
2752 s->opt[OPT_MODE_GROUP].cap = 0;
2753
2754 s->opt[OPT_SCAN_MODE].name = SANE_NAME_SCAN_MODE;
2755 s->opt[OPT_SCAN_MODE].title = SANE_TITLE_SCAN_MODE;
2756 s->opt[OPT_SCAN_MODE].desc = SANE_DESC_SCAN_MODE;
2757 s->opt[OPT_SCAN_MODE].type = SANE_TYPE_STRING;
2758 s->opt[OPT_SCAN_MODE].size = max_string_size (mode_list);
2759 s->opt[OPT_SCAN_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
2760 s->opt[OPT_SCAN_MODE].constraint.string_list = mode_list;
2761 s->val[OPT_SCAN_MODE].s = strdup (mode_list[1]);
2762
2763 s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
2764 s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
2765 s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
2766 s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
2767 s->opt[OPT_BIT_DEPTH].unit = SANE_UNIT_NONE;
2768 s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
2769 s->opt[OPT_BIT_DEPTH].constraint.word_list = bitdepth_list;
2770 s->val[OPT_BIT_DEPTH].w = bitdepth_list[1];
2771
2772 /* black level (lineart only) */
2773 s->opt[OPT_BLACK_LEVEL].name = SANE_NAME_BLACK_LEVEL;
2774 s->opt[OPT_BLACK_LEVEL].title = SANE_TITLE_BLACK_LEVEL;
2775 s->opt[OPT_BLACK_LEVEL].desc = SANE_DESC_BLACK_LEVEL;
2776 s->opt[OPT_BLACK_LEVEL].type = SANE_TYPE_INT;
2777 s->opt[OPT_BLACK_LEVEL].unit = SANE_UNIT_NONE;
2778 s->opt[OPT_BLACK_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE;
2779 s->opt[OPT_BLACK_LEVEL].constraint.range = &blacklevel_range;
2780 s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE;
2781 s->val[OPT_BLACK_LEVEL].w = 127;
2782
2783 s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
2784 s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
2785 s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
2786 s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
2787 s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
2788 s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
2789 s->opt[OPT_RESOLUTION].constraint.word_list = resbit_list;
2790 s->val[OPT_RESOLUTION].w = resbit_list[1];
2791
2792 /* "Enhancement" group: */
2793 s->opt[OPT_ENHANCEMENT_GROUP].name = "enhancement-group";
2794 s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
2795 s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
2796 s->opt[OPT_ENHANCEMENT_GROUP].size = 0;
2797 s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
2798 s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
2799 s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
2800
2801 /* brightness */
2802 s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
2803 s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
2804 s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
2805 s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
2806 s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
2807 s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
2808 s->opt[OPT_BRIGHTNESS].constraint.range = &brightness_contrast_range;
2809 s->val[OPT_BRIGHTNESS].w = 0;
2810
2811 /* contrast */
2812 s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
2813 s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
2814 s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
2815 s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
2816 s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
2817 s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
2818 s->opt[OPT_CONTRAST].constraint.range = &brightness_contrast_range;
2819 s->val[OPT_CONTRAST].w = 0;
2820
2821 /* master analog gamma */
2822 s->opt[OPT_GAMMA].name = SANE_NAME_ANALOG_GAMMA;
2823 s->opt[OPT_GAMMA].title = SANE_TITLE_ANALOG_GAMMA;
2824 s->opt[OPT_GAMMA].desc = SANE_DESC_ANALOG_GAMMA;
2825 s->opt[OPT_GAMMA].type = SANE_TYPE_FIXED;
2826 s->opt[OPT_GAMMA].unit = SANE_UNIT_NONE;
2827 s->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_RANGE;
2828 s->opt[OPT_GAMMA].constraint.range = &gamma_range;
2829 s->val[OPT_GAMMA].w = SANE_FIX (s->dev->gamma_master);
2830 s->opt[OPT_GAMMA].size = sizeof (SANE_Word);
2831
2832 /* red analog gamma */
2833 s->opt[OPT_GAMMA_R].name = SANE_NAME_ANALOG_GAMMA_R;
2834 s->opt[OPT_GAMMA_R].title = SANE_TITLE_ANALOG_GAMMA_R;
2835 s->opt[OPT_GAMMA_R].desc = SANE_DESC_ANALOG_GAMMA_R;
2836 s->opt[OPT_GAMMA_R].type = SANE_TYPE_FIXED;
2837 s->opt[OPT_GAMMA_R].unit = SANE_UNIT_NONE;
2838 s->opt[OPT_GAMMA_R].constraint_type = SANE_CONSTRAINT_RANGE;
2839 s->opt[OPT_GAMMA_R].constraint.range = &gamma_range;
2840 s->val[OPT_GAMMA_R].w = SANE_FIX (s->dev->gamma_r);
2841
2842 /* green analog gamma */
2843 s->opt[OPT_GAMMA_G].name = SANE_NAME_ANALOG_GAMMA_G;
2844 s->opt[OPT_GAMMA_G].title = SANE_TITLE_ANALOG_GAMMA_G;
2845 s->opt[OPT_GAMMA_G].desc = SANE_DESC_ANALOG_GAMMA_G;
2846 s->opt[OPT_GAMMA_G].type = SANE_TYPE_FIXED;
2847 s->opt[OPT_GAMMA_G].unit = SANE_UNIT_NONE;
2848 s->opt[OPT_GAMMA_G].constraint_type = SANE_CONSTRAINT_RANGE;
2849 s->opt[OPT_GAMMA_G].constraint.range = &gamma_range;
2850 s->val[OPT_GAMMA_G].w = SANE_FIX (s->dev->gamma_g);
2851
2852 /* blue analog gamma */
2853 s->opt[OPT_GAMMA_B].name = SANE_NAME_ANALOG_GAMMA_B;
2854 s->opt[OPT_GAMMA_B].title = SANE_TITLE_ANALOG_GAMMA_B;
2855 s->opt[OPT_GAMMA_B].desc = SANE_DESC_ANALOG_GAMMA_B;
2856 s->opt[OPT_GAMMA_B].type = SANE_TYPE_FIXED;
2857 s->opt[OPT_GAMMA_B].unit = SANE_UNIT_NONE;
2858 s->opt[OPT_GAMMA_B].constraint_type = SANE_CONSTRAINT_RANGE;
2859 s->opt[OPT_GAMMA_B].constraint.range = &gamma_range;
2860 s->val[OPT_GAMMA_B].w = SANE_FIX (s->dev->gamma_b);
2861
2862 s->opt[OPT_DEFAULT_ENHANCEMENTS].name = "default-enhancements";
2863 s->opt[OPT_DEFAULT_ENHANCEMENTS].title = SANE_I18N ("Defaults");
2864 s->opt[OPT_DEFAULT_ENHANCEMENTS].desc =
2865 SANE_I18N ("Set default values for enhancement controls.");
2866 s->opt[OPT_DEFAULT_ENHANCEMENTS].size = 0;
2867 s->opt[OPT_DEFAULT_ENHANCEMENTS].type = SANE_TYPE_BUTTON;
2868 s->opt[OPT_DEFAULT_ENHANCEMENTS].unit = SANE_UNIT_NONE;
2869 s->opt[OPT_DEFAULT_ENHANCEMENTS].constraint_type = SANE_CONSTRAINT_NONE;
2870
2871 /* "Geometry" group: */
2872 s->opt[OPT_GEOMETRY_GROUP].name = "geometry-group";
2873 s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
2874 s->opt[OPT_GEOMETRY_GROUP].desc = "";
2875 s->opt[OPT_GEOMETRY_GROUP].size = 0;
2876 s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
2877 s->opt[OPT_GEOMETRY_GROUP].cap = 0;
2878
2879 /* top-left x */
2880 s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
2881 s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
2882 s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
2883 s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
2884 s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
2885 s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
2886 s->opt[OPT_TL_X].constraint.range = &scan_range_x;
2887 s->val[OPT_TL_X].w = SANE_FIX (0.0);
2888
2889 /* top-left y */
2890 s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
2891 s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
2892 s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
2893 s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
2894 s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
2895 s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
2896 s->opt[OPT_TL_Y].constraint.range = &scan_range_y;
2897 s->val[OPT_TL_Y].w = SANE_FIX (0.0);
2898
2899 /* bottom-right x */
2900 s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
2901 s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
2902 s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
2903 s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
2904 s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
2905 s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
2906 s->opt[OPT_BR_X].constraint.range = &scan_range_x;
2907 s->val[OPT_BR_X].w = SANE_FIX (50.0);
2908
2909 /* bottom-right y */
2910 s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
2911 s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
2912 s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
2913 s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
2914 s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
2915 s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
2916 s->opt[OPT_BR_Y].constraint.range = &scan_range_y;
2917 s->val[OPT_BR_Y].w = SANE_FIX (50.0);
2918
2919 /* "Calibration" group: */
2920 s->opt[OPT_CALIBRATION_GROUP].name = "calibration-group";
2921 s->opt[OPT_CALIBRATION_GROUP].title = SANE_I18N ("Calibration");
2922 s->opt[OPT_CALIBRATION_GROUP].desc = "";
2923 s->opt[OPT_CALIBRATION_GROUP].size = 0;
2924 s->opt[OPT_CALIBRATION_GROUP].type = SANE_TYPE_GROUP;
2925 s->opt[OPT_CALIBRATION_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
2926 s->opt[OPT_CALIBRATION_GROUP].cap = 0;
2927
2928 /* calibrate */
2929 s->opt[OPT_CALIBRATE].name = "calibration";
2930 s->opt[OPT_CALIBRATE].title = SANE_I18N ("Calibrate before next scan");
2931 s->opt[OPT_CALIBRATE].desc =
2932 SANE_I18N ("If enabled, the device will be calibrated before the "
2933 "next scan. Otherwise, calibration is performed "
2934 "only before the first start.");
2935 s->opt[OPT_CALIBRATE].type = SANE_TYPE_BOOL;
2936 s->opt[OPT_CALIBRATE].unit = SANE_UNIT_NONE;
2937 s->opt[OPT_CALIBRATE].constraint_type = SANE_CONSTRAINT_NONE;
2938 s->val[OPT_CALIBRATE].w = SANE_FALSE;
2939
2940 /* calibrate */
2941 s->opt[OPT_CALIBRATE_SHADING].name = "calibration-shading";
2942 s->opt[OPT_CALIBRATE_SHADING].title =
2943 SANE_I18N ("Only perform shading-correction");
2944 s->opt[OPT_CALIBRATE_SHADING].desc =
2945 SANE_I18N ("If enabled, only the shading correction is "
2946 "performed during calibration. The default values "
2947 "for gain, offset and exposure time, "
2948 "either built-in or from the configuration file, "
2949 "are used.");
2950 s->opt[OPT_CALIBRATE_SHADING].type = SANE_TYPE_BOOL;
2951 s->opt[OPT_CALIBRATE_SHADING].unit = SANE_UNIT_NONE;
2952 s->opt[OPT_CALIBRATE_SHADING].constraint_type = SANE_CONSTRAINT_NONE;
2953 s->val[OPT_CALIBRATE_SHADING].w = SANE_FALSE;
2954 #ifdef ARTEC48U_USE_BUTTONS
2955 s->opt[OPT_BUTTON_STATE].name = "button-state";
2956 s->opt[OPT_BUTTON_STATE].title = SANE_I18N ("Button state");
2957 s->opt[OPT_BUTTON_STATE].type = SANE_TYPE_INT;
2958 s->opt[OPT_BUTTON_STATE].unit = SANE_UNIT_NONE;
2959 s->opt[OPT_BUTTON_STATE].constraint_type = SANE_CONSTRAINT_NONE;
2960 s->opt[OPT_BUTTON_STATE].cap = SANE_CAP_SOFT_DETECT;
2961 s->val[OPT_BUTTON_STATE].w = 0;
2962 #endif
2963 return SANE_STATUS_GOOD;
2964 }
2965
2966 static void
calculate_brightness(Artec48U_Scanner * s)2967 calculate_brightness (Artec48U_Scanner * s)
2968 {
2969 long cnt;
2970 double bright;
2971
2972 bright = (double) s->val[OPT_BRIGHTNESS].w;
2973
2974 bright *= 257.0;
2975 for (cnt = 0; cnt < 65536; cnt++)
2976 {
2977 if (bright < 0.0)
2978 s->brightness_array[cnt] =
2979 (int) (((double) cnt * (65535.0 + bright)) / 65535.0);
2980 else
2981 s->brightness_array[cnt] =
2982 (int) ((double) cnt +
2983 ((65535.0 - (double) cnt) * bright) / 65535.0);
2984 if (s->brightness_array[cnt] > 65535)
2985 s->brightness_array[cnt] = 65535;
2986 if (s->brightness_array[cnt] < 0)
2987 s->brightness_array[cnt] = 0;
2988 }
2989 }
2990
2991 static void
calculate_contrast(Artec48U_Scanner * s)2992 calculate_contrast (Artec48U_Scanner * s)
2993 {
2994 int val;
2995 double p;
2996 int cnt;
2997 double contr;
2998
2999 contr = (double) s->val[OPT_CONTRAST].w;
3000
3001 contr *= 257.0;
3002
3003 for (cnt = 0; cnt < 65536; cnt++)
3004 {
3005 if (contr < 0.0)
3006 {
3007 val = (int) (cnt > 32769) ? (65535 - cnt) : cnt;
3008 val = (int) (32769.0 * pow ((double) (val ? val : 1) / 32769.0,
3009 (32769.0 + contr) / 32769.0));
3010 s->contrast_array[cnt] = (cnt > 32769) ? (65535 - val) : val;
3011 if (s->contrast_array[cnt] > 65535)
3012 s->contrast_array[cnt] = 65535;
3013 if (s->contrast_array[cnt] < 0)
3014 s->contrast_array[cnt] = 0;
3015 }
3016 else
3017 {
3018 val = (cnt > 32769) ? (65535 - cnt) : cnt;
3019 p = ((int) contr == 32769) ? 32769.0 : 32769.0 / (32769.0 - contr);
3020 val = (int) (32769.0 * pow ((double) val / 32769.0, p));
3021 s->contrast_array[cnt] = (cnt > 32639) ? (65535 - val) : val;
3022 if (s->contrast_array[cnt] > 65535)
3023 s->contrast_array[cnt] = 65535;
3024 if (s->contrast_array[cnt] < 0)
3025 s->contrast_array[cnt] = 0;
3026 }
3027 }
3028 }
3029
3030 /*
3031 The calibration function
3032 Disclaimer: the following might be complete crap :-)
3033 -Gain, offset, exposure time
3034 It seems, that the gain values are actually constants. The windows driver always
3035 uses the values 0x0a,0x03,0x03, during calibration as well as during a normal
3036 scan. The exposure values are set to 0x04 for black calibration. It's not necessary to
3037 move the scan head during this stage.
3038 Calibration starts with default values for offset/exposure. These values are
3039 increased/decreased until the white and black values are within a specific range, defined
3040 by WHITE_MIN, WHITE_MAX, BLACK_MIN and BLACK_MAX.
3041
3042 -White shading correction
3043 The scanning head is moved some lines over the calibration strip. Some lines
3044 are scanned at 600dpi/16bit over the full width. The average values are used for the
3045 shading buffer. The normal exposure values are used.
3046 -Black shading correction
3047 Works like the white shading correction, with the difference, that the red-, green-
3048 and blue exposure time is set to 0x04 (the value is taken from the windoze driver).
3049 -Since we do this over the whole width of the image with the maximal optical resolution,
3050 we can use the shading data for every scan, independent of the size, position or resolution,
3051 because we have the shading values for every sensor/LED.
3052
3053 Note:
3054 For a CIS device, it's sufficient to determine those values once. It's not necessary, to
3055 repeat the calibration sequence before every new scan. The windoze driver even saves the values
3056 to various files to avoid the quite lengthy calibration sequence. This backend can also save
3057 the values to files. For this purpose, the user has to create a hidden directory called
3058 .artec-eplus48u in his/her home directory. If the user insists on calibration
3059 before every new scan, he/she can enable a specific option in the backend.
3060 */
3061 static SANE_Status
calibrate_scanner(SANE_Handle handle)3062 calibrate_scanner (SANE_Handle handle)
3063 {
3064 Artec48U_Scanner *s = handle;
3065 unsigned int *buffer_pointers[3];
3066 int avg_black[3];
3067 int avg_white[3];
3068 int exp_off;
3069 int c;
3070 int finish = 0;
3071 int noloop = 0;
3072
3073
3074 if ((s->val[OPT_CALIBRATE].w == SANE_TRUE) &&
3075 (s->val[OPT_CALIBRATE_SHADING].w == SANE_FALSE))
3076 {
3077 while (finish == 0)
3078 {
3079 finish = 1;
3080 /*get black values */
3081 artec48u_carriage_home (s->dev);
3082
3083 artec48u_wait_for_positioning (s->dev);
3084 s->reader = NULL;
3085
3086 s->scanning = SANE_TRUE;
3087
3088 init_shading_buffer (s);
3089
3090 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_BLACK,
3091 SANE_FALSE, &(s->params));
3092 artec48u_scanner_start_scan_extended (s, &(s->request),
3093 SA_CALIBRATE_SCAN_OFFSET_1,
3094 &(s->params));
3095
3096 for (c = 0; c < s->dev->shading_lines_b; c++)
3097 {
3098 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE);
3099 /* we abuse the shading buffer for the offset calculation */
3100 add_to_shading_buffer (s, buffer_pointers);
3101 }
3102 artec48u_scanner_stop_scan (s);
3103 finish_offset_buffer (s, &avg_black[0], &avg_black[1],
3104 &avg_black[2]);
3105 s->scanning = SANE_FALSE;
3106 XDBG ((1, "avg_r: %i, avg_g: %i, avg_b: %i\n", avg_black[0],
3107 avg_black[1], avg_black[2]));
3108 /*adjust offset */
3109 for (c = 0; c < 3; c++)
3110 {
3111 if (c == 0)
3112 {
3113 if (avg_black[c] < BLACK_MIN)
3114 {
3115 s->dev->afe_params.r_offset -= 1;
3116 finish = 0;
3117 XDBG ((1, "adjust offset r: -1\n"));
3118 }
3119 else if (avg_black[c] > BLACK_MAX)
3120 {
3121 s->dev->afe_params.r_offset += 1;
3122 finish = 0;
3123 XDBG ((1, "adjust offset r: +1\n"));
3124 }
3125 }
3126 if (c == 1)
3127 {
3128 if (avg_black[c] < BLACK_MIN)
3129 {
3130 s->dev->afe_params.g_offset -= 1;
3131 finish = 0;
3132 XDBG ((1, "adjust offset g: -1\n"));
3133 }
3134 else if (avg_black[c] > BLACK_MAX)
3135 {
3136 s->dev->afe_params.g_offset += 1;
3137 finish = 0;
3138 XDBG ((1, "adjust offset g: +1\n"));
3139 }
3140 }
3141 if (c == 2)
3142 {
3143 if (avg_black[c] < BLACK_MIN)
3144 {
3145 s->dev->afe_params.b_offset -= 1;
3146 finish = 0;
3147 XDBG ((1, "adjust offset b: -1\n"));
3148 }
3149 else if (avg_black[c] > BLACK_MAX)
3150 {
3151 s->dev->afe_params.b_offset += 1;
3152 finish = 0;
3153 XDBG ((1, "adjust offset b: +1\n"));
3154 }
3155 }
3156 }
3157
3158 /*adjust exposure */
3159 /*get white values */
3160
3161 artec48u_carriage_home (s->dev);
3162
3163 artec48u_wait_for_positioning (s->dev);
3164 s->reader = NULL;
3165
3166 s->scanning = SANE_TRUE;
3167
3168 init_shading_buffer (s);
3169
3170 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_WHITE,
3171 SANE_FALSE, &(s->params));
3172 artec48u_scanner_start_scan_extended (s, &(s->request),
3173 SA_CALIBRATE_SCAN_EXPOSURE_1,
3174 &(s->params));
3175
3176 for (c = 0; c < s->dev->shading_lines_w; c++)
3177 {
3178 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE);
3179 /* we abuse the shading buffer for the exposure calculation */
3180 add_to_shading_buffer (s, buffer_pointers);
3181 }
3182 artec48u_scanner_stop_scan (s);
3183 finish_exposure_buffer (s, &avg_white[0], &avg_white[1],
3184 &avg_white[2]);
3185 s->scanning = SANE_FALSE;
3186 XDBG ((1, "avg_r: %i, avg_g: %i, avg_b: %i\n", avg_white[0],
3187 avg_white[1], avg_white[2]));
3188 for (c = 0; c < 3; c++)
3189 {
3190 if (c == 0)
3191 {
3192 if (avg_white[c] < WHITE_MIN)
3193 {
3194 exp_off =
3195 ((WHITE_MAX + WHITE_MIN) / 2 -
3196 avg_white[c]) / EXPOSURE_STEP;
3197 if (exp_off < 1)
3198 exp_off = 1;
3199 s->dev->exp_params.r_time += exp_off;
3200 finish = 0;
3201 XDBG ((1, "adjust exposure r: ++\n"));
3202 }
3203 else if (avg_white[c] > WHITE_MAX)
3204 {
3205 exp_off =
3206 (avg_white[c] -
3207 (WHITE_MAX + WHITE_MIN) / 2) / EXPOSURE_STEP;
3208 if (exp_off < 1)
3209 exp_off = 1;
3210 s->dev->exp_params.r_time -= exp_off;
3211 finish = 0;
3212 XDBG ((1, "adjust exposure r: --\n"));
3213 }
3214 }
3215 else if (c == 1)
3216 {
3217 if (avg_white[c] < WHITE_MIN)
3218 {
3219 exp_off =
3220 ((WHITE_MAX + WHITE_MIN) / 2 -
3221 avg_white[c]) / EXPOSURE_STEP;
3222 if (exp_off < 1)
3223 exp_off = 1;
3224 s->dev->exp_params.g_time += exp_off;
3225 finish = 0;
3226 XDBG ((1, "adjust exposure g: ++\n"));
3227 }
3228 else if (avg_white[c] > WHITE_MAX)
3229 {
3230 exp_off =
3231 (avg_white[c] -
3232 (WHITE_MAX + WHITE_MIN) / 2) / EXPOSURE_STEP;
3233 if (exp_off < 1)
3234 exp_off = 1;
3235 s->dev->exp_params.g_time -= exp_off;
3236 finish = 0;
3237 XDBG ((1, "adjust exposure g: --\n"));
3238 }
3239 }
3240 else if (c == 2)
3241 {
3242 if (avg_white[c] < WHITE_MIN)
3243 {
3244 exp_off =
3245 ((WHITE_MAX + WHITE_MIN) / 2 -
3246 avg_white[c]) / EXPOSURE_STEP;
3247 if (exp_off < 1)
3248 exp_off = 1;
3249 s->dev->exp_params.b_time += exp_off;
3250 finish = 0;
3251 XDBG ((1, "adjust exposure b: ++\n"));
3252 }
3253 else if (avg_white[c] > WHITE_MAX)
3254 {
3255 exp_off =
3256 (avg_white[c] -
3257 (WHITE_MAX + WHITE_MIN) / 2) / EXPOSURE_STEP;
3258 if (exp_off < 1)
3259 exp_off = 1;
3260 s->dev->exp_params.b_time -= exp_off;
3261 finish = 0;
3262 XDBG ((1, "adjust exposure b: --\n"));
3263 }
3264 }
3265 }
3266
3267 XDBG ((1, "time_r: %x, time_g: %x, time_b: %x\n",
3268 s->dev->exp_params.r_time, s->dev->exp_params.g_time,
3269 s->dev->exp_params.b_time));
3270 XDBG ((1, "offset_r: %x, offset_g: %x, offset_b: %x\n",
3271 s->dev->afe_params.r_offset, s->dev->afe_params.g_offset,
3272 s->dev->afe_params.b_offset));
3273 ++noloop;
3274 if (noloop > 10)
3275 break;
3276 }
3277 }
3278
3279 XDBG ((1, "option redOffset 0x%x\n", s->dev->afe_params.r_offset));
3280 XDBG ((1, "option greenOffset 0x%x\n", s->dev->afe_params.g_offset));
3281 XDBG ((1, "option blueOffset 0x%x\n", s->dev->afe_params.b_offset));
3282 XDBG ((1, "option redExposure 0x%x\n", s->dev->exp_params.r_time));
3283 XDBG ((1, "option greenExposure 0x%x\n", s->dev->exp_params.g_time));
3284 XDBG ((1, "option blueExposure 0x%x\n", s->dev->exp_params.b_time));
3285
3286 s->dev->artec_48u_afe_params.r_offset = s->dev->afe_params.r_offset;
3287 s->dev->artec_48u_afe_params.g_offset = s->dev->afe_params.g_offset;
3288 s->dev->artec_48u_afe_params.b_offset = s->dev->afe_params.b_offset;
3289 /*don't forget the gain */
3290 s->dev->artec_48u_afe_params.r_pga = s->dev->afe_params.r_pga;
3291 s->dev->artec_48u_afe_params.g_pga = s->dev->afe_params.g_pga;
3292 s->dev->artec_48u_afe_params.b_pga = s->dev->afe_params.b_pga;
3293
3294 s->dev->artec_48u_exposure_params.r_time = s->dev->exp_params.r_time;
3295 s->dev->artec_48u_exposure_params.g_time = s->dev->exp_params.g_time;
3296 s->dev->artec_48u_exposure_params.b_time = s->dev->exp_params.b_time;
3297
3298 /*******************************
3299 *get the black shading values *
3300 *******************************/
3301 artec48u_carriage_home (s->dev);
3302
3303 artec48u_wait_for_positioning (s->dev);
3304 s->reader = NULL;
3305
3306 s->scanning = SANE_TRUE;
3307
3308 init_shading_buffer (s);
3309
3310 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_BLACK, SANE_FALSE,
3311 &(s->params));
3312 artec48u_scanner_start_scan_extended (s, &(s->request),
3313 SA_CALIBRATE_SCAN_BLACK,
3314 &(s->params));
3315
3316 for (c = 0; c < s->dev->shading_lines_b; c++)
3317 {
3318 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE);
3319 add_to_shading_buffer (s, buffer_pointers);
3320 }
3321 artec48u_scanner_stop_scan (s);
3322 finish_shading_buffer (s, SANE_FALSE);
3323 s->scanning = SANE_FALSE;
3324
3325 /*******************************
3326 *get the white shading values *
3327 *******************************/
3328 artec48u_carriage_home (s->dev);
3329
3330 artec48u_wait_for_positioning (s->dev);
3331 s->reader = NULL;
3332 s->scanning = SANE_TRUE;
3333
3334 init_shading_buffer (s);
3335
3336 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_WHITE, SANE_FALSE,
3337 &(s->params));
3338 artec48u_scanner_start_scan_extended (s, &(s->request),
3339 SA_CALIBRATE_SCAN_WHITE,
3340 &(s->params));
3341 for (c = 0; c < s->dev->shading_lines_w; c++)
3342 {
3343 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE);
3344 add_to_shading_buffer (s, buffer_pointers);
3345 }
3346 artec48u_scanner_stop_scan (s);
3347 finish_shading_buffer (s, SANE_TRUE);
3348 s->scanning = SANE_FALSE;
3349 save_calibration_data (s);
3350 return SANE_STATUS_GOOD;
3351 }
3352
3353 static SANE_Status
close_pipe(Artec48U_Scanner * s)3354 close_pipe (Artec48U_Scanner * s)
3355 {
3356 if (s->pipe >= 0)
3357 {
3358 XDBG ((1, "close_pipe\n"));
3359 close (s->pipe);
3360 s->pipe = -1;
3361 }
3362 return SANE_STATUS_EOF;
3363 }
3364 static void
sigalarm_handler(int __sane_unused__ signal)3365 sigalarm_handler (int __sane_unused__ signal)
3366 {
3367 XDBG ((1, "ALARM!!!\n"));
3368 cancelRead = SANE_TRUE;
3369 }
3370
3371 static void
sig_chldhandler(int signo)3372 sig_chldhandler (int signo)
3373 {
3374 XDBG ((1, "Child is down (signal=%d)\n", signo));
3375 }
3376
3377 static int
reader_process(void * data)3378 reader_process (void * data)
3379 {
3380 Artec48U_Scanner * s = (Artec48U_Scanner *) data;
3381 int fd = s->reader_pipe;
3382
3383 SANE_Status status;
3384 struct SIGACTION act;
3385 sigset_t ignore_set;
3386 ssize_t bytes_written = 0;
3387
3388 XDBG ((1, "reader process...\n"));
3389
3390 if (sanei_thread_is_forked()) close (s->pipe);
3391
3392 sigfillset (&ignore_set);
3393 sigdelset (&ignore_set, SIGTERM);
3394 sigdelset (&ignore_set, SIGUSR1);
3395 #if defined (__APPLE__) && defined (__MACH__)
3396 sigdelset (&ignore_set, SIGUSR2);
3397 #endif
3398 sigprocmask (SIG_SETMASK, &ignore_set, 0);
3399
3400 memset (&act, 0, sizeof (act));
3401 sigaction (SIGTERM, &act, 0);
3402 sigaction (SIGUSR1, &act, 0);
3403
3404 cancelRead = SANE_FALSE;
3405 if (sigemptyset (&(act.sa_mask)) < 0)
3406 XDBG ((2, "(child) reader_process: sigemptyset() failed\n"));
3407 act.sa_flags = 0;
3408
3409 act.sa_handler = reader_process_sigterm_handler;
3410 if (sigaction (SIGTERM, &act, 0) < 0)
3411 XDBG ((2, "(child) reader_process: sigaction(SIGTERM,...) failed\n"));
3412
3413 act.sa_handler = usb_reader_process_sigterm_handler;
3414 if (sigaction (SIGUSR1, &act, 0) < 0)
3415 XDBG ((2, "(child) reader_process: sigaction(SIGUSR1,...) failed\n"));
3416
3417
3418 XDBG ((2, "(child) reader_process: s=%p, fd=%d\n", (void *) s, fd));
3419
3420 /*read line by line into buffer */
3421 /*copy buffer pointers to line_buffer */
3422 XDBG ((2, "(child) reader_process: byte_cnt %d\n", (int) s->byte_cnt));
3423 s->eof = SANE_FALSE;
3424 while (s->lines_to_read > 0)
3425 {
3426 if (cancelRead == SANE_TRUE)
3427 {
3428 XDBG ((2, "(child) reader_process: cancelRead == SANE_TRUE\n"));
3429 s->scanning = SANE_FALSE;
3430 s->eof = SANE_FALSE;
3431 return SANE_STATUS_CANCELLED;
3432 }
3433 if (s->scanning != SANE_TRUE)
3434 {
3435 XDBG ((2, "(child) reader_process: scanning != SANE_TRUE\n"));
3436 return SANE_STATUS_CANCELLED;
3437 }
3438 status = artec48u_scanner_read_line (s, s->buffer_pointers, SANE_TRUE);
3439 if (status != SANE_STATUS_GOOD)
3440 {
3441 XDBG ((2, "(child) reader_process: scanner_read_line failed\n"));
3442 return SANE_STATUS_IO_ERROR;
3443 }
3444 copy_scan_line (s);
3445 s->lines_to_read -= 1;
3446 bytes_written =
3447 write (fd, s->line_buffer, s->sane_params.bytes_per_line);
3448
3449 if (bytes_written < 0)
3450 {
3451 XDBG ((2, "(child) reader_process: write returned %s\n",
3452 strerror (errno)));
3453 s->eof = SANE_FALSE;
3454 return SANE_STATUS_IO_ERROR;
3455 }
3456
3457 XDBG ((2, "(child) reader_process: lines to read %i\n", s->lines_to_read));
3458 }
3459 s->eof = SANE_TRUE;
3460 close (fd);
3461 return SANE_STATUS_GOOD;
3462 }
3463
3464 static SANE_Status
do_cancel(Artec48U_Scanner * s,SANE_Bool closepipe)3465 do_cancel (Artec48U_Scanner * s, SANE_Bool closepipe)
3466 {
3467 struct SIGACTION act;
3468 SANE_Pid res;
3469 XDBG ((1, "do_cancel\n"));
3470
3471 s->scanning = SANE_FALSE;
3472
3473 if (sanei_thread_is_valid (s->reader_pid))
3474 {
3475 /*parent */
3476 XDBG ((1, "killing reader_process\n"));
3477 /* tell the driver to stop scanning */
3478 sigemptyset (&(act.sa_mask));
3479 act.sa_flags = 0;
3480
3481 act.sa_handler = sigalarm_handler;
3482
3483 if (sigaction (SIGALRM, &act, 0) == -1)
3484 XDBG ((1, "sigaction() failed !\n"));
3485
3486 /* kill our child process and wait until done */
3487 alarm (10);
3488 if (sanei_thread_kill (s->reader_pid) < 0)
3489 XDBG ((1, "sanei_thread_kill() failed !\n"));
3490 res = sanei_thread_waitpid (s->reader_pid, 0);
3491 alarm (0);
3492
3493 if (res != s->reader_pid)
3494 {
3495 XDBG ((1, "sanei_thread_waitpid() failed !\n"));
3496 }
3497 sanei_thread_invalidate (s->reader_pid);
3498 XDBG ((1, "reader_process killed\n"));
3499 }
3500 if (SANE_TRUE == closepipe)
3501 {
3502 close_pipe (s);
3503 XDBG ((1, "pipe closed\n"));
3504 }
3505 artec48u_scanner_stop_scan (s);
3506 artec48u_carriage_home (s->dev);
3507 if (s->line_buffer)
3508 {
3509 XDBG ((2, "freeing line_buffer\n"));
3510 free (s->line_buffer);
3511 s->line_buffer = NULL;
3512 }
3513 if (s->lineart_buffer)
3514 {
3515 XDBG ((2, "freeing lineart_buffer\n"));
3516 free (s->lineart_buffer);
3517 s->lineart_buffer = NULL;
3518 }
3519
3520 return SANE_STATUS_CANCELLED;
3521 }
3522
3523 SANE_Status
sane_get_devices(const SANE_Device *** device_list,SANE_Bool local_only)3524 sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
3525 {
3526 static const SANE_Device **devlist = 0;
3527 Artec48U_Device *dev;
3528 SANE_Int dev_num;
3529
3530 XDBG ((5, "sane_get_devices: start: local_only = %s\n",
3531 local_only == SANE_TRUE ? "true" : "false"));
3532
3533 if (devlist)
3534 free (devlist);
3535
3536 devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
3537 if (!devlist)
3538 return SANE_STATUS_NO_MEM;
3539
3540 dev_num = 0;
3541 for (dev = first_dev; dev_num < num_devices; dev = dev->next)
3542 {
3543 devlist[dev_num] = &dev->sane;
3544 XDBG ((3, "sane_get_devices: name %s\n", dev->sane.name));
3545 XDBG ((3, "sane_get_devices: vendor %s\n", dev->sane.vendor));
3546 XDBG ((3, "sane_get_devices: model %s\n", dev->sane.model));
3547 ++dev_num;
3548 }
3549 devlist[dev_num] = 0;
3550 ++dev_num;
3551
3552 *device_list = devlist;
3553
3554 XDBG ((5, "sane_get_devices: exit\n"));
3555
3556 return SANE_STATUS_GOOD;
3557 }
3558
3559 static SANE_Status
load_calibration_data(Artec48U_Scanner * s)3560 load_calibration_data (Artec48U_Scanner * s)
3561 {
3562 SANE_Status status = SANE_STATUS_GOOD;
3563 FILE *f = 0;
3564 size_t cnt;
3565 char path[PATH_MAX];
3566 char filename[PATH_MAX];
3567
3568 s->calibrated = SANE_FALSE;
3569 path[0] = 0;
3570
3571 /* return SANE_STATUS_INVAL if HOME environment variable is not set */
3572 if (getenv ("HOME") == NULL)
3573 {
3574 XDBG ((1, "Environment variable HOME not set\n"));
3575 return SANE_STATUS_INVAL;
3576 }
3577
3578 if (strlen (getenv ("HOME")) < (PATH_MAX - 1))
3579 strcat (path, getenv ("HOME"));
3580 else
3581 return SANE_STATUS_INVAL;
3582
3583 if (strlen (path) < (PATH_MAX - 1 - strlen ("/.artec_eplus48u/")))
3584 strcat (path, "/.artec_eplus48u/");
3585 else
3586 return SANE_STATUS_INVAL;
3587
3588 /*try to load black shading file */
3589 strcpy (filename, path);
3590 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_black")))
3591 strcat (filename, "artec48ushading_black");
3592 else
3593 return SANE_STATUS_INVAL;
3594 XDBG ((1, "Try to read black shading file: \"%s\"\n", filename));
3595
3596 f = fopen (filename, "rb");
3597 if (!f)
3598 return SANE_STATUS_INVAL;
3599
3600 /*read values */
3601 cnt = fread (s->shading_buffer_b, sizeof (unsigned char), 30720*s->dev->epro_mult, f); /*epro*/
3602 if (cnt != (30720*s->dev->epro_mult)) /*epro*/
3603 {
3604 fclose (f);
3605 XDBG ((1, "Could not load black shading file\n"));
3606 return SANE_STATUS_INVAL;
3607 }
3608 fclose (f);
3609
3610 /*try to load white shading file */
3611 strcpy (filename, path);
3612 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_white")))
3613 strcat (filename, "artec48ushading_white");
3614 else
3615 return SANE_STATUS_INVAL;
3616 XDBG ((1, "Try to read white shading file: \"%s\"\n", filename));
3617 f = fopen (filename, "rb");
3618 if (!f)
3619 return SANE_STATUS_INVAL;
3620 /*read values */
3621 cnt = fread (s->shading_buffer_w, sizeof (unsigned char), 30720*s->dev->epro_mult, f);/*epro*/
3622 if (cnt != (30720*s->dev->epro_mult)) /*epro*/
3623 {
3624 fclose (f);
3625 XDBG ((1, "Could not load white shading file\n"));
3626 return SANE_STATUS_INVAL;
3627 }
3628 fclose (f);
3629
3630 /*try to load offset file */
3631 strcpy (filename, path);
3632 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uoffset")))
3633 strcat (filename, "artec48uoffset");
3634 else
3635 return SANE_STATUS_INVAL;
3636 XDBG ((1, "Try to read offset file: \"%s\"\n", filename));
3637 f = fopen (filename, "rb");
3638 if (!f)
3639 return SANE_STATUS_INVAL;
3640 /*read values */
3641 cnt =
3642 fread (&s->dev->artec_48u_afe_params, sizeof (Artec48U_AFE_Parameters), 1,
3643 f);
3644 if (cnt != 1)
3645 {
3646 fclose (f);
3647 XDBG ((1, "Could not load offset file\n"));
3648 return SANE_STATUS_INVAL;
3649 }
3650 fclose (f);
3651
3652 /*load exposure file */
3653 strcpy (filename, path);
3654 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uexposure")))
3655 strcat (filename, "artec48uexposure");
3656 else
3657 return SANE_STATUS_INVAL;
3658 XDBG ((1, "Try to read exposure file: \"%s\"\n", filename));
3659 f = fopen (filename, "rb");
3660 if (!f)
3661 return SANE_STATUS_INVAL;
3662 /*read values */
3663 cnt =
3664 fread (&s->dev->artec_48u_exposure_params,
3665 sizeof (Artec48U_Exposure_Parameters), 1, f);
3666 if (cnt != 1)
3667 {
3668 fclose (f);
3669 XDBG ((1, "Could not load exposure file\n"));
3670 return SANE_STATUS_INVAL;
3671 }
3672 fclose (f);
3673 s->calibrated = SANE_TRUE;
3674 return status;
3675 }
3676
3677 static SANE_Status
save_calibration_data(Artec48U_Scanner * s)3678 save_calibration_data (Artec48U_Scanner * s)
3679 {
3680 SANE_Status status = SANE_STATUS_GOOD;
3681 FILE *f = 0;
3682 size_t cnt;
3683 char path[PATH_MAX];
3684 char filename[PATH_MAX];
3685 mode_t mode = S_IRUSR | S_IWUSR;
3686
3687 path[0] = 0;
3688
3689 /* return SANE_STATUS_INVAL if HOME environment variable is not set */
3690 if (getenv ("HOME") == NULL)
3691 {
3692 XDBG ((1, "Environment variable HOME not set\n"));
3693 return SANE_STATUS_INVAL;
3694 }
3695
3696 if (strlen (getenv ("HOME")) < (PATH_MAX - 1))
3697 strcat (path, getenv ("HOME"));
3698 else
3699 return SANE_STATUS_INVAL;
3700
3701 if (strlen (path) < (PATH_MAX - 1 - strlen ("/.artec_eplus48u/")))
3702 strcat (path, "/.artec_eplus48u/");
3703 else
3704 return SANE_STATUS_INVAL;
3705
3706 /*try to save black shading file */
3707 strcpy (filename, path);
3708 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_black")))
3709 strcat (filename, "artec48ushading_black");
3710 else
3711 return SANE_STATUS_INVAL;
3712 XDBG ((1, "Try to save black shading file: \"%s\"\n", filename));
3713 f = fopen (filename, "w");
3714 if (!f)
3715 {
3716 XDBG ((1, "Could not save artec48ushading_black\n"));
3717 return SANE_STATUS_INVAL;
3718 }
3719 if (chmod (filename, mode) != 0)
3720 return SANE_STATUS_INVAL;
3721
3722 /*read values */
3723 cnt = fwrite (s->shading_buffer_b, sizeof (unsigned char), 30720*s->dev->epro_mult, f); /*epro*/
3724 XDBG ((1, "Wrote %li bytes to black shading buffer \n", (u_long) cnt));
3725 if (cnt != (30720*s->dev->epro_mult))/*epro*/
3726 {
3727 fclose (f);
3728 XDBG ((1, "Could not write black shading buffer\n"));
3729 return SANE_STATUS_INVAL;
3730 }
3731 fclose (f);
3732
3733 /*try to save white shading file */
3734 strcpy (filename, path);
3735 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_white")))
3736 strcat (filename, "artec48ushading_white");
3737 else
3738 return SANE_STATUS_INVAL;
3739 XDBG ((1, "Try to save white shading file: \"%s\"\n", filename));
3740 f = fopen (filename, "w");
3741 if (!f)
3742 return SANE_STATUS_INVAL;
3743 if (chmod (filename, mode) != 0)
3744 return SANE_STATUS_INVAL;
3745 /*read values */
3746 cnt = fwrite (s->shading_buffer_w, sizeof (unsigned char), 30720*s->dev->epro_mult, f);/*epro*/
3747 if (cnt != (30720*s->dev->epro_mult)) /*epro*/
3748 {
3749 fclose (f);
3750 XDBG ((1, "Could not write white shading buffer\n"));
3751 return SANE_STATUS_INVAL;
3752 }
3753 fclose (f);
3754
3755 /*try to save offset file */
3756 strcpy (filename, path);
3757 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uoffset")))
3758 strcat (filename, "artec48uoffset");
3759 else
3760 return SANE_STATUS_INVAL;
3761 XDBG ((1, "Try to write offset file: \"%s\"\n", filename));
3762 f = fopen (filename, "w");
3763 if (!f)
3764 return SANE_STATUS_INVAL;
3765 if (chmod (filename, mode) != 0)
3766 return SANE_STATUS_INVAL;
3767 /*read values */
3768 cnt =
3769 fwrite (&s->dev->artec_48u_afe_params, sizeof (Artec48U_AFE_Parameters),
3770 1, f);
3771 if (cnt != 1)
3772 {
3773 fclose (f);
3774 XDBG ((1, "Could not write afe values\n"));
3775 return SANE_STATUS_INVAL;
3776 }
3777 fclose (f);
3778
3779 /*try to write exposure file */
3780 strcpy (filename, path);
3781 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uexposure")))
3782 strcat (filename, "artec48uexposure");
3783 else
3784 return SANE_STATUS_INVAL;
3785 XDBG ((1, "Try to write exposure file: \"%s\"\n", filename));
3786 f = fopen (filename, "w");
3787 if (!f)
3788 return SANE_STATUS_INVAL;
3789 if (chmod (filename, mode) != 0)
3790 return SANE_STATUS_INVAL;
3791 /*read values */
3792 cnt =
3793 fwrite (&s->dev->artec_48u_exposure_params,
3794 sizeof (Artec48U_Exposure_Parameters), 1, f);
3795 if (cnt != 1)
3796 {
3797 fclose (f);
3798 XDBG ((1, "Could not write exposure values\n"));
3799 return SANE_STATUS_INVAL;
3800 }
3801 fclose (f);
3802 return status;
3803 }
3804
3805 SANE_Status
sane_open(SANE_String_Const devicename,SANE_Handle * handle)3806 sane_open (SANE_String_Const devicename, SANE_Handle * handle)
3807 {
3808 SANE_Status status = SANE_STATUS_INVAL;
3809 Artec48U_Device *dev = 0;
3810 Artec48U_Scanner *s = 0;
3811
3812 if (!devicename)
3813 return SANE_STATUS_INVAL;
3814 XDBG ((2, "sane_open: devicename = \"%s\"\n", devicename));
3815
3816
3817 if (devicename[0])
3818 {
3819 for (dev = first_dev; dev; dev = dev->next)
3820 {
3821 if (strcmp (dev->sane.name, devicename) == 0)
3822 {
3823 XDBG ((2, "sane_open: found matching device %s\n",
3824 dev->sane.name));
3825 break;
3826 }
3827 }
3828 if (!dev)
3829 {
3830 status = attach (devicename, &dev);
3831 if (status != SANE_STATUS_GOOD)
3832 XDBG ((2, "sane_open: attach failed %s\n", devicename));
3833 }
3834 }
3835 else
3836 {
3837 /* empty devicename -> use first device */
3838 XDBG ((2, "sane_open: empty devicename\n"));
3839 dev = first_dev;
3840 }
3841 if (!dev)
3842 return SANE_STATUS_INVAL;
3843
3844 status = artec48u_device_open (dev);
3845
3846 if (status != SANE_STATUS_GOOD)
3847 {
3848 XDBG ((3, "could not open device\n"));
3849 return status;
3850 }
3851 XDBG ((2, "sane_open: opening device `%s', handle = %p\n", dev->sane.name,
3852 (void *) dev));
3853
3854 XDBG ((1, "sane_open - %s\n", dev->sane.name));
3855 XDBG ((2, "sane_open: try to open %s\n", dev->sane.name));
3856
3857 status = artec48u_device_activate (dev);
3858 if (status != SANE_STATUS_GOOD)
3859 {
3860 XDBG ((3, "could not activate device\n"));
3861 return status;
3862 }
3863 /* We do not check anymore, whether the firmware is already loaded */
3864 /* because that caused problems after rebooting; furthermore, loading */
3865 /* of the firmware is fast, therefore the test doesn't make much sense */
3866 status = download_firmware_file (dev);
3867 if (status != SANE_STATUS_GOOD)
3868 {
3869 XDBG ((3, "download_firmware_file failed\n"));
3870 return status;
3871 }
3872 /* If a scan is interrupted without sending stop_scan, bad things happen.
3873 * Send the stop scan command now just in case. */
3874 artec48u_stop_scan (dev);
3875
3876 artec48u_wait_for_positioning (dev);
3877
3878 artec48u_scanner_new (dev, &s);
3879 init_calibrator (s);
3880 s->next = first_handle;
3881 first_handle = s;
3882 *handle = s;
3883
3884 status = init_options (s);
3885 if (status != SANE_STATUS_GOOD)
3886 return status;
3887 /*Try to load the calibration values */
3888 status = load_calibration_data (s);
3889
3890 return SANE_STATUS_GOOD;
3891 }
3892
3893 void
sane_close(SANE_Handle handle)3894 sane_close (SANE_Handle handle)
3895 {
3896 Artec48U_Scanner *s;
3897
3898 XDBG ((5, "sane_close: start\n"));
3899
3900 /* remove handle from list of open handles: */
3901 for (s = first_handle; s; s = s->next)
3902 {
3903 if (s == handle)
3904 break;
3905 }
3906 if (!s)
3907 {
3908 XDBG ((5, "close: invalid handle %p\n", handle));
3909 return;
3910 }
3911 artec48u_device_close (s->dev);
3912 artec48u_scanner_free (s);
3913 XDBG ((5, "sane_close: exit\n"));
3914 }
3915
3916 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle handle,SANE_Int option)3917 sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
3918 {
3919 Artec48U_Scanner *s = handle;
3920
3921 if ((unsigned) option >= NUM_OPTIONS)
3922 return 0;
3923 XDBG ((5, "sane_get_option_descriptor: option = %s (%d)\n",
3924 s->opt[option].name, option));
3925 return s->opt + option;
3926 }
3927
3928 SANE_Status
sane_control_option(SANE_Handle handle,SANE_Int option,SANE_Action action,void * value,SANE_Int * info)3929 sane_control_option (SANE_Handle handle, SANE_Int option,
3930 SANE_Action action, void *value, SANE_Int * info)
3931 {
3932 Artec48U_Scanner *s = handle;
3933 #ifdef ARTEC48U_USE_BUTTONS
3934 SANE_Int button_state;
3935 #endif
3936 SANE_Status status;
3937 XDBG ((8, "sane_control_option: handle=%p, opt=%d, act=%d, val=%p, info=%p\n",
3938 (void *) handle, option, action, (void *) value, (void *) info));
3939
3940 if (info)
3941 *info = 0;
3942
3943 if (option < 0 || option >= NUM_OPTIONS)
3944 return SANE_STATUS_INVAL; /* Unknown option ... */
3945
3946 if (!SANE_OPTION_IS_ACTIVE (s->opt[option].cap))
3947 return SANE_STATUS_INVAL;
3948
3949 switch (action)
3950 {
3951 case SANE_ACTION_SET_VALUE:
3952 if (s->scanning == SANE_TRUE)
3953 return SANE_STATUS_INVAL;
3954
3955 if (!SANE_OPTION_IS_SETTABLE (s->opt[option].cap))
3956 return SANE_STATUS_INVAL;
3957
3958 status = sanei_constrain_value (s->opt + option, value, info);
3959
3960 if (status != SANE_STATUS_GOOD)
3961 return status;
3962
3963 switch (option)
3964 {
3965 case OPT_RESOLUTION:
3966 if(s->dev->is_epro != 0)
3967 {
3968 if((s->val[option].w == 1200) && (*(SANE_Word *) value < 1200))
3969 {
3970 s->opt[OPT_BIT_DEPTH].constraint.word_list = bitdepth_list;
3971 *info |= SANE_INFO_RELOAD_OPTIONS;
3972 }
3973 else if((s->val[option].w < 1200) && (*(SANE_Word *) value == 1200))
3974 {
3975 s->opt[OPT_BIT_DEPTH].constraint.word_list = bitdepth_list2;
3976 if(s->val[OPT_BIT_DEPTH].w > 8)
3977 s->val[OPT_BIT_DEPTH].w = 8;
3978 *info |= SANE_INFO_RELOAD_OPTIONS;
3979 }
3980 }
3981 s->val[option].w = *(SANE_Word *) value;
3982 if (info)
3983 {
3984 *info |= SANE_INFO_RELOAD_PARAMS;
3985 }
3986 break;
3987 /* fall through */
3988 case OPT_BIT_DEPTH:
3989 case OPT_TL_X:
3990 case OPT_TL_Y:
3991 case OPT_BR_X:
3992 case OPT_BR_Y:
3993 s->val[option].w = *(SANE_Word *) value;
3994 if (info)
3995 *info |= SANE_INFO_RELOAD_PARAMS;
3996 return SANE_STATUS_GOOD;
3997 /* fall through */
3998 case OPT_BLACK_LEVEL:
3999 case OPT_BRIGHTNESS:
4000 case OPT_CONTRAST:
4001 case OPT_GAMMA:
4002 case OPT_GAMMA_R:
4003 case OPT_GAMMA_G:
4004 case OPT_GAMMA_B:
4005 case OPT_CALIBRATE:
4006 case OPT_CALIBRATE_SHADING:
4007 s->val[option].w = *(SANE_Word *) value;
4008 return SANE_STATUS_GOOD;
4009 case OPT_DEFAULT_ENHANCEMENTS:
4010 s->val[OPT_GAMMA].w = SANE_FIX (s->dev->gamma_master);
4011 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[2]) == 0)
4012 {
4013 s->val[OPT_GAMMA_R].w = SANE_FIX (s->dev->gamma_r);
4014 s->val[OPT_GAMMA_G].w = SANE_FIX (s->dev->gamma_g);
4015 s->val[OPT_GAMMA_B].w = SANE_FIX (s->dev->gamma_b);
4016 }
4017 s->val[OPT_BRIGHTNESS].w = 0;
4018 s->val[OPT_CONTRAST].w = 0;
4019 if (info)
4020 *info |= SANE_INFO_RELOAD_OPTIONS;
4021 break;
4022 case OPT_SCAN_MODE:
4023 if (s->val[option].s)
4024 free (s->val[option].s);
4025 s->val[option].s = strdup (value);
4026 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[0]) == 0)
4027 {
4028 s->opt[OPT_GAMMA_R].cap |= SANE_CAP_INACTIVE;
4029 s->opt[OPT_GAMMA_G].cap |= SANE_CAP_INACTIVE;
4030 s->opt[OPT_GAMMA_B].cap |= SANE_CAP_INACTIVE;
4031 s->opt[OPT_BLACK_LEVEL].cap &= ~SANE_CAP_INACTIVE;
4032 s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
4033 }
4034 else if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[1]) == 0)
4035 {
4036 s->opt[OPT_GAMMA_R].cap |= SANE_CAP_INACTIVE;
4037 s->opt[OPT_GAMMA_G].cap |= SANE_CAP_INACTIVE;
4038 s->opt[OPT_GAMMA_B].cap |= SANE_CAP_INACTIVE;
4039 s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE;
4040 s->opt[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE;
4041 }
4042 else
4043 {
4044 s->opt[OPT_GAMMA_R].cap &= ~SANE_CAP_INACTIVE;
4045 s->opt[OPT_GAMMA_G].cap &= ~SANE_CAP_INACTIVE;
4046 s->opt[OPT_GAMMA_B].cap &= ~SANE_CAP_INACTIVE;
4047 s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE;
4048 s->opt[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE;
4049 }
4050 if (info)
4051 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
4052 return SANE_STATUS_GOOD;
4053 }
4054 break;
4055 case SANE_ACTION_GET_VALUE:
4056 switch (option)
4057 {
4058 /* word options: */
4059 case OPT_NUM_OPTS:
4060 case OPT_RESOLUTION:
4061 case OPT_BIT_DEPTH:
4062 case OPT_BLACK_LEVEL:
4063 case OPT_TL_X:
4064 case OPT_TL_Y:
4065 case OPT_BR_X:
4066 case OPT_BR_Y:
4067 case OPT_BRIGHTNESS:
4068 case OPT_CONTRAST:
4069 case OPT_GAMMA:
4070 case OPT_GAMMA_R:
4071 case OPT_GAMMA_G:
4072 case OPT_GAMMA_B:
4073 case OPT_CALIBRATE:
4074 case OPT_CALIBRATE_SHADING:
4075 *(SANE_Word *) value = (SANE_Word) s->val[option].w;
4076 return SANE_STATUS_GOOD;
4077 /* string options: */
4078 case OPT_SCAN_MODE:
4079 strcpy (value, s->val[option].s);
4080 return SANE_STATUS_GOOD;
4081 #ifdef ARTEC48U_USE_BUTTONS
4082 case OPT_BUTTON_STATE:
4083 status = artec48u_check_buttons (s->dev, &button_state);
4084 if (status == SANE_STATUS_GOOD)
4085 {
4086 s->val[option].w = button_state;
4087 *(SANE_Int *) value = (SANE_Int) s->val[option].w;
4088 }
4089 else
4090 {
4091 s->val[option].w = 0;
4092 *(SANE_Int *) value = 0;
4093 }
4094 return SANE_STATUS_GOOD;
4095 #endif
4096 }
4097 break;
4098 default:
4099 return SANE_STATUS_INVAL;
4100 }
4101 return SANE_STATUS_GOOD;
4102 }
4103
4104 SANE_Status
sane_get_parameters(SANE_Handle handle,SANE_Parameters * params)4105 sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
4106 {
4107 Artec48U_Scanner *s = handle;
4108 SANE_Status status;
4109 SANE_Word resx;
4110 /* int scan_mode;*/
4111 SANE_String str = s->val[OPT_SCAN_MODE].s;
4112 int tlx;
4113 int tly;
4114 int brx;
4115 int bry;
4116 int tmp;
4117 XDBG ((2, "sane_get_params: string %s\n", str));
4118 XDBG ((2, "sane_get_params: enter\n"));
4119
4120 tlx = s->val[OPT_TL_X].w;
4121 tly = s->val[OPT_TL_Y].w;
4122 brx = s->val[OPT_BR_X].w;
4123 bry = s->val[OPT_BR_Y].w;
4124
4125 /*make sure, that tlx < brx and tly < bry
4126 this will NOT change the options */
4127 if (tlx > brx)
4128 {
4129 tmp = tlx;
4130 tlx = brx;
4131 brx = tmp;
4132 }
4133 if (tly > bry)
4134 {
4135 tmp = tly;
4136 tly = bry;
4137 bry = tmp;
4138 }
4139 resx = s->val[OPT_RESOLUTION].w;
4140 str = s->val[OPT_SCAN_MODE].s;
4141
4142 s->request.color = SANE_TRUE;
4143 if ((strcmp (str, mode_list[0]) == 0) || (strcmp (str, mode_list[1]) == 0))
4144 s->request.color = SANE_FALSE;
4145 else
4146 s->request.color = SANE_TRUE;
4147 s->request.depth = s->val[OPT_BIT_DEPTH].w;
4148 if (strcmp (str, mode_list[0]) == 0)
4149 s->request.depth = 8;
4150 s->request.y0 = tly; /**< Top boundary */
4151 s->request.x0 = SANE_FIX (216.0) - brx; /**< left boundary */
4152 s->request.xs = brx - tlx; /**< Width */
4153 s->request.ys = bry - tly; /**< Height */
4154 s->request.xdpi = resx; /**< Horizontal resolution */
4155 s->request.ydpi = resx; /**< Vertical resolution */
4156 /*epro*/
4157 if ((resx == 1200) && (s->dev->is_epro == 0))
4158 s->request.xdpi = 600;/**< Vertical resolution */
4159
4160 status = artec48u_setup_scan (s, &(s->request), SA_SCAN,
4161 SANE_TRUE, &(s->params));
4162 if (status != SANE_STATUS_GOOD)
4163 return SANE_STATUS_INVAL;
4164
4165 /*DBG(1, "sane_get_params: scan_mode %i\n",scan_mode);*/
4166
4167 params->depth = s->params.depth;
4168 s->params.lineart = SANE_FALSE;
4169 if (s->params.color == SANE_TRUE)
4170 {
4171 params->format = SANE_FRAME_RGB;
4172 params->bytes_per_line = s->params.pixel_xs * 3;
4173 }
4174 else
4175 {
4176 params->format = SANE_FRAME_GRAY;
4177 params->bytes_per_line = s->params.pixel_xs;
4178 if (strcmp (str, mode_list[0]) == 0)
4179 {
4180 params->depth = 1;
4181 params->bytes_per_line = (s->params.pixel_xs + 7) / 8;
4182 s->params.lineart = SANE_TRUE;
4183 }
4184 }
4185 if ((resx == 1200) && (s->dev->is_epro == 0))
4186 {
4187 if (params->depth == 1)
4188 params->bytes_per_line = (s->params.pixel_xs * 2 + 7) / 8;
4189 else
4190 params->bytes_per_line *= 2;
4191 }
4192 if (params->depth == 16)
4193 params->bytes_per_line *= 2;
4194 params->last_frame = SANE_TRUE;
4195 params->pixels_per_line = s->params.pixel_xs;
4196 if ((resx == 1200) && (s->dev->is_epro == 0))
4197 params->pixels_per_line *= 2;
4198 params->lines = s->params.pixel_ys;
4199 return SANE_STATUS_GOOD;
4200 }
4201
4202 SANE_Status
sane_start(SANE_Handle handle)4203 sane_start (SANE_Handle handle)
4204 {
4205 Artec48U_Scanner *s = handle;
4206 SANE_Status status;
4207 int fds[2];
4208
4209 if (s->scanning)
4210 {
4211 return SANE_STATUS_DEVICE_BUSY;
4212 }
4213
4214 if (sane_get_parameters (handle, &s->sane_params) != SANE_STATUS_GOOD)
4215 return SANE_STATUS_INVAL;
4216
4217 if ((s->calibrated != SANE_TRUE) || (s->val[OPT_CALIBRATE].w == SANE_TRUE))
4218 {
4219 XDBG ((1, "Must calibrate scanner\n"));
4220 status = calibrate_scanner (s);
4221 if (status != SANE_STATUS_GOOD)
4222 return status;
4223 s->calibrated = SANE_TRUE;
4224 }
4225 if (sane_get_parameters (handle, &s->sane_params) != SANE_STATUS_GOOD)
4226 return SANE_STATUS_INVAL;
4227
4228 calculate_brightness (s);
4229 calculate_contrast (s);
4230 calculateGamma (s);
4231 calculateGammaRed (s);
4232 calculateGammaGreen (s);
4233 calculateGammaBlue (s);
4234
4235 artec48u_carriage_home (s->dev);
4236
4237 artec48u_wait_for_positioning (s->dev);
4238 s->reader = NULL;
4239
4240 s->scanning = SANE_TRUE;
4241 s->byte_cnt = 0;
4242 s->lines_to_read = s->params.pixel_ys;
4243 /*allocate a buffer, that can hold a complete scan line */
4244 /*If resolution is 1200 dpi and we are scanning in lineart mode,
4245 then we also allocate a lineart_buffer, which can hold a complete scan line
4246 in 8 bit/gray. This makes interpolation easier. */
4247 if ((s->params.ydpi == 1200) && (s->dev->is_epro == 0))
4248 {
4249 if (s->request.color == SANE_TRUE)
4250 {
4251 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 8);
4252 }
4253 else
4254 {
4255 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 4);
4256 /*lineart ? */
4257 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[0]) == 0)
4258 s->lineart_buffer = (SANE_Byte *) malloc (s->params.pixel_xs * 2);
4259 }
4260 }
4261 else
4262 {
4263 if (s->request.color == SANE_TRUE)
4264 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 4);
4265 else
4266 {
4267 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 2);
4268 /*lineart ? */
4269 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[0]) == 0)
4270 s->lineart_buffer = (SANE_Byte *) malloc (s->params.pixel_xs * 2);
4271 }
4272 }
4273 if (pipe (fds) < 0)
4274 {
4275 s->scanning = SANE_FALSE;
4276 XDBG ((2, "sane_start: pipe failed (%s)\n", strerror (errno)));
4277 return SANE_STATUS_IO_ERROR;
4278 }
4279 status = artec48u_scanner_start_scan (s, &s->request, &s->params);
4280 if (status != SANE_STATUS_GOOD)
4281 {
4282 XDBG ((2, "sane_start: could not start scan\n"));
4283 return status;
4284 }
4285 s->pipe = fds[0];
4286 s->reader_pipe = fds[1];
4287 s->reader_pid = sanei_thread_begin (reader_process, s);
4288 cancelRead = SANE_FALSE;
4289 if (!sanei_thread_is_valid (s->reader_pid))
4290 {
4291 s->scanning = SANE_FALSE;
4292 XDBG ((2, "sane_start: sanei_thread_begin failed (%s)\n", strerror (errno)));
4293 return SANE_STATUS_NO_MEM;
4294 }
4295 signal (SIGCHLD, sig_chldhandler);
4296
4297 if (sanei_thread_is_forked()) close (s->reader_pipe);
4298
4299 XDBG ((1, "sane_start done\n"));
4300
4301 return SANE_STATUS_GOOD; /* parent */
4302 }
4303
4304 SANE_Status
sane_read(SANE_Handle handle,SANE_Byte * data,SANE_Int max_length,SANE_Int * length)4305 sane_read (SANE_Handle handle, SANE_Byte * data,
4306 SANE_Int max_length, SANE_Int * length)
4307 {
4308 Artec48U_Scanner *s = handle;
4309 ssize_t nread;
4310
4311 *length = 0;
4312
4313 /* here we read all data from the driver... */
4314 nread = read (s->pipe, data, max_length);
4315 XDBG ((3, "sane_read - read %ld bytes\n", (long) nread));
4316 if (cancelRead == SANE_TRUE)
4317 {
4318 return do_cancel (s, SANE_TRUE);
4319 }
4320
4321 if (nread < 0)
4322 {
4323 if (EAGAIN == errno)
4324 {
4325 /* if we already had read the picture, so it's okay and stop */
4326 if (s->eof == SANE_TRUE)
4327 {
4328 sanei_thread_waitpid (s->reader_pid, 0);
4329 sanei_thread_invalidate (s->reader_pid);
4330 artec48u_scanner_stop_scan (s);
4331 artec48u_carriage_home (s->dev);
4332 return close_pipe (s);
4333 }
4334 /* else force the frontend to try again */
4335 return SANE_STATUS_GOOD;
4336 }
4337 else
4338 {
4339 XDBG ((4, "ERROR: errno=%d\n", errno));
4340 do_cancel (s, SANE_TRUE);
4341 return SANE_STATUS_IO_ERROR;
4342 }
4343 }
4344
4345 *length = nread;
4346 s->byte_cnt += nread;
4347
4348 /* nothing read means that we're finished OR we had a problem... */
4349 if (0 == nread)
4350 {
4351 if (0 == s->byte_cnt)
4352 {
4353 s->exit_code = sanei_thread_get_status (s->reader_pid);
4354
4355 if (SANE_STATUS_GOOD != s->exit_code)
4356 {
4357 close_pipe (s);
4358 return s->exit_code;
4359 }
4360 }
4361 return close_pipe (s);
4362 }
4363 return SANE_STATUS_GOOD;
4364 }
4365
4366 void
sane_cancel(SANE_Handle handle)4367 sane_cancel (SANE_Handle handle)
4368 {
4369 Artec48U_Scanner *s = handle;
4370 XDBG ((2, "sane_cancel: handle = %p\n", handle));
4371 if (s->scanning)
4372 do_cancel (s, SANE_FALSE);
4373 }
4374
4375 SANE_Status
sane_set_io_mode(SANE_Handle handle,SANE_Bool non_blocking)4376 sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
4377 {
4378 Artec48U_Scanner *s = (Artec48U_Scanner *) handle;
4379
4380 XDBG ((1, "sane_set_io_mode: non_blocking=%d\n", non_blocking));
4381
4382 if (!s->scanning)
4383 {
4384 XDBG ((4, "ERROR: not scanning !\n"));
4385 return SANE_STATUS_INVAL;
4386 }
4387
4388 if (-1 == s->pipe)
4389 {
4390 XDBG ((4, "ERROR: not supported !\n"));
4391 return SANE_STATUS_UNSUPPORTED;
4392 }
4393
4394 if (fcntl (s->pipe, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0)
4395 {
4396 XDBG ((4, "ERROR: can?t set to non-blocking mode !\n"));
4397 return SANE_STATUS_IO_ERROR;
4398 }
4399
4400 XDBG ((1, "sane_set_io_mode done\n"));
4401 return SANE_STATUS_GOOD;
4402 }
4403
4404 SANE_Status
sane_get_select_fd(SANE_Handle handle,SANE_Int * fd)4405 sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
4406 {
4407 Artec48U_Scanner *s = (Artec48U_Scanner *) handle;
4408
4409 XDBG ((1, "sane_get_select_fd\n"));
4410
4411 if (!s->scanning)
4412 {
4413 XDBG ((4, "ERROR: not scanning !\n"));
4414 return SANE_STATUS_INVAL;
4415 }
4416
4417 *fd = s->pipe;
4418
4419 XDBG ((1, "sane_get_select_fd done\n"));
4420 return SANE_STATUS_GOOD;
4421 }
4422
4423 SANE_Status
sane_init(SANE_Int * version_code,SANE_Auth_Callback authorize)4424 sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
4425 {
4426 Artec48U_Device *device = 0;
4427 SANE_Status status;
4428 char str[PATH_MAX] = _DEFAULT_DEVICE;
4429 char temp[PATH_MAX];
4430 size_t len;
4431 FILE *fp;
4432 double gamma_m = 1.9;
4433 double gamma_r = 1.0;
4434 double gamma_g = 1.0;
4435 double gamma_b = 1.0;
4436 int epro_default = 0;
4437
4438 DBG_INIT ();
4439 eProMult = 1;
4440 isEPro = 0;
4441 temp[0] = 0;
4442 strcpy (vendor_string, "Artec");
4443 strcpy (model_string, "E+ 48U");
4444
4445 sanei_usb_init ();
4446 sanei_thread_init ();
4447
4448 /* do some presettings... */
4449 auth = authorize;
4450
4451 if (version_code != NULL)
4452 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, 0);
4453
4454 fp = sanei_config_open (ARTEC48U_CONFIG_FILE);
4455
4456 /* default to _DEFAULT_DEVICE instead of insisting on config file */
4457 if (NULL == fp)
4458 {
4459 status = attach (_DEFAULT_DEVICE, &device);
4460 return status;
4461 }
4462
4463 while (sanei_config_read (str, sizeof (str), fp))
4464 {
4465 XDBG ((1, "sane_init, >%s<\n", str));
4466 /* ignore line comments */
4467 if (str[0] == '#')
4468 continue;
4469 len = strlen (str);
4470 /* ignore empty lines */
4471 if (0 == len)
4472 continue;
4473 /* check for options */
4474 if (0 == strncmp (str, "option", 6))
4475 {
4476 if(decodeVal (str,"ePlusPro",_INT, &isEPro,&epro_default) == SANE_TRUE)
4477 {
4478 eProMult = 1;
4479 if(isEPro != 0)
4480 {
4481 eProMult = 2;
4482 XDBG ((3, "Is Artec E Pro\n"));
4483 }
4484 else
4485 XDBG ((3, "Is Artec E+ 48U\n"));
4486 }
4487 decodeVal (str, "masterGamma", _FLOAT, &gamma_master_default,
4488 &gamma_m);
4489 decodeVal (str, "redGamma", _FLOAT, &gamma_r_default, &gamma_r);
4490 decodeVal (str, "greenGamma", _FLOAT, &gamma_g_default, &gamma_g);
4491 decodeVal (str, "blueGamma", _FLOAT, &gamma_b_default, &gamma_b);
4492 decodeVal (str, "redOffset", _BYTE, &afe_params.r_offset,
4493 &default_afe_params.r_offset);
4494 decodeVal (str, "greenOffset", _BYTE, &afe_params.g_offset,
4495 &default_afe_params.g_offset);
4496 decodeVal (str, "blueOffset", _BYTE, &afe_params.b_offset,
4497 &default_afe_params.b_offset);
4498
4499 decodeVal (str, "redExposure", _INT, &exp_params.r_time,
4500 &default_exp_params.r_time);
4501 decodeVal (str, "greenExposure", _INT, &exp_params.g_time,
4502 &default_exp_params.g_time);
4503 decodeVal (str, "blueExposure", _INT, &exp_params.b_time,
4504 &default_exp_params.b_time);
4505
4506 decodeVal (str, "modelString", _STRING, model_string, model_string);
4507 decodeVal (str, "vendorString", _STRING, vendor_string,
4508 vendor_string);
4509
4510 decodeVal (str, "artecFirmwareFile", _STRING, firmwarePath,
4511 firmwarePath);
4512 }
4513 else if (0 == strncmp (str, "usb", 3))
4514 {
4515 if (temp[0] != 0)
4516 {
4517 XDBG ((3, "trying to attach: %s\n", temp));
4518 XDBG ((3, " vendor: %s\n", vendor_string));
4519 XDBG ((3, " model: %s\n", model_string));
4520 sanei_usb_attach_matching_devices (temp, attach_one_device);
4521 }
4522 /*save config line in temp */
4523 strcpy (temp, str);
4524 }
4525 else if (0 == strncmp (str, "device", 6))
4526 {
4527 if (SANE_TRUE == decodeDevName (str, devName))
4528 {
4529 if (devName[0] != 0)
4530 sanei_usb_attach_matching_devices (devName,
4531 attach_one_device);
4532 temp[0] = 0;
4533 }
4534 }
4535 else
4536 {
4537 /* ignore other stuff... */
4538 XDBG ((1, "ignoring >%s<\n", str));
4539 }
4540 }
4541 if (temp[0] != 0)
4542 {
4543 XDBG ((3, "trying to attach: %s\n", temp));
4544 XDBG ((3, " vendor: %s\n", vendor_string));
4545 XDBG ((3, " model: %s\n", model_string));
4546 sanei_usb_attach_matching_devices (temp, attach_one_device);
4547 temp[0] = 0;
4548 }
4549
4550 fclose (fp);
4551 return SANE_STATUS_GOOD;
4552 }
4553
4554 void
sane_exit(void)4555 sane_exit (void)
4556 {
4557 Artec48U_Device *dev, *next;
4558
4559 XDBG ((5, "sane_exit: start\n"));
4560 for (dev = first_dev; dev; dev = next)
4561 {
4562 next = dev->next;
4563 /*function will check, whether device is really open */
4564 artec48u_device_close (dev);
4565 artec48u_device_free (dev);
4566 }
4567 XDBG ((5, "sane_exit: exit\n"));
4568 return;
4569 }
4570