1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 1998, 1999
4 Kazuya Fukuda, Abel Deuring based on BYTEC GmbH Germany
5 Written by Helmut Koeberle previous Work on canon.c file from the
6 SANE package.
7
8 This file is part of the SANE package.
9
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2 of the
13 License, or (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <https://www.gnu.org/licenses/>.
22
23 As a special exception, the authors of SANE give permission for
24 additional uses of the libraries contained in this release of SANE.
25
26 The exception is that, if you link a SANE library with other files
27 to produce an executable, this does not by itself cause the
28 resulting executable to be covered by the GNU General Public
29 License. Your use of that executable is in no way restricted on
30 account of linking the SANE library code into it.
31
32 This exception does not, however, invalidate any other reasons why
33 the executable file might be covered by the GNU General Public
34 License.
35
36 If you submit changes to SANE to the maintainers to be included in
37 a subsequent release, you agree by submitting the changes that
38 those changes may be distributed with this exception intact.
39
40 If you write modifications of your own for SANE, it is your choice
41 whether to permit this exception to apply to your modifications.
42 If you do not wish that, delete this exception notice.
43
44 This file implements a SANE backend for Sharp flatbed scanners. */
45
46 /*
47 Version 0.32
48 changes to version 0.31:
49 - support for JX320 added (Thanks to Isaac Wilcox for providind the
50 patch)
51
52 Version 0.31
53 changes to version 0.30:
54 - support for JX350 added (Thanks to Shuhei Tomita for providind the
55 patch)
56
57 changes to version 0.20
58 - support for the proposed extended open function in sanei_scsi.c added
59 - support for ADF and FSU (transparency adapter) added
60 - simple sense handler added
61 - preview added
62 - added several missing statements "s->fd = -1;" after
63 "sanei_scsi_close(s->fd)" to error returns in sane_start();
64 - maximum scan sizes are read from the scanner, if a JX330 or JX250
65 is used. (this avoids the guessing of scan sizes for the JX330)
66 - gamma table support added
67 - "Fixed gamma selection (1.0/2.2)", available for JX330 and JX610,
68 is now implemented for the JX250 by downloading a gamma table
69 - changed the calls to free() and strdup() in sane_control_option to
70 strcpy.
71 (I don't like too frequent unchecked malloc()s and strdups :) Abel)
72 - cleaned up some quirks in option handling, eg, that "threshold"
73 was initially enabled, while the initial scan mode is "color"
74 - cleaned up setting SANE_INFO_RELOAD_OPTIONS and SANE_INFO_RELOAD_PARAMS
75 bits in sane_control_option
76 - bi-level color scans now give useful (8 bit) output
77 - separate thresholds for red, green, blue (bi-level color scan) added
78 */
79 #include "../include/sane/config.h"
80
81 #include <limits.h>
82 #include <stdlib.h>
83 #include <stdarg.h>
84 #include <string.h>
85 #include <unistd.h>
86 #include <errno.h>
87 #include <math.h>
88
89 #include "../include/sane/sane.h"
90 #include "../include/sane/saneopts.h"
91 #include "../include/sane/sanei_scsi.h"
92
93 /* QUEUEDEBUG should be undefined unless you want to play
94 with the sanei_scsi.c under Linux and/or with the Linux's SG driver,
95 or your suspect problems with command queueing
96 */
97 #if 0
98 #define QUEUEDEBUG
99 #define DEBUG
100 #ifdef DEBUG
101 #include <unistd.h>
102 #include <sys/time.h>
103 #endif
104 #endif
105
106 /* USE_FORK: fork a special reader process
107 */
108
109 #ifdef HAVE_SYS_SHM_H
110 #ifndef HAVE_OS2_H
111 #define USE_FORK
112 #endif
113 #endif
114
115 #ifdef USE_FORK
116 #include <signal.h>
117 #include <fcntl.h>
118 #include <sys/types.h>
119 #include <sys/wait.h>
120
121 #include <sys/ipc.h>
122 #include <sys/shm.h>
123
124 #endif /* USE_FORK */
125
126 /* xxx I'm not sure, if I understood the JX610 and JX330 manuals right,
127 that the data for the SEND command should be in ASCII format...
128 SEND commands with a data bock are used, if USE_CUSTOM_GAMMA
129 and / or USE_COLOR_THRESHOLD are enabled.
130 Abel
131 */
132 #define USE_CUSTOM_GAMMA
133 #define USE_COLOR_THRESHOLD
134 /* enable a short list of some standard resolutions. XSane provides
135 its own resolution list; therefore its is generally not reasonable
136 to enable this list, if you mainly using XSane. But it might be handy
137 if you are working with xscanimage
138 */
139 /* #define USE_RESOLUTION_LIST */
140
141 /* enable separate specification of resolution in X and Y direction.
142 XSane will show the Y-resolution at a quite different place than
143 the X-resolution
144 */
145 /* #define USE_SEPARATE_Y_RESOLUTION */
146
147
148 #define BACKEND_NAME sharp
149 #include "../include/sane/sanei_backend.h"
150
151 #include <sharp.h>
152
153 #ifndef PATH_MAX
154 #define PATH_MAX 1024
155 #endif
156
157 #define DEFAULT_MUD_JX610 25
158 #define DEFAULT_MUD_JX320 25
159 #define DEFAULT_MUD_JX330 1200
160 #define DEFAULT_MUD_JX250 1200
161
162 #define PIX_TO_MM(x, mud) ((x) * 25.4 / mud)
163 #define MM_TO_PIX(x, mud) ((x) * mud / 25.4)
164
165 #include "../include/sane/sanei_config.h"
166 #define SHARP_CONFIG_FILE "sharp.conf"
167
168 static int num_devices = 0;
169 static SHARP_Device *first_dev = NULL;
170 static SHARP_Scanner *first_handle = NULL;
171
172 typedef enum
173 {
174 MODES_LINEART = 0,
175 MODES_GRAY,
176 MODES_LINEART_COLOR,
177 MODES_COLOR
178 }
179 Modes;
180
181 #define M_LINEART SANE_VALUE_SCAN_MODE_LINEART
182 #define M_GRAY SANE_VALUE_SCAN_MODE_GRAY
183 #define M_LINEART_COLOR SANE_VALUE_SCAN_MODE_COLOR_LINEART
184 #define M_COLOR SANE_VALUE_SCAN_MODE_COLOR
185 static const SANE_String_Const mode_list[] =
186 {
187 M_LINEART, M_GRAY, M_LINEART_COLOR, M_COLOR,
188 0
189 };
190
191 #define M_BILEVEL "none"
192 #define M_BAYER "Dither Bayer"
193 #define M_SPIRAL "Dither Spiral"
194 #define M_DISPERSED "Dither Dispersed"
195 #define M_ERRDIFFUSION "Error Diffusion"
196
197 static const SANE_String_Const halftone_list[] =
198 {
199 M_BILEVEL, M_BAYER, M_SPIRAL, M_DISPERSED, M_ERRDIFFUSION,
200 0
201 };
202
203 #define LIGHT_GREEN "green"
204 #define LIGHT_RED "red"
205 #define LIGHT_BLUE "blue"
206 #define LIGHT_WHITE "white"
207
208 #define MAX_RETRIES 50
209
210 static const SANE_String_Const light_color_list[] =
211 {
212 LIGHT_GREEN, LIGHT_RED, LIGHT_BLUE, LIGHT_WHITE,
213 0
214 };
215
216 /* possible values for ADF/FSU selection */
217 static SANE_String use_adf = "Automatic Document Feeder";
218 static SANE_String use_fsu = "Transparency Adapter";
219 static SANE_String use_simple = "Flatbed";
220
221 /* auto selection of ADF and FSU, as described in the JX330 manual,
222 is a nice idea -- but I assume that the possible scan window
223 sizes depend not only for the JX250, but also for JX330 on the
224 usage of ADF or FSU. Thus, the user might be able to select scan
225 windows of an "illegal" size, which would have to be automatically
226 corrected, and I don't see, how the user could be informed about
227 this "window clipping". More important, I don't see, how the
228 frontend could be informed that the ADF is automatically enabled.
229
230 Insert a "#define ALLOW_AUTO_SELECT_ADF", if you want to play
231 with this feature.
232 */
233 #ifdef ALLOW_AUTO_SELECT_ADF
234 static SANE_String_Const use_auto = "AutoSelection";
235 #endif
236
237 #define HAVE_FSU 1
238 #define HAVE_ADF 2
239
240 /* The follow #defines are used in SHARP_Scanner.adf_fsu_mode
241 and as indexes for the arrays x_ranges, y_ranges in SHARP_Device
242 */
243 #define SCAN_SIMPLE 0
244 #define SCAN_WITH_FSU 1
245 #define SCAN_WITH_ADF 2
246 #ifdef ALLOW_AUTO_SELECT_ADF
247 #define SCAN_ADF_FSU_AUTO 3
248 #endif
249 #define LOAD_PAPER 1
250 #define UNLOAD_PAPER 0
251
252 #define PAPER_MAX 10
253 #define W_LETTER "11\"x17\""
254 #define INVOICE "8.5\"x5.5\""
255 static const SANE_String_Const paper_list_jx610[] =
256 {
257 "A3", "A4", "A5", "A6", "B4", "B5",
258 W_LETTER, "Legal", "Letter", INVOICE,
259 0
260 };
261
262 static const SANE_String_Const paper_list_jx330[] =
263 {
264 "A4", "A5", "A6", "B5",
265 0
266 };
267
268 #define GAMMA10 "1.0"
269 #define GAMMA22 "2.2"
270
271 static const SANE_String_Const gamma_list[] =
272 {
273 GAMMA10, GAMMA22,
274 0
275 };
276
277 #if 0
278 #define SPEED_NORMAL "Normal"
279 #define SPEED_FAST "Fast"
280 static const SANE_String_Const speed_list[] =
281 {
282 SPEED_NORMAL, SPEED_FAST,
283 0
284 };
285 #endif
286
287 #ifdef USE_RESOLUTION_LIST
288 #define RESOLUTION_MAX_JX610 8
289 static const SANE_String_Const resolution_list_jx610[] =
290 {
291 "50", "75", "100", "150", "200", "300", "400", "600", "Select",
292 0
293 };
294
295 #define RESOLUTION_MAX_JX250 7
296 static const SANE_String_Const resolution_list_jx250[] =
297 {
298 "50", "75", "100", "150", "200", "300", "400", "Select",
299 0
300 };
301 #endif
302
303 #define EDGE_NONE "None"
304 #define EDGE_MIDDLE "Middle"
305 #define EDGE_STRONG "Strong"
306 #define EDGE_BLUR "Blur"
307 static const SANE_String_Const edge_emphasis_list[] =
308 {
309 EDGE_NONE, EDGE_MIDDLE, EDGE_STRONG, EDGE_BLUR,
310 0
311 };
312
313 #ifdef USE_CUSTOM_GAMMA
314 static const SANE_Range u8_range =
315 {
316 0, /* minimum */
317 255, /* maximum */
318 0 /* quantization */
319 };
320 #endif
321
322 static SANE_Status
sense_handler(int __sane_unused__ fd,u_char * sense_buffer,void * s)323 sense_handler(int __sane_unused__ fd, u_char *sense_buffer, void *s)
324 {
325 int sense_key;
326 SHARP_Sense_Data *sdat = (SHARP_Sense_Data *) s;
327
328 #define add_sense_code sense_buffer[12]
329 #define add_sense_qual sense_buffer[13]
330
331 memcpy(sdat->sb, sense_buffer, 16);
332
333 DBG(10, "sense code: %02x %02x %02x %02x %02x %02x %02x %02x "
334 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
335 sense_buffer[0], sense_buffer[1], sense_buffer[2], sense_buffer[3],
336 sense_buffer[4], sense_buffer[5], sense_buffer[6], sense_buffer[7],
337 sense_buffer[8], sense_buffer[9], sense_buffer[10], sense_buffer[11],
338 sense_buffer[12], sense_buffer[13], sense_buffer[14], sense_buffer[15]);
339
340 sense_key = sense_buffer[2] & 0x0F;
341 /* do we have additional information ? */
342 if (sense_buffer[7] >= 5)
343 {
344 if (sdat->model == JX610)
345 {
346 /* The JX610 uses somewhat different error codes */
347 switch (add_sense_code)
348 {
349 case 0x04:
350 DBG(5, "error: scanner not ready\n");
351 return SANE_STATUS_IO_ERROR;
352 case 0x08:
353 DBG(5, "error: scanner communication failure (time out?)\n");
354 return SANE_STATUS_IO_ERROR;
355 case 0x1A:
356 DBG(10, "error: parameter list length error\n");
357 return SANE_STATUS_IO_ERROR;
358 case 0x20:
359 DBG(10, "error: invalid command code\n");
360 return SANE_STATUS_IO_ERROR;
361 case 0x24:
362 DBG(10, "error: invalid field in CDB\n");
363 return SANE_STATUS_IO_ERROR;
364 case 0x25:
365 DBG(10, "error: LUN not supported\n");
366 return SANE_STATUS_IO_ERROR;
367 case 0x26:
368 DBG(10, "error: invalid field in parameter list\n");
369 return SANE_STATUS_IO_ERROR;
370 case 0x29:
371 DBG(10, "note: reset occurred\n");
372 return SANE_STATUS_GOOD;
373 case 0x2a:
374 DBG(10, "note: mode parameter change\n");
375 return SANE_STATUS_GOOD;
376 case 0x37:
377 DBG(10, "note: rounded parameter\n");
378 return SANE_STATUS_GOOD;
379 case 0x39:
380 DBG(10, "error: saving parameter not supported\n");
381 return SANE_STATUS_IO_ERROR;
382 case 0x47:
383 DBG(10, "SCSI parity error\n");
384 return SANE_STATUS_IO_ERROR;
385 case 0x48:
386 DBG(10, "initiator detected error message received\n");
387 return SANE_STATUS_IO_ERROR;
388 case 0x60:
389 DBG(1, "error: lamp failure\n");
390 return SANE_STATUS_IO_ERROR;
391 case 0x62:
392 DBG(1, "scan head positioning error\n");
393 return SANE_STATUS_IO_ERROR;
394 }
395
396 }
397 else if (sdat->model == JX250 || sdat->model == JX330 ||
398 sdat->model == JX350 || sdat->model == JX320)
399 {
400 switch (sense_key)
401 {
402 case 0x02: /* not ready */
403 switch (add_sense_code)
404 {
405 case 0x80:
406 switch (add_sense_qual)
407 {
408 case 0:
409 DBG(1, "Scanner not ready: ADF cover open\n");
410 if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
411 return SANE_STATUS_COVER_OPEN;
412 else
413 return SANE_STATUS_GOOD;
414 case 1:
415 DBG(1, "Scanner not ready: ADF maintenance "
416 "cover open\n");
417 if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
418 return SANE_STATUS_COVER_OPEN;
419 else
420 return SANE_STATUS_GOOD;
421 default:
422 DBG(5, "Scanner not ready: undocumented reason\n");
423 return SANE_STATUS_IO_ERROR;
424 }
425 case 0x81:
426 /* NOT TESTED -- I don't have a FSU */
427 switch (add_sense_qual)
428 {
429 case 0:
430 DBG(1, "Scanner not ready: FSU cover open\n");
431 if (sdat->complain_on_errors & COMPLAIN_ON_FSU_ERROR)
432 return SANE_STATUS_COVER_OPEN;
433 else
434 return SANE_STATUS_GOOD;
435 case 1:
436 DBG(1, "Scanner not ready: FSU light dispersion "
437 "error\n");
438 if (sdat->complain_on_errors & COMPLAIN_ON_FSU_ERROR)
439 {
440 return SANE_STATUS_IO_ERROR;
441 }
442 else
443 return SANE_STATUS_GOOD;
444 default:
445 DBG(5, "Scanner not ready: undocumented reason\n");
446 return SANE_STATUS_IO_ERROR;
447 }
448 default:
449 DBG(5, "Scanner not ready: undocumented reason\n");
450 return SANE_STATUS_IO_ERROR;
451 }
452 case 0x03: /* medium error */
453 switch (add_sense_code)
454 {
455 case 0x3a:
456 DBG(1, "ADF is empty\n");
457 if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
458 return SANE_STATUS_NO_DOCS;
459 else
460 return SANE_STATUS_GOOD;
461 case 0x53:
462 DBG(1, "ADF paper jam\n"
463 "Open and close the maintenance cover to clear "
464 "this error\n");
465 if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
466 return SANE_STATUS_JAMMED;
467 else
468 return SANE_STATUS_GOOD;
469 default:
470 DBG(5, "medium error: undocumented reason\n");
471 return SANE_STATUS_IO_ERROR;
472 }
473 case 0x04: /* hardware error */
474 switch (add_sense_code)
475 {
476 case 0x08:
477 DBG(1, "hardware error: scanner communication failed\n");
478 return SANE_STATUS_IO_ERROR;
479 case 0x60:
480 DBG(1, "hardware error: lamp failure\n");
481 return SANE_STATUS_IO_ERROR;
482 case 0x62:
483 DBG(1, "hardware error: scan head positioning failed\n");
484 return SANE_STATUS_IO_ERROR;
485 default:
486 DBG(1, "general hardware error\n");
487 return SANE_STATUS_IO_ERROR;
488 }
489 case 0x05: /* illegal request */
490 DBG(10, "error: illegal request\n");
491 return SANE_STATUS_IO_ERROR;
492 case 0x06: /* unit attention */
493 switch (add_sense_code)
494 {
495 case 0x29:
496 DBG(5, "unit attention: reset occurred\n");
497 return SANE_STATUS_GOOD;
498 case 0x2a:
499 DBG(5, "unit attention: parameter changed by "
500 "another initiator\n");
501 return SANE_STATUS_IO_ERROR;
502 default:
503 DBG(5, "unit attention: exact reason not documented\n");
504 return SANE_STATUS_IO_ERROR;
505 }
506 case 0x09: /* data remains */
507 DBG(5, "error: data remains\n");
508 return SANE_STATUS_IO_ERROR;
509 default:
510 DBG(5, "error: sense code not documented\n");
511 return SANE_STATUS_IO_ERROR;
512 }
513 }
514 }
515 return SANE_STATUS_IO_ERROR;
516 }
517
518 static SANE_Status
test_unit_ready(int fd)519 test_unit_ready (int fd)
520 {
521 static u_char cmd[] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
522 SANE_Status status;
523 DBG (11, "<< test_unit_ready ");
524
525 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
526
527 DBG (11, ">>\n");
528 return (status);
529 }
530
531 #if 0
532 static SANE_Status
533 request_sense (int fd, void *sense_buf, size_t *sense_size)
534 {
535 static u_char cmd[] = {REQUEST_SENSE, 0, 0, 0, SENSE_LEN, 0};
536 SANE_Status status;
537 DBG (11, "<< request_sense ");
538
539 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), sense_buf, sense_size);
540
541 DBG (11, ">>\n");
542 return (status);
543 }
544 #endif
545
546 static SANE_Status
inquiry(int fd,void * inq_buf,size_t * inq_size)547 inquiry (int fd, void *inq_buf, size_t *inq_size)
548 {
549 static u_char cmd[] = {INQUIRY, 0, 0, 0, INQUIRY_LEN, 0};
550 SANE_Status status;
551 DBG (11, "<< inquiry ");
552
553 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), inq_buf, inq_size);
554
555 DBG (11, ">>\n");
556 return (status);
557 }
558
559 static SANE_Status
mode_select_mud(int fd,int mud)560 mode_select_mud (int fd, int mud)
561 {
562 static u_char cmd[6 + MODEPARAM_LEN] =
563 {MODE_SELECT6, 0x10, 0, 0, MODEPARAM_LEN, 0};
564 mode_select_param *mp;
565 SANE_Status status;
566 DBG (11, "<< mode_select_mud ");
567
568 mp = (mode_select_param *)(cmd + 6);
569 memset (mp, 0, MODEPARAM_LEN);
570 mp->page_code = 3;
571 mp->page_length = 6;
572 mp->mud[0] = mud >> 8;
573 mp->mud[1] = mud & 0xFF;
574
575 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
576
577 DBG (11, ">>\n");
578 return (status);
579 }
580
581 static SANE_Status
mode_select_adf_fsu(int fd,int mode)582 mode_select_adf_fsu (int fd, int mode)
583 {
584 static u_char cmd[6 + MODE_SUBDEV_LEN] =
585 {MODE_SELECT6, 0x10, 0, 0, MODE_SUBDEV_LEN, 0};
586 mode_select_subdevice *mp;
587 SANE_Status status;
588 DBG (11, "<< mode_select_adf_fsu ");
589
590 mp = (mode_select_subdevice *)(cmd + 6);
591 memset (mp, 0, MODE_SUBDEV_LEN);
592 mp->page_code = 0x20;
593 mp->page_length = 26;
594 switch (mode)
595 {
596 case SCAN_SIMPLE:
597 mp->a_mode = 0x40;
598 mp->f_mode = 0x40;
599 break;
600 case SCAN_WITH_FSU:
601 mp->a_mode = 0;
602 mp->f_mode = 0x40;
603 break;
604 case SCAN_WITH_ADF:
605 mp->a_mode = 0x40;
606 mp->f_mode = 0;
607 break;
608 #ifdef ALLOW_AUTO_SELECT_ADF
609 case: SCAN_ADF_FSU_AUTO:
610 mp->a_mode = 0;
611 mp->f_mode = 0;
612 break;
613 #endif
614 }
615
616 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
617
618 DBG (11, ">>\n");
619 return (status);
620 }
621
622 static SANE_Status wait_ready(int fd);
623
624 static SANE_Status
object_position(int fd,int load)625 object_position(int fd, int load)
626 {
627 static u_char cmd[] = {OBJECT_POSITION, 0, 0, 0, 0, 0, 0, 0, 0, 0};
628 SANE_Status status;
629 DBG (11, "<< object_position ");
630
631 cmd[1] = load;
632
633 wait_ready(fd);
634 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
635
636 DBG (11, ">>\n");
637 return (status);
638 }
639
640 #if 0
641 static SANE_Status
642 reserve_unit (int fd)
643 {
644 static u_char cmd[] = {RESERVE_UNIT, 0, 0, 0, 0, 0};
645 SANE_Status status;
646 DBG (11, "<< reserve_unit ");
647
648 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
649
650 DBG (11, ">>\n");
651 return (status);
652 }
653 #endif
654
655 #if 0
656 static SANE_Status
657 release_unit (int fd)
658 {
659 static u_char cmd[] = {RELEASE_UNIT, 0, 0, 0, 0, 0};
660 SANE_Status status;
661 DBG (11, "<< release_unit ");
662
663 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
664
665 DBG (11, ">>\n");
666 return (status);
667 }
668 #endif
669
670 static SANE_Status
mode_sense(int fd,void * modeparam_buf,size_t * modeparam_size,int page)671 mode_sense (int fd, void *modeparam_buf, size_t * modeparam_size,
672 int page)
673 {
674 static u_char cmd[6];
675 SANE_Status status;
676 DBG (11, "<< mode_sense ");
677
678 memset (cmd, 0, sizeof (cmd));
679 cmd[0] = 0x1a;
680 cmd[2] = page;
681 cmd[4] = *modeparam_size;
682 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), modeparam_buf,
683 modeparam_size);
684
685 DBG (11, ">>\n");
686 return (status);
687 }
688
689 static SANE_Status
scan(int fd)690 scan (int fd)
691 {
692 static u_char cmd[] = {SCAN, 0, 0, 0, 0, 0};
693 SANE_Status status;
694 DBG (11, "<< scan ");
695
696 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
697
698 DBG (11, ">>\n");
699 return (status);
700 }
701
702 #if 0
703 static SANE_Status
704 send_diagnostics (int fd)
705 {
706 static u_char cmd[] = {SEND_DIAGNOSTIC, 0x04, 0, 0, 0, 0};
707 SANE_Status status;
708 DBG (11, "<< send_diagnostics ");
709
710 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
711
712 DBG (11, ">>\n");
713 return (status);
714 }
715 #endif
716
717 static SANE_Status
send(int fd,SHARP_Send * ss)718 send (int fd, SHARP_Send * ss)
719 {
720 static u_char cmd[] = {SEND, 0, 0, 0, 0, 0, 0, 0, 0, 0};
721 SANE_Status status;
722 DBG (11, "<< send ");
723
724 cmd[2] = ss->dtc;
725 cmd[4] = ss->dtq >> 8;
726 cmd[5] = ss->dtq;
727 cmd[6] = ss->length >> 16;
728 cmd[7] = ss->length >> 8;
729 cmd[8] = ss->length >> 0;
730
731 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
732
733 DBG (11, ">>\n");
734 return (status);
735
736 }
737
738 static SANE_Status
set_window(int fd,window_param * wp,int len)739 set_window (int fd, window_param *wp, int len)
740 {
741 static u_char cmd[10 + WINDOW_LEN] =
742 {SET_WINDOW, 0, 0, 0, 0, 0, 0, 0, 0, 0};
743 window_param *winp;
744 SANE_Status status;
745 DBG (11, "<< set_window ");
746
747 cmd[8] = len;
748 winp = (window_param *)(cmd + 10);
749 memset (winp, 0, WINDOW_LEN);
750 memcpy (winp, wp, len);
751 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
752
753 DBG (11, ">>\n");
754 return (status);
755
756 }
757
758 static SANE_Status
get_window(int fd,void * buf,size_t * buf_size)759 get_window (int fd, void *buf, size_t * buf_size)
760 {
761
762 static u_char cmd[10] = {GET_WINDOW, 0, 0, 0, 0, 0, 0, 0, WINDOW_LEN, 0};
763 SANE_Status status;
764 DBG (11, "<< get_window ");
765
766 cmd[8] = *buf_size;
767 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
768
769 DBG (11, ">>\n");
770 return (status);
771 }
772
773 #ifdef USE_FORK
774
775 /* the following four functions serve simply the purpose
776 to avoid "over-optimised" code when reader_process and
777 read_data wait for the buffer to become ready. The simple
778 while-loops in these functions which check the buffer
779 status may be optimised so that the machine code only
780 operates with registers instead of using the variable
781 values stored in memory. (This is only a workaround -
782 it would be better to set a compiler pragma, which ensures
783 that the program looks into the RAM in these while loops --
784 but unfortunately I could not find appropriate information
785 about this at least for gcc, not to speak about other
786 compilers...
787 Abel)
788 */
789
790 static int
cancel_requested(SHARP_Scanner * s)791 cancel_requested(SHARP_Scanner *s)
792 {
793 return s->rdr_ctl->cancel;
794 }
795
796 static SANE_Status
rdr_status(SHARP_Scanner * s)797 rdr_status(SHARP_Scanner *s)
798 {
799 return s->rdr_ctl->status;
800 }
801
802 static int
buf_status(SHARP_shmem_ctl * s)803 buf_status(SHARP_shmem_ctl *s)
804 {
805 return s->shm_status;
806 }
807
808 static int
reader_running(SHARP_Scanner * s)809 reader_running(SHARP_Scanner *s)
810 {
811 return s->rdr_ctl->running;
812 }
813
814 static int
reader_process(SHARP_Scanner * s)815 reader_process(SHARP_Scanner *s)
816 {
817 SANE_Status status;
818 sigset_t sigterm_set;
819 static u_char cmd[] = {READ, 0, 0, 0, 0, 0, 0, 0, 0, 0};
820 int full_count = 0, counted;
821 size_t waitindex, cmdindex;
822 size_t bytes_to_queue;
823 size_t nread;
824 size_t max_bytes_per_read;
825 int max_queue;
826 int i, retries = MAX_RETRIES;
827 SHARP_shmem_ctl *bc;
828
829 s->rdr_ctl->running = 1;
830 DBG(11, "<< reader_process\n");
831
832 sigemptyset (&sigterm_set);
833
834 bytes_to_queue = s->bytes_to_read;
835
836 /* it seems that some carriage stops can be avoided with the
837 JX-250, if the data of an integral number of scan lines is
838 read with one SCSI command
839 */
840 max_bytes_per_read = s->dev->info.bufsize / s->params.bytes_per_line;
841 if (max_bytes_per_read)
842 max_bytes_per_read *= s->params.bytes_per_line;
843 else
844 /* this is a really tiny buffer..*/
845 max_bytes_per_read = s->dev->info.bufsize;
846
847 /* wait_ready(s->fd); */
848
849 if (s->dev->info.queued_reads <= s->dev->info.buffers)
850 max_queue = s->dev->info.queued_reads;
851 else
852 max_queue = s->dev->info.buffers;
853 if (max_queue <= 0)
854 max_queue = 1;
855 for (i = 0; i < max_queue; i++)
856 {
857 bc = &s->rdr_ctl->buf_ctl[i];
858 if (bytes_to_queue)
859 {
860 nread = bytes_to_queue;
861 if (nread > max_bytes_per_read)
862 nread = max_bytes_per_read;
863 bc->used = nread;
864 cmd[6] = nread >> 16;
865 cmd[7] = nread >> 8;
866 cmd[8] = nread;
867 #ifdef QUEUEDEBUG
868 DBG(2, "reader: req_enter...\n");
869 #endif
870 status = sanei_scsi_req_enter (s->fd, cmd, sizeof (cmd),
871 bc->buffer,
872 &bc->used,
873 &bc->qid);
874 #ifdef QUEUEDEBUG
875 DBG(2, "reader: req_enter ok\n");
876 #endif
877 if (status != SANE_STATUS_GOOD)
878 {
879 DBG(1, "reader_process: read command failed: %s",
880 sane_strstatus(status));
881 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
882 sanei_scsi_req_flush_all_extended(s->fd);
883 #else
884 sanei_scsi_req_flush_all();
885 #endif
886 s->rdr_ctl->status = status;
887 s->rdr_ctl->running = 0;
888 return 2;
889 }
890 bc->shm_status = SHM_BUSY;
891 bc->nreq = bc->used;
892 bytes_to_queue -= bc->nreq;
893 }
894 else
895 {
896 bc->used = 0;
897 bc->shm_status = SHM_EMPTY;
898 }
899 }
900 waitindex = 0;
901 cmdindex = i % s->dev->info.buffers;
902
903 while(s->bytes_to_read > 0)
904 {
905 if (cancel_requested(s))
906 {
907 #ifdef QUEUEDEBUG
908 DBG(2, "reader: flushing requests...\n");
909 #endif
910 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
911 sanei_scsi_req_flush_all_extended(s->fd);
912 #else
913 sanei_scsi_req_flush_all();
914 #endif
915 #ifdef QUEUEDEBUG
916 DBG(2, "reader: flushing requests ok\n");
917 #endif
918 s->rdr_ctl->cancel = 0;
919 s->rdr_ctl->status = SANE_STATUS_CANCELLED;
920 s->rdr_ctl->running = 0;
921 DBG(11, " reader_process (cancelled) >>\n");
922 return 1;
923 }
924
925 bc = &s->rdr_ctl->buf_ctl[waitindex];
926 if (bc->shm_status == SHM_BUSY)
927 {
928 #ifdef DEBUG
929 {
930 struct timeval t;
931 gettimeofday(&t, 0);
932 DBG(2, "rd: waiting for data %li.%06li\n", t.tv_sec, t.tv_usec);
933 }
934 #endif
935 #ifdef QUEUEDEBUG
936 DBG(2, "reader: req_wait...\n");
937 #endif
938 status = sanei_scsi_req_wait(bc->qid);
939 #ifdef QUEUEDEBUG
940 DBG(2, "reader: req_wait ok\n");
941 #endif
942 #ifdef DEBUG
943 {
944 struct timeval t;
945 gettimeofday(&t, 0);
946 DBG(2, "rd: data received %li.%06li\n", t.tv_sec, t.tv_usec);
947 }
948 #endif
949 if (status == SANE_STATUS_DEVICE_BUSY && retries)
950 {
951 bc->used = 0;
952 retries--;
953 DBG(11, "reader: READ command returned BUSY\n");
954 status = SANE_STATUS_GOOD;
955 usleep(10000);
956 }
957 else if (status != SANE_STATUS_GOOD)
958 {
959 DBG(1, "reader_process: read command failed: %s\n",
960 sane_strstatus(status));
961 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
962 sanei_scsi_req_flush_all_extended(s->fd);
963 #else
964 sanei_scsi_req_flush_all();
965 #endif
966 s->rdr_ctl->status = status;
967 s->rdr_ctl->running = 0;
968 return 2;
969 }
970 else
971 {
972 retries = MAX_RETRIES;
973 }
974 #if 1
975 s->bytes_to_read -= bc->used;
976 bytes_to_queue += bc->nreq - bc->used;
977 #else
978 /* xxxxxxxxxxxxxxxxxxx TEST xxxxxxxxxxxxxxx */
979 s->bytes_to_read -= bc->nreq;
980 /* memset(bc->buffer + bc->used, 0, bc->nreq - bc->used); */
981 bc->used = bc->nreq;
982 /* bytes_to_queue += bc->nreq - bc->used; */
983 DBG(1, "btr: %i btq: %i nreq: %i nrcv: %i\n",
984 s->bytes_to_read, bytes_to_queue, bc->nreq, bc->used);
985 #endif
986 bc->start = 0;
987 bc->shm_status = SHM_FULL;
988
989 waitindex++;
990 if (waitindex == s->dev->info.buffers)
991 waitindex = 0;
992
993 }
994
995 if (bytes_to_queue)
996 {
997 /* wait until the next buffer is completely read via read_data */
998 bc = &s->rdr_ctl->buf_ctl[cmdindex];
999 counted = 0;
1000 while (buf_status(bc) != SHM_EMPTY)
1001 {
1002 if (!counted)
1003 {
1004 counted = 1;
1005 full_count++;
1006 }
1007 if (cancel_requested(s))
1008 {
1009 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
1010 sanei_scsi_req_flush_all_extended(s->fd);
1011 #else
1012 sanei_scsi_req_flush_all();
1013 #endif
1014 s->rdr_ctl->cancel = 0;
1015 s->rdr_ctl->status = SANE_STATUS_CANCELLED;
1016 s->rdr_ctl->running = 0;
1017 DBG(11, " reader_process (cancelled) >>\n");
1018 return 1;
1019 }
1020 }
1021
1022 nread = bytes_to_queue;
1023 if (nread > max_bytes_per_read)
1024 nread = max_bytes_per_read;
1025 bc->used = nread;
1026 cmd[6] = nread >> 16;
1027 cmd[7] = nread >> 8;
1028 cmd[8] = nread;
1029 status = sanei_scsi_req_enter (s->fd, cmd, sizeof (cmd),
1030 bc->buffer, &bc->used, &bc->qid);
1031 if (status != SANE_STATUS_GOOD)
1032 {
1033 DBG(1, "reader_process: read command failed: %s",
1034 sane_strstatus(status));
1035 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
1036 sanei_scsi_req_flush_all_extended(s->fd);
1037 #else
1038 sanei_scsi_req_flush_all();
1039 #endif
1040 s->rdr_ctl->status = status;
1041 s->rdr_ctl->running = 0;
1042 return 2;
1043 }
1044 bc->shm_status = SHM_BUSY;
1045 bc->nreq = nread;
1046 bytes_to_queue -= nread;
1047
1048 cmdindex++;
1049 if (cmdindex == s->dev->info.buffers)
1050 cmdindex = 0;
1051 }
1052
1053 if (cancel_requested(s))
1054 {
1055 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
1056 sanei_scsi_req_flush_all_extended(s->fd);
1057 #else
1058 sanei_scsi_req_flush_all();
1059 #endif
1060 s->rdr_ctl->cancel = 0;
1061 s->rdr_ctl->status = SANE_STATUS_CANCELLED;
1062 s->rdr_ctl->running = 0;
1063 DBG(11, " reader_process (cancelled) >>\n");
1064 return 1;
1065 }
1066 }
1067
1068 DBG(1, "buffer full conditions: %i\n", full_count);
1069 DBG(11, " reader_process>>\n");
1070
1071 s->rdr_ctl->running = 0;
1072 return 0;
1073 }
1074
1075 static SANE_Status
read_data(SHARP_Scanner * s,SANE_Byte * buf,size_t * buf_size)1076 read_data (SHARP_Scanner *s, SANE_Byte *buf, size_t * buf_size)
1077 {
1078 size_t copysize, copied = 0;
1079 SHARP_shmem_ctl *bc;
1080
1081 DBG(11, "<< read_data ");
1082
1083 bc = &s->rdr_ctl->buf_ctl[s->read_buff];
1084
1085 while (copied < *buf_size)
1086 {
1087 /* wait until the reader process delivers data or a scanner error occurs: */
1088 while ( buf_status(bc) != SHM_FULL
1089 && rdr_status(s) == SANE_STATUS_GOOD)
1090 {
1091 usleep(10); /* could perhaps be longer. make this user configurable?? */
1092 }
1093
1094 if (rdr_status(s) != SANE_STATUS_GOOD)
1095 {
1096 return rdr_status(s);
1097 DBG(11, ">>\n");
1098 }
1099
1100 copysize = bc->used - bc->start;
1101
1102 if (copysize > *buf_size - copied )
1103 copysize = *buf_size - copied;
1104
1105 memcpy(buf, &(bc->buffer[bc->start]), copysize);
1106
1107 copied += copysize;
1108 buf = &buf[copysize];
1109
1110 bc->start += copysize;
1111 if (bc->start >= bc->used)
1112 {
1113 bc->start = 0;
1114 bc->shm_status = SHM_EMPTY;
1115 s->read_buff++;
1116 if (s->read_buff == s->dev->info.buffers)
1117 s->read_buff = 0;
1118 bc = &s->rdr_ctl->buf_ctl[s->read_buff];
1119 }
1120 }
1121
1122 DBG(11, ">>\n");
1123 return SANE_STATUS_GOOD;
1124 }
1125
1126 #else /* don't USE_FORK: */
1127
1128 static SANE_Status
read_data(SHARP_Scanner * s,SANE_Byte * buf,size_t * buf_size)1129 read_data (SHARP_Scanner *s, SANE_Byte *buf, size_t * buf_size)
1130 {
1131 static u_char cmd[] = {READ, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1132 SANE_Status status = SANE_STATUS_GOOD;
1133 size_t remain = *buf_size;
1134 size_t nread;
1135 int retries = MAX_RETRIES;
1136 DBG (11, "<< read_data ");
1137
1138 /* sane_read_shuffled requires that read_data returns
1139 exactly *buf_size bytes, so it must be guaranteed here.
1140 Further make sure that not more bytes are read in than
1141 sanei_scsi_max_request_size allows, to avoid a failure
1142 of the read command
1143 */
1144 while (remain > 0)
1145 {
1146 nread = remain;
1147 if (nread > s->dev->info.bufsize)
1148 nread = s->dev->info.bufsize;
1149 cmd[6] = nread >> 16;
1150 cmd[7] = nread >> 8;
1151 cmd[8] = nread;
1152 status = sanei_scsi_cmd (s->fd, cmd, sizeof (cmd),
1153 &buf[*buf_size - remain], &nread);
1154 if (status == SANE_STATUS_DEVICE_BUSY && retries)
1155 {
1156 retries--;
1157 nread = 0;
1158 usleep(10000);
1159 }
1160 else if (status != SANE_STATUS_GOOD)
1161 {
1162 DBG(11, ">>\n");
1163 return(status);
1164 }
1165 else
1166 {
1167 retries = MAX_RETRIES;
1168 }
1169 remain -= nread;
1170 }
1171 DBG (11, ">>\n");
1172 return (status);
1173 }
1174 #endif
1175
1176 static size_t
max_string_size(const SANE_String_Const strings[])1177 max_string_size (const SANE_String_Const strings[])
1178 {
1179 size_t size, max_size = 0;
1180 int i;
1181 DBG (10, "<< max_string_size ");
1182
1183 for (i = 0; strings[i]; ++i)
1184 {
1185 size = strlen (strings[i]) + 1;
1186 if (size > max_size)
1187 max_size = size;
1188 }
1189
1190 DBG (10, ">>\n");
1191 return max_size;
1192 }
1193
1194 static SANE_Status
wait_ready(int fd)1195 wait_ready(int fd)
1196 {
1197 SANE_Status status;
1198 int retry = 0;
1199
1200 while ((status = test_unit_ready (fd)) != SANE_STATUS_GOOD)
1201 {
1202 DBG (5, "wait_ready failed (%d)\n", retry);
1203 if (retry++ > 15){
1204 return SANE_STATUS_IO_ERROR;
1205 }
1206 sleep(3);
1207 }
1208 return (status);
1209
1210 }
1211
1212 /* ask the scanner for the maximum scan sizes with/without ADF and
1213 FSU. The JX330 manual does mention the sizes.
1214 */
1215 static SANE_Status
get_max_scan_size(int fd,SHARP_Device * dev,int mode)1216 get_max_scan_size(int fd, SHARP_Device *dev, int mode)
1217 {
1218 SANE_Status status;
1219 mode_sense_subdevice m_subdev;
1220 size_t buf_size;
1221
1222 status = mode_select_adf_fsu(fd, mode);
1223 if (status != SANE_STATUS_GOOD)
1224 {
1225 DBG (1, "get_scan_sizes: MODE_SELECT/subdevice page failed\n");
1226 sanei_scsi_close (fd);
1227 return (SANE_STATUS_INVAL);
1228 }
1229
1230 DBG (3, "get_scan_sizes: sending MODE SENSE/subdevice page\n");
1231 memset (&m_subdev, 0, sizeof (m_subdev));
1232 buf_size = sizeof (m_subdev);
1233 status = mode_sense (fd, &m_subdev, &buf_size, 0x20);
1234 if (status != SANE_STATUS_GOOD)
1235 {
1236 DBG (1, "get_scan_sizes: MODE_SENSE/subdevice page failed\n");
1237 sanei_scsi_close (fd);
1238 return (SANE_STATUS_INVAL);
1239 }
1240
1241 dev->info.tl_x_ranges[mode].min = 0;
1242 dev->info.tl_x_ranges[mode].max = SANE_FIX(PIX_TO_MM(
1243 (m_subdev.max_x[0] << 24) + (m_subdev.max_x[1] << 16) +
1244 (m_subdev.max_x[2] << 8) + m_subdev.max_x[3] - 1, dev->info.mud));
1245 dev->info.tl_x_ranges[mode].quant = 0;
1246
1247 dev->info.br_x_ranges[mode].min = SANE_FIX(PIX_TO_MM(1, dev->info.mud));
1248 dev->info.br_x_ranges[mode].max = SANE_FIX(PIX_TO_MM(
1249 (m_subdev.max_x[0] << 24) + (m_subdev.max_x[1] << 16) +
1250 (m_subdev.max_x[2] << 8) + m_subdev.max_x[3], dev->info.mud));
1251 dev->info.br_x_ranges[mode].quant = 0;
1252
1253 dev->info.tl_y_ranges[mode].min = 0;
1254 if ((dev->sensedat.model != JX250 && dev->sensedat.model != JX350) ||
1255 mode != SCAN_WITH_FSU)
1256 dev->info.tl_y_ranges[mode].max = SANE_FIX(PIX_TO_MM(
1257 (m_subdev.max_y[0] << 24) + (m_subdev.max_y[1] << 16) +
1258 (m_subdev.max_y[2] << 8) + m_subdev.max_y[3] - 1, dev->info.mud));
1259 else
1260 /* The manual for the JX250 states on page 62 that the maximum
1261 value for tl_y in FSU mode is 13199, while the max value for
1262 br_y is 13900, which is (probably -- I don't have a FSU) returned
1263 by mode sense/subdevice page. Therefore, we cannot simply
1264 decrement that value and store it as max(tl_y).
1265 */
1266 dev->info.tl_y_ranges[mode].max = 13199;
1267 dev->info.tl_y_ranges[mode].quant = 0;
1268
1269 dev->info.br_y_ranges[mode].min = SANE_FIX(PIX_TO_MM(1, dev->info.mud));
1270 dev->info.br_y_ranges[mode].max = SANE_FIX(PIX_TO_MM(
1271 (m_subdev.max_y[0] << 24) + (m_subdev.max_y[1] << 16) +
1272 (m_subdev.max_y[2] << 8) + m_subdev.max_y[3], dev->info.mud));
1273 dev->info.br_y_ranges[mode].quant = 0;
1274
1275 return SANE_STATUS_GOOD;
1276 }
1277
1278 static SANE_Status
attach(const char * devnam,SHARP_Device ** devp)1279 attach (const char *devnam, SHARP_Device ** devp)
1280 {
1281 SANE_Status status;
1282 SHARP_Device *dev;
1283 SHARP_Sense_Data sensedat;
1284
1285 int fd;
1286 char inquiry_data[INQUIRY_LEN];
1287 const char *model_name;
1288 mode_sense_param msp;
1289 mode_sense_subdevice m_subdev;
1290 size_t buf_size;
1291 DBG (10, "<< attach ");
1292
1293 for (dev = first_dev; dev; dev = dev->next)
1294 {
1295 if (strcmp (dev->sane.name, devnam) == 0)
1296 {
1297 if (devp)
1298 *devp = dev;
1299 return (SANE_STATUS_GOOD);
1300 }
1301 }
1302
1303 sensedat.model = unknown;
1304 sensedat.complain_on_errors = 0;
1305 DBG (3, "attach: opening %s\n", devnam);
1306 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
1307 {
1308 int bufsize = 4096;
1309 status = sanei_scsi_open_extended (devnam, &fd, &sense_handler, &sensedat, &bufsize);
1310 if (status != SANE_STATUS_GOOD)
1311 {
1312 DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
1313 return (status);
1314 }
1315 if (bufsize < 4096)
1316 {
1317 DBG(1, "attach: open failed. no memory\n");
1318 sanei_scsi_close(fd);
1319 return SANE_STATUS_NO_MEM;
1320 }
1321 }
1322 #else
1323 status = sanei_scsi_open (devnam, &fd, &sense_handler, &sensedat);
1324 if (status != SANE_STATUS_GOOD)
1325 {
1326 DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
1327 return (status);
1328 }
1329 #endif
1330
1331 DBG (3, "attach: sending INQUIRY\n");
1332 memset (inquiry_data, 0, sizeof (inquiry_data));
1333 buf_size = sizeof (inquiry_data);
1334 status = inquiry (fd, inquiry_data, &buf_size);
1335 if (status != SANE_STATUS_GOOD)
1336 {
1337 DBG (1, "attach: inquiry failed: %s\n", sane_strstatus (status));
1338 sanei_scsi_close (fd);
1339 return (status);
1340 }
1341
1342 if (inquiry_data[0] == 6 && strncmp (inquiry_data + 8, "SHARP", 5) == 0)
1343 {
1344 if (strncmp (inquiry_data + 16, "JX610", 5) == 0)
1345 sensedat.model = JX610;
1346 else if (strncmp (inquiry_data + 16, "JX250", 5) == 0)
1347 sensedat.model = JX250;
1348 else if (strncmp (inquiry_data + 16, "JX350", 5) == 0)
1349 sensedat.model = JX350;
1350 else if ( strncmp (inquiry_data + 16, "JX320", 5) == 0
1351 || strncmp (inquiry_data + 16, "JX325", 5) == 0)
1352 sensedat.model = JX320;
1353 else if (strncmp (inquiry_data + 16, "JX330", 5) == 0)
1354 sensedat.model = JX330;
1355 }
1356
1357 if (sensedat.model == unknown)
1358 {
1359 DBG (1, "attach: device doesn't look like a Sharp scanner\n");
1360 sanei_scsi_close (fd);
1361 return (SANE_STATUS_INVAL);
1362 }
1363
1364 DBG (3, "attach: sending TEST_UNIT_READY\n");
1365 status = test_unit_ready (fd);
1366 if (status != SANE_STATUS_GOOD)
1367 {
1368 DBG (1, "attach: test unit ready failed (%s)\n",
1369 sane_strstatus (status));
1370 sanei_scsi_close (fd);
1371 return (status);
1372 }
1373
1374 DBG (3, "attach: sending MODE SELECT\n");
1375 /* JX-610 probably supports only 25 MUD size
1376 JX-320 only supports 25 MUD size
1377 */
1378 if (strncmp (inquiry_data + 16, "JX610", 5) == 0)
1379 status = mode_select_mud (fd, DEFAULT_MUD_JX610);
1380 else if (strncmp (inquiry_data + 16, "JX320", 5) == 0)
1381 status = mode_select_mud (fd, DEFAULT_MUD_JX320);
1382 else
1383 status = mode_select_mud (fd, DEFAULT_MUD_JX330);
1384
1385 if (status != SANE_STATUS_GOOD)
1386 {
1387 DBG (1, "attach: MODE_SELECT6 failed\n");
1388 sanei_scsi_close (fd);
1389 return (SANE_STATUS_INVAL);
1390 }
1391
1392 DBG (3, "attach: sending MODE SENSE/MUP page\n");
1393 memset (&msp, 0, sizeof (msp));
1394 buf_size = sizeof (msp);
1395 status = mode_sense (fd, &msp, &buf_size, 3);
1396 if (status != SANE_STATUS_GOOD)
1397 {
1398 DBG (1, "attach: MODE_SENSE/MUP page failed\n");
1399 sanei_scsi_close (fd);
1400 return (SANE_STATUS_INVAL);
1401 }
1402
1403 dev = malloc (sizeof (*dev));
1404 if (!dev)
1405 return (SANE_STATUS_NO_MEM);
1406 memset (dev, 0, sizeof (*dev));
1407
1408 dev->sane.name = strdup (devnam);
1409 dev->sane.vendor = "SHARP";
1410 model_name = (char*) inquiry_data + 16;
1411 dev->sane.model = strndup (model_name, 10);
1412 dev->sane.type = "flatbed scanner";
1413
1414 dev->sensedat.model = sensedat.model;
1415
1416 DBG (5, "dev->sane.name = %s\n", dev->sane.name);
1417 DBG (5, "dev->sane.vendor = %s\n", dev->sane.vendor);
1418 DBG (5, "dev->sane.model = %s\n", dev->sane.model);
1419 DBG (5, "dev->sane.type = %s\n", dev->sane.type);
1420
1421 dev->info.xres_range.quant = 0;
1422 dev->info.yres_range.quant = 0;
1423
1424 dev->info.tl_x_ranges[SCAN_SIMPLE].min = SANE_FIX(0);
1425 dev->info.br_x_ranges[SCAN_SIMPLE].min = SANE_FIX(1);
1426 dev->info.tl_y_ranges[SCAN_SIMPLE].min = SANE_FIX(0);
1427 dev->info.br_y_ranges[SCAN_SIMPLE].min = SANE_FIX(1);
1428 dev->info.tl_x_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
1429 dev->info.br_x_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
1430 dev->info.tl_y_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
1431 dev->info.br_y_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
1432
1433 dev->info.xres_default = 150;
1434 dev->info.yres_default = 150;
1435 dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(209);
1436 dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210);
1437 dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(296);
1438 dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297);
1439
1440 dev->info.bmu = msp.bmu;
1441 dev->info.mud = (msp.mud[0] << 8) + msp.mud[1];
1442
1443 dev->info.adf_fsu_installed = 0;
1444 if (dev->sensedat.model == JX610)
1445 {
1446 dev->info.xres_range.max = 600;
1447 dev->info.xres_range.min = 30;
1448
1449 dev->info.yres_range.max = 600;
1450 dev->info.yres_range.min = 30;
1451 dev->info.x_default = SANE_FIX(210);
1452 dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(303); /* 304.8mm is the real max */
1453 dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(304); /* 304.8mm is the real max */
1454
1455 dev->info.y_default = SANE_FIX(297);
1456 dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(430); /* 431.8 is the real max */
1457 dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(431); /* 431.8 is the real max */
1458 }
1459 else if (dev->sensedat.model == JX320)
1460 {
1461 dev->info.xres_range.max = 600;
1462 dev->info.xres_range.min = 30;
1463
1464 dev->info.yres_range.max = 600;
1465 dev->info.yres_range.min = 30;
1466 dev->info.x_default = SANE_FIX(210);
1467 dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(212);
1468 dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(213);
1469
1470 dev->info.y_default = SANE_FIX(297);
1471 dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(292);
1472 dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(293);
1473 }
1474 else
1475 {
1476 /* ask the scanner, if ADF or FSU are installed, and ask for
1477 the maximum scan sizes with/without ADF and FSU.
1478 */
1479
1480 DBG (3, "attach: sending MODE SENSE/subdevice page\n");
1481 memset (&m_subdev, 0, sizeof (m_subdev));
1482 buf_size = sizeof (m_subdev);
1483 status = mode_sense (fd, &m_subdev, &buf_size, 0x20);
1484 if (status != SANE_STATUS_GOOD)
1485 {
1486 DBG (1, "attach: MODE_SENSE/subdevice page failed\n");
1487 sanei_scsi_close (fd);
1488 return (SANE_STATUS_INVAL);
1489 }
1490
1491 /* The JX330 manual is not very clear about the ADF- und FSU-Bits
1492 returned by a JX320 and JX325 for the mode sense command:
1493 Are these bits set to zero or not? To be on the safe side, let's
1494 clear them.
1495 */
1496
1497 if ( strncmp(inquiry_data + 16, "JX320", 5) == 0
1498 || strncmp(inquiry_data + 16, "JX325", 5) == 0)
1499 {
1500 m_subdev.f_mode_type = 0;
1501 m_subdev.a_mode_type = 0;
1502 }
1503
1504 get_max_scan_size(fd, dev, SCAN_SIMPLE);
1505
1506 if (m_subdev.a_mode_type & 0x03)
1507 {
1508 dev->info.adf_fsu_installed = HAVE_ADF;
1509 get_max_scan_size(fd, dev, SCAN_WITH_ADF);
1510 }
1511 if (m_subdev.f_mode_type & 0x07)
1512 {
1513 dev->info.adf_fsu_installed |= HAVE_FSU;
1514 get_max_scan_size(fd, dev, SCAN_WITH_FSU);
1515 }
1516
1517 if ( dev->sensedat.model == JX320
1518 || dev->sensedat.model == JX330
1519 || dev->sensedat.model == JX350)
1520 {
1521 dev->info.xres_range.max = 600;
1522 dev->info.xres_range.min = 30;
1523
1524 dev->info.yres_range.max = 600;
1525 dev->info.yres_range.min = 30;
1526 dev->info.x_default = SANE_FIX(210);
1527 dev->info.y_default = SANE_FIX(297);
1528 }
1529 else if (dev->sensedat.model == JX250)
1530 {
1531 dev->info.xres_range.max = 400;
1532 dev->info.xres_range.min = 30;
1533
1534 dev->info.yres_range.max = 400;
1535 dev->info.yres_range.min = 30;
1536 dev->info.x_default = SANE_FIX(210);
1537 dev->info.y_default = SANE_FIX(297);
1538 }
1539 }
1540 sanei_scsi_close (fd);
1541
1542 dev->info.threshold_range.min = 1;
1543 dev->info.threshold_range.max = 255;
1544 dev->info.threshold_range.quant = 0;
1545
1546 DBG (5, "xres_default=%d\n", dev->info.xres_default);
1547 DBG (5, "xres_range.max=%d\n", dev->info.xres_range.max);
1548 DBG (5, "xres_range.min=%d\n", dev->info.xres_range.min);
1549 DBG (5, "xres_range.quant=%d\n", dev->info.xres_range.quant);
1550 DBG (5, "yres_default=%d\n", dev->info.yres_default);
1551 DBG (5, "yres_range.max=%d\n", dev->info.yres_range.max);
1552 DBG (5, "yres_range.min=%d\n", dev->info.yres_range.min);
1553 DBG (5, "xres_range.quant=%d\n", dev->info.xres_range.quant);
1554
1555 DBG (5, "x_default=%f\n", SANE_UNFIX(dev->info.x_default));
1556 DBG (5, "tl_x_range[0].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_SIMPLE].max));
1557 DBG (5, "tl_x_range[0].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_SIMPLE].min));
1558 DBG (5, "tl_x_range[0].quant=%d\n", dev->info.tl_x_ranges[SCAN_SIMPLE].quant);
1559 DBG (5, "br_x_range[0].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_SIMPLE].max));
1560 DBG (5, "br_x_range[0].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_SIMPLE].min));
1561 DBG (5, "br_x_range[0].quant=%d\n", dev->info.br_x_ranges[SCAN_SIMPLE].quant);
1562 DBG (5, "y_default=%f\n", SANE_UNFIX(dev->info.y_default));
1563 DBG (5, "tl_y_range[0].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_SIMPLE].max));
1564 DBG (5, "tl_y_range[0].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_SIMPLE].min));
1565 DBG (5, "tl_y_range[0].quant=%d\n", dev->info.tl_y_ranges[SCAN_SIMPLE].quant);
1566 DBG (5, "br_y_range[0].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_SIMPLE].max));
1567 DBG (5, "br_y_range[0].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_SIMPLE].min));
1568 DBG (5, "br_y_range[0].quant=%d\n", dev->info.br_y_ranges[SCAN_SIMPLE].quant);
1569
1570 if (dev->info.adf_fsu_installed & HAVE_FSU)
1571 {
1572 DBG (5, "tl_x_range[1].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_FSU].max));
1573 DBG (5, "tl_x_range[1].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_FSU].min));
1574 DBG (5, "tl_x_range[1].quant=%d\n", dev->info.tl_x_ranges[SCAN_WITH_FSU].quant);
1575 DBG (5, "br_x_range[1].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_FSU].max));
1576 DBG (5, "br_x_range[1].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_FSU].min));
1577 DBG (5, "br_x_range[1].quant=%d\n", dev->info.br_x_ranges[SCAN_WITH_FSU].quant);
1578 DBG (5, "tl_y_range[1].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_FSU].max));
1579 DBG (5, "tl_y_range[1].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_FSU].min));
1580 DBG (5, "tl_y_range[1].quant=%d\n", dev->info.tl_y_ranges[SCAN_WITH_FSU].quant);
1581 DBG (5, "br_y_range[1].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_FSU].max));
1582 DBG (5, "br_y_range[1].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_FSU].min));
1583 DBG (5, "br_y_range[1].quant=%d\n", dev->info.br_y_ranges[SCAN_WITH_FSU].quant);
1584 }
1585
1586 if (dev->info.adf_fsu_installed & HAVE_ADF)
1587 {
1588 DBG (5, "tl_x_range[2].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_ADF].max));
1589 DBG (5, "tl_x_range[2].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_ADF].min));
1590 DBG (5, "tl_x_range[2].quant=%d\n", dev->info.tl_x_ranges[SCAN_WITH_ADF].quant);
1591 DBG (5, "br_x_range[2].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_ADF].max));
1592 DBG (5, "br_x_range[2].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_ADF].min));
1593 DBG (5, "br_x_range[2].quant=%d\n", dev->info.br_x_ranges[SCAN_WITH_ADF].quant);
1594 DBG (5, "tl_y_range[2].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_ADF].max));
1595 DBG (5, "tl_y_range[2].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_ADF].min));
1596 DBG (5, "tl_y_range[2].quant=%d\n", dev->info.tl_y_ranges[SCAN_WITH_ADF].quant);
1597 DBG (5, "br_y_range[2].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_ADF].max));
1598 DBG (5, "br_y_range[2].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_ADF].min));
1599 DBG (5, "br_y_range[2].quant=%d\n", dev->info.br_y_ranges[SCAN_WITH_ADF].quant);
1600 }
1601
1602 DBG (5, "bmu=%d\n", dev->info.bmu);
1603 DBG (5, "mud=%d\n", dev->info.mud);
1604
1605 ++num_devices;
1606 dev->next = first_dev;
1607 first_dev = dev;
1608
1609 if (devp)
1610 *devp = dev;
1611
1612 DBG (10, ">>\n");
1613 return (SANE_STATUS_GOOD);
1614 }
1615
1616 /* Enabling / disabling of gamma options.
1617 Depends on many user settable options, so lets put it into
1618 one function to be called by init_options and by sane_control_option
1619
1620 */
1621 #ifdef USE_CUSTOM_GAMMA
1622 static void
set_gamma_caps(SHARP_Scanner * s)1623 set_gamma_caps(SHARP_Scanner *s)
1624 {
1625 /* neither fixed nor custom gamma for line art modes */
1626 if ( strcmp(s->val[OPT_MODE].s, M_LINEART) == 0
1627 || strcmp(s->val[OPT_MODE].s, M_LINEART_COLOR) == 0)
1628 {
1629 s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
1630 s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
1631 s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
1632 s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1633 s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1634 s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1635 }
1636 else if (strcmp(s->val[OPT_MODE].s, M_GRAY) == 0)
1637 {
1638 s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1639 if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
1640 {
1641 s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1642 s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
1643 }
1644 else
1645 {
1646 s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
1647 s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
1648 }
1649 s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1650 s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1651 s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1652 }
1653 else
1654 {
1655 /* color mode */
1656 s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1657 if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
1658 {
1659 s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1660 s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
1661 s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1662 s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1663 s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1664 }
1665 else
1666 {
1667 s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
1668 s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
1669 s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1670 s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1671 s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1672 }
1673 }
1674 }
1675 #endif /* USE_CUSTOM_GAMMA */
1676
1677 /* The next function is a slightly modified version of sanei_constrain_value
1678 Instead of returning status information like STATUS_INVAL, it adjusts
1679 an invalid value to the nearest allowed one.
1680 */
1681 static void
clip_value(const SANE_Option_Descriptor * opt,void * value)1682 clip_value (const SANE_Option_Descriptor * opt, void * value)
1683 {
1684 const SANE_String_Const * string_list;
1685 const SANE_Word * word_list;
1686 int i, num_matches, match;
1687 const SANE_Range * range;
1688 SANE_Word w, v;
1689 size_t len;
1690
1691 switch (opt->constraint_type)
1692 {
1693 case SANE_CONSTRAINT_RANGE:
1694 w = *(SANE_Word *) value;
1695 range = opt->constraint.range;
1696
1697 if (w < range->min)
1698 w = range->min;
1699 else if (w > range->max)
1700 w = range->max;
1701
1702 if (range->quant)
1703 {
1704 v = (w - range->min + range->quant/2) / range->quant;
1705 w = v * range->quant + range->min;
1706 *(SANE_Word*) value = w;
1707 }
1708 break;
1709
1710 case SANE_CONSTRAINT_WORD_LIST:
1711 w = *(SANE_Word *) value;
1712 word_list = opt->constraint.word_list;
1713 for (i = 1; w != word_list[i]; ++i)
1714 if (i >= word_list[0])
1715 /* somewhat arbitrary... Would be better to have a default value
1716 explicitly defined.
1717 */
1718 *(SANE_Word*) value = word_list[1];
1719 break;
1720
1721 case SANE_CONSTRAINT_STRING_LIST:
1722 /* Matching algorithm: take the longest unique match ignoring
1723 case. If there is an exact match, it is admissible even if
1724 the same string is a prefix of a longer option name. */
1725 string_list = opt->constraint.string_list;
1726 len = strlen (value);
1727
1728 /* count how many matches of length LEN characters we have: */
1729 num_matches = 0;
1730 match = -1;
1731 for (i = 0; string_list[i]; ++i)
1732 if (strncasecmp (value, string_list[i], len) == 0
1733 && len <= strlen (string_list[i]))
1734 {
1735 match = i;
1736 if (len == strlen (string_list[i]))
1737 {
1738 /* exact match... */
1739 if (strcmp (value, string_list[i]) != 0)
1740 /* ...but case differs */
1741 strcpy (value, string_list[match]);
1742 }
1743 ++num_matches;
1744 }
1745
1746 if (num_matches > 1)
1747 /* xxx quite arbitrary... We could also choose the first match
1748 */
1749 strcpy(value, string_list[match]);
1750 else if (num_matches == 1)
1751 strcpy (value, string_list[match]);
1752 else
1753 strcpy (value, string_list[0]);
1754
1755 default:
1756 break;
1757 }
1758 }
1759
1760 /* make sure that enough memory is allocated for each string,
1761 so that the strcpy in sane_control_option / set value cannot
1762 write behind the end of the allocated memory.
1763 */
1764 static SANE_Status
init_string_option(SHARP_Scanner * s,SANE_String_Const name,SANE_String_Const title,SANE_String_Const desc,const SANE_String_Const * string_list,int option,int default_index)1765 init_string_option(SHARP_Scanner *s, SANE_String_Const name,
1766 SANE_String_Const title, SANE_String_Const desc,
1767 const SANE_String_Const *string_list, int option, int default_index)
1768 {
1769 int i;
1770
1771 s->opt[option].name = name;
1772 s->opt[option].title = title;
1773 s->opt[option].desc = desc;
1774 s->opt[option].type = SANE_TYPE_STRING;
1775 s->opt[option].size = max_string_size (string_list);
1776 s->opt[option].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1777 s->opt[option].constraint.string_list = string_list;
1778 s->val[option].s = malloc(s->opt[option].size);
1779 if (s->val[option].s == 0)
1780 {
1781 for (i = 1; i < NUM_OPTIONS; i++)
1782 {
1783 if (s->val[i].s && s->opt[i].type == SANE_TYPE_STRING)
1784 free(s->val[i].s);
1785 }
1786 return SANE_STATUS_NO_MEM;
1787 }
1788 strcpy(s->val[option].s, string_list[default_index]);
1789 return SANE_STATUS_GOOD;
1790 }
1791
1792 static SANE_Status
init_options(SHARP_Scanner * s)1793 init_options (SHARP_Scanner * s)
1794 {
1795 int i, default_source, sourcename_index = 0;
1796 SANE_Word scalar;
1797 DBG (10, "<< init_options ");
1798
1799 memset (s->opt, 0, sizeof (s->opt));
1800 memset (s->val, 0, sizeof (s->val));
1801
1802 for (i = 0; i < NUM_OPTIONS; ++i)
1803 {
1804 s->opt[i].size = sizeof (SANE_Word);
1805 s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
1806 s->val[i].s = 0;
1807 }
1808
1809 s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
1810 s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
1811 s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
1812 s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
1813 s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
1814
1815 /* Mode group: */
1816 s->opt[OPT_MODE_GROUP].title = "Scan Mode";
1817 s->opt[OPT_MODE_GROUP].desc = "";
1818 s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
1819 s->opt[OPT_MODE_GROUP].cap = 0;
1820 s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1821
1822 /* scan mode */
1823 #if 0
1824 s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
1825 s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
1826 s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
1827 s->opt[OPT_MODE].type = SANE_TYPE_STRING;
1828 s->opt[OPT_MODE].size = max_string_size (mode_list);
1829 s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1830 s->opt[OPT_MODE].constraint.string_list = mode_list;
1831 s->val[OPT_MODE].s = strdup (mode_list[3]); /* color scan */
1832 #endif
1833 init_string_option(s, SANE_NAME_SCAN_MODE, SANE_TITLE_SCAN_MODE,
1834 SANE_DESC_SCAN_MODE, mode_list, OPT_MODE, 3);
1835
1836 /* half tone */
1837 #if 0
1838 s->opt[OPT_HALFTONE].name = SANE_NAME_HALFTONE_PATTERN;
1839 s->opt[OPT_HALFTONE].title = SANE_TITLE_HALFTONE_PATTERN;
1840 s->opt[OPT_HALFTONE].desc = SANE_DESC_HALFTONE " (JX-330 only)";
1841 s->opt[OPT_HALFTONE].type = SANE_TYPE_STRING;
1842 s->opt[OPT_HALFTONE].size = max_string_size (halftone_list);
1843 s->opt[OPT_HALFTONE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1844 s->opt[OPT_HALFTONE].constraint.string_list = halftone_list;
1845 s->val[OPT_HALFTONE].s = strdup (halftone_list[0]);
1846 #endif
1847 init_string_option(s, SANE_NAME_HALFTONE_PATTERN, SANE_TITLE_HALFTONE_PATTERN,
1848 SANE_DESC_HALFTONE " (JX-330 only)", halftone_list, OPT_HALFTONE, 0);
1849
1850 if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350 ||
1851 s->dev->sensedat.model == JX610 || s->dev->sensedat.model == JX320)
1852 s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
1853
1854 i = 0;
1855 default_source = s->dev->info.default_scan_mode;
1856
1857 #ifdef ALLOW_AUTO_SELECT_ADF
1858 /* The JX330, but nut not the JX250 supports auto selection of ADF/FSU: */
1859 if (s->dev->info.adf_fsu_installed && (s->dev->sensedat.model == JX330))
1860 s->dev->info->scansources[i++] = use_auto;
1861 #endif
1862 if (s->dev->info.adf_fsu_installed & HAVE_ADF)
1863 {
1864 if (default_source == -1)
1865 default_source = SCAN_WITH_ADF;
1866 if (default_source == SCAN_WITH_ADF)
1867 sourcename_index = i;
1868 s->dev->info.scansources[i++] = use_adf;
1869 }
1870 else
1871 {
1872 if (default_source == SCAN_WITH_ADF)
1873 default_source = SCAN_SIMPLE;
1874 }
1875 if (s->dev->info.adf_fsu_installed & HAVE_FSU)
1876 {
1877 if (default_source == -1)
1878 default_source = SCAN_WITH_FSU;
1879 if (default_source == SCAN_WITH_FSU)
1880 sourcename_index = i;
1881 s->dev->info.scansources[i++] = use_fsu;
1882 }
1883 else
1884 {
1885 if (default_source == SCAN_WITH_FSU)
1886 default_source = SCAN_SIMPLE;
1887 }
1888 if (default_source < 0)
1889 default_source = SCAN_SIMPLE;
1890 if (default_source == SCAN_SIMPLE)
1891 sourcename_index = i;
1892 s->dev->info.scansources[i++] = use_simple;
1893 s->dev->info.scansources[i] = 0;
1894
1895 #if 0
1896 s->opt[OPT_SCANSOURCE].name = SANE_NAME_SCAN_SOURCE;
1897 s->opt[OPT_SCANSOURCE].title = SANE_TITLE_SCAN_SOURCE;
1898 s->opt[OPT_SCANSOURCE].desc = SANE_DESC_SCAN_SOURCE;
1899 s->opt[OPT_SCANSOURCE].type = SANE_TYPE_STRING;
1900 s->opt[OPT_SCANSOURCE].size = max_string_size (s->dev->info.scansources);
1901 s->opt[OPT_SCANSOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1902 s->opt[OPT_SCANSOURCE].constraint.string_list = (SANE_String_Const*)s->dev->info.scansources;
1903 s->val[OPT_SCANSOURCE].s = strdup (s->dev->info.scansources[0]);
1904 #endif
1905
1906 init_string_option(s, SANE_NAME_SCAN_SOURCE, SANE_TITLE_SCAN_SOURCE,
1907 SANE_DESC_SCAN_SOURCE, (SANE_String_Const*)s->dev->info.scansources,
1908 OPT_SCANSOURCE, sourcename_index);
1909
1910 if (i < 2)
1911 s->opt[OPT_SCANSOURCE].cap |= SANE_CAP_INACTIVE;
1912
1913 #if 0
1914 s->opt[OPT_PAPER].name = "Paper size";
1915 s->opt[OPT_PAPER].title = "Paper size";
1916 s->opt[OPT_PAPER].desc = "Paper size";
1917 s->opt[OPT_PAPER].type = SANE_TYPE_STRING;
1918 /* xxx the possible values for the paper size should be changeable,
1919 to reflect the different maximum scan sizes with/without ADF and FSU
1920 */
1921 if (s->dev->sensedat.model == JX610)
1922 {
1923 s->opt[OPT_PAPER].size = max_string_size (paper_list_jx610);
1924 s->opt[OPT_PAPER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1925 s->opt[OPT_PAPER].constraint.string_list = paper_list_jx610;
1926 s->val[OPT_PAPER].s = strdup (paper_list_jx610[1]);
1927 }
1928 else
1929 {
1930 s->opt[OPT_PAPER].size = max_string_size (paper_list_jx330);
1931 s->opt[OPT_PAPER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1932 s->opt[OPT_PAPER].constraint.string_list = paper_list_jx330;
1933 s->val[OPT_PAPER].s = strdup (paper_list_jx330[0]);
1934 }
1935 #endif
1936
1937 if (s->dev->sensedat.model == JX610)
1938 init_string_option(s, "Paper size", "Paper size",
1939 "Paper size", paper_list_jx610, OPT_PAPER, 1);
1940 else
1941 init_string_option(s, "Paper size", "Paper size",
1942 "Paper size", paper_list_jx330, OPT_PAPER, 0);
1943
1944 /* gamma */
1945 #if 0
1946 s->opt[OPT_GAMMA].name = "Gamma";
1947 s->opt[OPT_GAMMA].title = "Gamma";
1948 s->opt[OPT_GAMMA].desc = "Gamma";
1949 s->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
1950 s->opt[OPT_GAMMA].size = max_string_size (gamma_list);
1951 s->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1952 s->opt[OPT_GAMMA].constraint.string_list = gamma_list;
1953 s->val[OPT_GAMMA].s = strdup (gamma_list[1]);
1954 #endif
1955
1956 init_string_option(s, "Gamma", "Gamma", "Gamma", gamma_list, OPT_GAMMA, 1);
1957
1958 /* scan speed */
1959 s->opt[OPT_SPEED].name = SANE_NAME_SCAN_SPEED;
1960 s->opt[OPT_SPEED].title = "Scan speed [fast]";
1961 s->opt[OPT_SPEED].desc = SANE_DESC_SCAN_SPEED;
1962 s->opt[OPT_SPEED].type = SANE_TYPE_BOOL;
1963 s->val[OPT_SPEED].w = SANE_TRUE;
1964
1965 /* Resolution Group */
1966 s->opt[OPT_RESOLUTION_GROUP].title = "Resolution";
1967 s->opt[OPT_RESOLUTION_GROUP].desc = "";
1968 s->opt[OPT_RESOLUTION_GROUP].type = SANE_TYPE_GROUP;
1969 s->opt[OPT_RESOLUTION_GROUP].cap = 0;
1970 s->opt[OPT_RESOLUTION_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1971
1972 /* select resolution */
1973 #ifdef USE_RESOLUTION_LIST
1974 if (s->dev->sensedat.model == JX610 || s->dev->sensedat.model == JX330 ||
1975 s->dev->sensedat.model == JX350 || s->dev->sensedat.model == JX320)
1976 init_string_option(s, "ResolutionList", "ResolutionList", "ResolutionList",
1977 resolution_list_jx610, OPT_RESOLUTION_LIST, RESOLUTION_MAX_JX610);
1978 else
1979 init_string_option(s, "ResolutionList", "ResolutionList", "ResolutionList",
1980 resolution_list_jx250, OPT_RESOLUTION_LIST, RESOLUTION_MAX_JX250);
1981 #endif
1982 /* x resolution */
1983 s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
1984 s->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
1985 s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
1986 s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
1987 s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
1988 s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
1989 s->opt[OPT_X_RESOLUTION].constraint.range = &s->dev->info.xres_range;
1990 s->val[OPT_X_RESOLUTION].w = s->dev->info.xres_default;
1991
1992 #ifdef USE_SEPARATE_Y_RESOLUTION
1993 /* y resolution */
1994 s->opt[OPT_Y_RESOLUTION].name = "Y" SANE_NAME_SCAN_RESOLUTION;
1995 s->opt[OPT_Y_RESOLUTION].title = "Y " SANE_TITLE_SCAN_RESOLUTION;
1996 s->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
1997 s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
1998 s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
1999 s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
2000 s->opt[OPT_Y_RESOLUTION].constraint.range = &s->dev->info.yres_range;
2001 s->val[OPT_Y_RESOLUTION].w = s->dev->info.yres_default;
2002 #endif
2003
2004 /* "Geometry" group: */
2005 s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
2006 s->opt[OPT_GEOMETRY_GROUP].desc = "";
2007 s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
2008 s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
2009 s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
2010
2011 /* top-left x */
2012 s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
2013 s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
2014 s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
2015 s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
2016 s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
2017 s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
2018 s->opt[OPT_TL_X].constraint.range = &s->dev->info.tl_x_ranges[default_source];
2019 s->val[OPT_TL_X].w = s->dev->info.tl_x_ranges[default_source].min;
2020
2021 /* top-left y */
2022 s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
2023 s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
2024 s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
2025 s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
2026 s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
2027 s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
2028 s->opt[OPT_TL_Y].constraint.range = &s->dev->info.tl_y_ranges[default_source];
2029 s->val[OPT_TL_Y].w = s->dev->info.tl_y_ranges[default_source].min;
2030
2031 /* bottom-right x */
2032 s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
2033 s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
2034 s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
2035 s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
2036 s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
2037 s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
2038 s->opt[OPT_BR_X].constraint.range = &s->dev->info.br_x_ranges[default_source];
2039 scalar = s->dev->info.x_default;
2040 clip_value (&s->opt[OPT_BR_X], &scalar);
2041 s->val[OPT_BR_X].w = scalar;
2042
2043 /* bottom-right y */
2044 s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
2045 s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
2046 s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
2047 s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
2048 s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
2049 s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
2050 s->opt[OPT_BR_Y].constraint.range = &s->dev->info.br_y_ranges[default_source];
2051 /* The FSU for JX250 allows a maximum scan length of 11.5 inch,
2052 which is less than the default value of 297 mm
2053 */
2054 scalar = s->dev->info.y_default;
2055 clip_value (&s->opt[OPT_BR_X], &scalar);
2056 s->val[OPT_BR_Y].w = scalar;
2057
2058 /* "Enhancement" group: */
2059 s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
2060 s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
2061 s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
2062 s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
2063 s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
2064
2065 /* edge emphasis */
2066 #if 0
2067 s->opt[OPT_EDGE_EMPHASIS].name = "Edge emphasis";
2068 s->opt[OPT_EDGE_EMPHASIS].title = "Edge emphasis";
2069 s->opt[OPT_EDGE_EMPHASIS].desc = "Edge emphasis";
2070 s->opt[OPT_EDGE_EMPHASIS].type = SANE_TYPE_STRING;
2071 s->opt[OPT_EDGE_EMPHASIS].size = max_string_size (edge_emphasis_list);
2072 s->opt[OPT_EDGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST;
2073 s->opt[OPT_EDGE_EMPHASIS].constraint.string_list = edge_emphasis_list;
2074 s->val[OPT_EDGE_EMPHASIS].s = strdup (edge_emphasis_list[0]);
2075 #endif
2076 init_string_option(s, "Edge emphasis", "Edge emphasis",
2077 "Edge emphasis", edge_emphasis_list,
2078 OPT_EDGE_EMPHASIS, 0);
2079
2080 if ( s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350
2081 || s->dev->sensedat.model == JX320)
2082 s->opt[OPT_EDGE_EMPHASIS].cap |= SANE_CAP_INACTIVE;
2083
2084 /* threshold */
2085 s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
2086 s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
2087 s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
2088 s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
2089 s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
2090 s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
2091 s->opt[OPT_THRESHOLD].constraint.range = &s->dev->info.threshold_range;
2092 s->val[OPT_THRESHOLD].w = 128;
2093 s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
2094
2095 #ifdef USE_COLOR_THRESHOLD
2096 s->opt[OPT_THRESHOLD_R].name = SANE_NAME_THRESHOLD "-red";
2097 /* xxx the titles and descriptions are confusing:
2098 "set white point (red)"
2099 Any idea? maybe "threshold to get the red component on"
2100 */
2101 s->opt[OPT_THRESHOLD_R].title = SANE_TITLE_THRESHOLD " (red)";
2102 s->opt[OPT_THRESHOLD_R].desc = SANE_DESC_THRESHOLD " (red)";
2103 s->opt[OPT_THRESHOLD_R].type = SANE_TYPE_INT;
2104 s->opt[OPT_THRESHOLD_R].unit = SANE_UNIT_NONE;
2105 s->opt[OPT_THRESHOLD_R].constraint_type = SANE_CONSTRAINT_RANGE;
2106 s->opt[OPT_THRESHOLD_R].constraint.range = &s->dev->info.threshold_range;
2107 s->val[OPT_THRESHOLD_R].w = 128;
2108 s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
2109
2110 s->opt[OPT_THRESHOLD_G].name = SANE_NAME_THRESHOLD "-green";
2111 s->opt[OPT_THRESHOLD_G].title = SANE_TITLE_THRESHOLD " (green)";
2112 s->opt[OPT_THRESHOLD_G].desc = SANE_DESC_THRESHOLD " (green)";
2113 s->opt[OPT_THRESHOLD_G].type = SANE_TYPE_INT;
2114 s->opt[OPT_THRESHOLD_G].unit = SANE_UNIT_NONE;
2115 s->opt[OPT_THRESHOLD_G].constraint_type = SANE_CONSTRAINT_RANGE;
2116 s->opt[OPT_THRESHOLD_G].constraint.range = &s->dev->info.threshold_range;
2117 s->val[OPT_THRESHOLD_G].w = 128;
2118 s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
2119
2120 s->opt[OPT_THRESHOLD_B].name = SANE_NAME_THRESHOLD "-blue";
2121 s->opt[OPT_THRESHOLD_B].title = SANE_TITLE_THRESHOLD " (blue)";
2122 s->opt[OPT_THRESHOLD_B].desc = SANE_DESC_THRESHOLD " (blue)";
2123 s->opt[OPT_THRESHOLD_B].type = SANE_TYPE_INT;
2124 s->opt[OPT_THRESHOLD_B].unit = SANE_UNIT_NONE;
2125 s->opt[OPT_THRESHOLD_B].constraint_type = SANE_CONSTRAINT_RANGE;
2126 s->opt[OPT_THRESHOLD_B].constraint.range = &s->dev->info.threshold_range;
2127 s->val[OPT_THRESHOLD_B].w = 128;
2128 s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
2129
2130 #endif
2131
2132 /* light color (for gray scale and line art scans) */
2133 #if 0
2134 s->opt[OPT_LIGHTCOLOR].name = "LightColor";
2135 s->opt[OPT_LIGHTCOLOR].title = "Light Color";
2136 s->opt[OPT_LIGHTCOLOR].desc = "Light Color";
2137 s->opt[OPT_LIGHTCOLOR].type = SANE_TYPE_STRING;
2138 s->opt[OPT_LIGHTCOLOR].size = max_string_size (light_color_list);
2139 s->opt[OPT_LIGHTCOLOR].constraint_type = SANE_CONSTRAINT_STRING_LIST;
2140 s->opt[OPT_LIGHTCOLOR].constraint.string_list = light_color_list;
2141 s->val[OPT_LIGHTCOLOR].s = strdup (light_color_list[3]);
2142 s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
2143 #endif
2144 init_string_option(s, "LightColor", "LightColor", "LightColor",
2145 light_color_list, OPT_LIGHTCOLOR, 3);
2146 s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
2147
2148 s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
2149 s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
2150 s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
2151 s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
2152 s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
2153 s->val[OPT_PREVIEW].w = SANE_FALSE;
2154
2155
2156 #ifdef USE_CUSTOM_GAMMA
2157 /* custom-gamma table */
2158 s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
2159 s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
2160 s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
2161 s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
2162 s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
2163
2164 /* grayscale gamma vector */
2165 s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
2166 s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
2167 s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
2168 s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
2169 #if 0
2170 s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
2171 #endif
2172 s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
2173 s->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
2174 s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
2175 s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
2176 s->val[OPT_GAMMA_VECTOR].wa = &s->gamma_table[0][0];
2177
2178 /* red gamma vector */
2179 s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
2180 s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
2181 s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
2182 s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
2183 #if 0
2184 s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
2185 #endif
2186 s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
2187 s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
2188 s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
2189 s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
2190 s->val[OPT_GAMMA_VECTOR_R].wa = &s->gamma_table[1][0];
2191
2192 /* green gamma vector */
2193 s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
2194 s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
2195 s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
2196 s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
2197 #if 0
2198 s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
2199 #endif
2200 s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
2201 s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
2202 s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
2203 s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
2204 s->val[OPT_GAMMA_VECTOR_G].wa = &s->gamma_table[2][0];
2205
2206 /* blue gamma vector */
2207 s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
2208 s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
2209 s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
2210 s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
2211 #if 0
2212 s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
2213 #endif
2214 s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
2215 s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
2216 s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
2217 s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
2218 s->val[OPT_GAMMA_VECTOR_B].wa = &s->gamma_table[3][0];
2219 set_gamma_caps(s);
2220 #endif
2221
2222 DBG (10, ">>\n");
2223 return SANE_STATUS_GOOD;
2224 }
2225
2226 static SANE_Status
do_cancel(SHARP_Scanner * s)2227 do_cancel (SHARP_Scanner * s)
2228 {
2229 static u_char cmd[] = {READ, 0, 0, 0, 0, 2, 0, 0, 0, 0};
2230
2231 DBG (10, "<< do_cancel ");
2232
2233 #ifdef USE_FORK
2234 if (s->reader_pid > 0)
2235 {
2236 int exit_status;
2237 int count = 0;
2238 /* ensure child knows it's time to stop: */
2239
2240 DBG(11, "stopping reader process\n");
2241 s->rdr_ctl->cancel = 1;
2242 while(reader_running(s) && count < 100)
2243 {
2244 usleep(100000);
2245 count++;
2246 };
2247 if (reader_running(s))
2248 {
2249 /* be brutal...
2250 !! The waiting time of 10 seconds might be far too short
2251 !! if the resolution limit of the JX 250 is increased to
2252 !! to more than 400 dpi: for these (interpolated) resolutions,
2253 !! the JX 250 is awfully slow.
2254 */
2255 kill(s->reader_pid, SIGKILL);
2256 }
2257 wait(&exit_status);
2258 DBG(11, "reader process stopped\n");
2259
2260 s->reader_pid = 0;
2261 }
2262
2263 #endif
2264 if (s->scanning == SANE_TRUE)
2265 {
2266 wait_ready(s->fd);
2267 sanei_scsi_cmd (s->fd, cmd, sizeof (cmd), 0, 0);
2268 /* if (s->adf_scan) */
2269 if ( s->dev->sensedat.model != JX610
2270 && s->dev->sensedat.model != JX320)
2271 object_position(s->fd, UNLOAD_PAPER);
2272 }
2273
2274 s->scanning = SANE_FALSE;
2275
2276 if (s->fd >= 0)
2277 {
2278 sanei_scsi_close (s->fd);
2279 s->fd = -1;
2280 }
2281 #ifdef USE_FORK
2282 {
2283 struct shmid_ds ds;
2284 if (s->shmid != -1)
2285 shmctl(s->shmid, IPC_RMID, &ds);
2286 s->shmid = -1;
2287 }
2288 #endif
2289 if (s->buffer)
2290 free(s->buffer);
2291 s->buffer = 0;
2292
2293 DBG (10, ">>\n");
2294 return (SANE_STATUS_CANCELLED);
2295 }
2296
2297 static SHARP_New_Device *new_devs = 0;
2298 static SHARP_New_Device *new_dev_pool = 0;
2299
2300 static SANE_Status
attach_and_list(const char * devnam)2301 attach_and_list(const char *devnam)
2302 {
2303 SANE_Status res;
2304 SHARP_Device *devp;
2305 SHARP_New_Device *np;
2306
2307 res = attach(devnam, &devp);
2308 if (res == SANE_STATUS_GOOD)
2309 {
2310 if (new_dev_pool)
2311 {
2312 np = new_dev_pool;
2313 new_dev_pool = np->next;
2314 }
2315 else
2316 {
2317 np = malloc(sizeof(SHARP_New_Device));
2318 if (np == 0)
2319 return SANE_STATUS_NO_MEM;
2320 }
2321 np->next =new_devs;
2322 np->dev = devp;
2323 new_devs = np;
2324 }
2325 return res;
2326 }
2327
2328 static int buffers[2] = {DEFAULT_BUFFERS, DEFAULT_BUFFERS};
2329 static int bufsize[2] = {DEFAULT_BUFSIZE, DEFAULT_BUFSIZE};
2330 static int queued_reads[2] = {DEFAULT_QUEUED_READS, DEFAULT_QUEUED_READS};
2331 static int stop_on_fsu_error[2] = {COMPLAIN_ON_FSU_ERROR | COMPLAIN_ON_ADF_ERROR,
2332 COMPLAIN_ON_FSU_ERROR | COMPLAIN_ON_ADF_ERROR};
2333 static int default_scan_mode[2] = {-1, -1};
2334
2335 SANE_Status
sane_init(SANE_Int * version_code,SANE_Auth_Callback __sane_unused__ authorize)2336 sane_init (SANE_Int * version_code,
2337 SANE_Auth_Callback __sane_unused__ authorize)
2338 {
2339 char devnam[PATH_MAX] = "/dev/scanner";
2340 char line[PATH_MAX];
2341 const char *lp;
2342 char *word;
2343 char *end;
2344 FILE *fp;
2345 int opt_index = 0;
2346 int linecount = 0;
2347 #if 1
2348 SHARP_Device sd;
2349 SHARP_Device *dp = &sd;
2350 #else
2351 SHARP_Device *dp;
2352 #endif
2353 SHARP_New_Device *np;
2354 int i;
2355
2356 DBG_INIT ();
2357 DBG (10, "<< sane_init ");
2358
2359 #if defined PACKAGE && defined VERSION
2360 DBG (2, "sane_init: " PACKAGE " " VERSION "\n");
2361 #endif
2362
2363 if (version_code)
2364 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
2365
2366 fp = sanei_config_open (SHARP_CONFIG_FILE);
2367 if (!fp)
2368 {
2369 /* use "/dev/scanner" as the default device name if no
2370 config file is available
2371 */
2372 attach (devnam, &dp);
2373 /* make sure that there are at least two buffers */
2374 if (DEFAULT_BUFFERS < 2)
2375 dp->info.buffers = DEFAULT_BUFFERS;
2376 else
2377 dp->info.buffers = 2;
2378 dp->info.wanted_bufsize = DEFAULT_BUFSIZE;
2379 dp->info.queued_reads = DEFAULT_QUEUED_READS;
2380 dp->info.complain_on_errors = COMPLAIN_ON_ADF_ERROR | COMPLAIN_ON_FSU_ERROR;
2381 dp->info.default_scan_mode = -1;
2382 return SANE_STATUS_GOOD;
2383 }
2384
2385 while (fgets(line, PATH_MAX, fp))
2386 {
2387 linecount++;
2388 word = 0;
2389 lp = sanei_config_get_string(line, &word);
2390 if (word)
2391 {
2392 if (word[0] != '#')
2393 {
2394 if (strcmp(word, "option") == 0)
2395 {
2396 free(word);
2397 word = 0;
2398 lp = sanei_config_get_string(lp, &word);
2399 if (strcmp(word, "buffers") == 0)
2400 {
2401 free(word);
2402 word = 0;
2403 sanei_config_get_string(lp, &word);
2404 i = strtol(word, &end, 0);
2405 if (end == word)
2406 {
2407 DBG(1, "error in config file, line %i: number expected:\n",
2408 linecount);
2409 DBG(1, "%s\n", line);
2410 }
2411 else
2412 if (i > 2)
2413 buffers[opt_index] = i;
2414 else
2415 buffers[opt_index] = 2;
2416 }
2417 else if (strcmp(word, "buffersize") == 0)
2418 {
2419 free(word);
2420 word = 0;
2421 sanei_config_get_string(lp, &word);
2422 i = strtol(word, &end, 0);
2423 if (word == end)
2424 {
2425 DBG(1, "error in config file, line %i: number expected:\n",
2426 linecount);
2427 DBG(1, "%s\n", line);
2428 }
2429 else
2430 bufsize[opt_index] = i;
2431 }
2432 else if (strcmp(word, "readqueue") == 0)
2433 {
2434 free(word);
2435 word = 0;
2436 sanei_config_get_string(lp, &word);
2437 i = strtol(word, &end, 0);
2438 if (word == end)
2439 {
2440 DBG(1, "error in config file, line %i: number expected:\n",
2441 linecount);
2442 DBG(1, "%s\n", line);
2443 }
2444 else
2445 queued_reads[opt_index] = i;
2446 }
2447 else if (strcmp(word, "stop_on_fsu_error") == 0)
2448 {
2449 free(word);
2450 word = 0;
2451 sanei_config_get_string(lp, &word);
2452 i = strtol(word, &end, 0);
2453 if (word == end)
2454 {
2455 DBG(1, "error in config file, line %i: number expected:\n",
2456 linecount);
2457 DBG(1, "%s\n", line);
2458 }
2459 else
2460 stop_on_fsu_error[opt_index]
2461 = i ? COMPLAIN_ON_FSU_ERROR : 0;
2462 }
2463 else if (strcmp(word, "default_scan_source") == 0)
2464 {
2465 free(word);
2466 word = 0;
2467 sanei_config_get_string(lp, &word);
2468 if (strcmp(word, "auto") == 0)
2469 default_scan_mode[opt_index] = -1;
2470 else if (strcmp(word, "fsu") == 0)
2471 default_scan_mode[opt_index] = SCAN_WITH_FSU;
2472 else if (strcmp(word, "adf") == 0)
2473 default_scan_mode[opt_index] = SCAN_WITH_ADF;
2474 else if (strcmp(word, "flatbed") == 0)
2475 default_scan_mode[opt_index] = SCAN_SIMPLE;
2476 else
2477 {
2478 DBG(1, "error in config file, line %i: number expected:\n",
2479 linecount);
2480 DBG(1, "%s\n", line);
2481 }
2482 }
2483 else
2484 {
2485 DBG(1, "error in config file, line %i: unknown option\n",
2486 linecount);
2487 DBG(1, "%s\n", line);
2488 }
2489 }
2490 else
2491 {
2492 while (new_devs)
2493 {
2494 if (buffers[1] >= 2)
2495 new_devs->dev->info.buffers = buffers[1];
2496 else
2497 new_devs->dev->info.buffers = 2;
2498 if (bufsize[1] > 0)
2499 new_devs->dev->info.wanted_bufsize = bufsize[1];
2500 else
2501 new_devs->dev->info.wanted_bufsize = DEFAULT_BUFSIZE;
2502 if (queued_reads[1] >= 0)
2503 new_devs->dev->info.queued_reads = queued_reads[1];
2504 else
2505 new_devs->dev->info.queued_reads = 0;
2506 new_devs->dev->info.complain_on_errors = stop_on_fsu_error[1];
2507 new_devs->dev->info.default_scan_mode = default_scan_mode[1];
2508 np = new_devs->next;
2509 new_devs->next = new_dev_pool;
2510 new_dev_pool = new_devs;
2511 new_devs = np;
2512 }
2513 if (line[strlen(line)-1] == '\n')
2514 line[strlen(line)-1] = 0;
2515 sanei_config_attach_matching_devices(line, &attach_and_list);
2516 buffers[1] = buffers[0];
2517 bufsize[1] = bufsize[0];
2518 queued_reads[1] = queued_reads[0];
2519 stop_on_fsu_error[1] = stop_on_fsu_error[0];
2520 default_scan_mode[1] = default_scan_mode[0];
2521 opt_index = 1;
2522 }
2523 }
2524 if (word) free(word);
2525 }
2526 }
2527
2528 while (new_devs)
2529 {
2530 if (buffers[1] >= 2)
2531 new_devs->dev->info.buffers = buffers[1];
2532 else
2533 new_devs->dev->info.buffers = 2;
2534 if (bufsize[1] > 0)
2535 new_devs->dev->info.wanted_bufsize = bufsize[1];
2536 else
2537 new_devs->dev->info.wanted_bufsize = DEFAULT_BUFSIZE;
2538 if (queued_reads[1] >= 0)
2539 new_devs->dev->info.queued_reads = queued_reads[1];
2540 else
2541 new_devs->dev->info.queued_reads = 0;
2542 new_devs->dev->info.complain_on_errors = stop_on_fsu_error[1];
2543 new_devs->dev->info.default_scan_mode = default_scan_mode[1];
2544 if (line[strlen(line)-1] == '\n')
2545 line[strlen(line)-1] = 0;
2546 np = new_devs->next;
2547 free(new_devs);
2548 new_devs = np;
2549 }
2550 while (new_dev_pool)
2551 {
2552 np = new_dev_pool->next;
2553 free(new_dev_pool);
2554 new_dev_pool = np;
2555 }
2556 fclose(fp);
2557 DBG (10, "sane_init >>\n");
2558 return (SANE_STATUS_GOOD);
2559 }
2560
2561 static const SANE_Device **devlist = 0;
2562 void
sane_exit(void)2563 sane_exit (void)
2564 {
2565 SHARP_Device *dev, *next;
2566 DBG (10, "<< sane_exit ");
2567
2568 for (dev = first_dev; dev; dev = next)
2569 {
2570 next = dev->next;
2571 free ((void *) dev->sane.name);
2572 free ((void *) dev->sane.model);
2573 free (dev);
2574 }
2575
2576 if (devlist)
2577 free(devlist);
2578 devlist = 0;
2579 first_dev = 0;
2580
2581 DBG (10, ">>\n");
2582 }
2583
2584 SANE_Status
sane_get_devices(const SANE_Device *** device_list,SANE_Bool __sane_unused__ local_only)2585 sane_get_devices (const SANE_Device *** device_list,
2586 SANE_Bool __sane_unused__ local_only)
2587 {
2588 SHARP_Device *dev;
2589 int i;
2590 DBG (10, "<< sane_get_devices ");
2591
2592 if (devlist)
2593 free (devlist);
2594 devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
2595 if (!devlist)
2596 return (SANE_STATUS_NO_MEM);
2597
2598 i = 0;
2599 for (dev = first_dev; dev; dev = dev->next)
2600 devlist[i++] = &dev->sane;
2601 devlist[i++] = 0;
2602
2603 *device_list = devlist;
2604
2605 DBG (10, ">>\n");
2606 return SANE_STATUS_GOOD;
2607 }
2608
2609 SANE_Status
sane_open(SANE_String_Const devnam,SANE_Handle * handle)2610 sane_open (SANE_String_Const devnam, SANE_Handle * handle)
2611 {
2612 SANE_Status status;
2613 SHARP_Device *dev;
2614 SHARP_Scanner *s;
2615 #ifdef USE_CUSTOM_GAMMA
2616 int i, j;
2617 #endif
2618
2619 DBG (10, "<< sane_open ");
2620
2621 if (devnam[0])
2622 {
2623 for (dev = first_dev; dev; dev = dev->next)
2624 {
2625 if (strcmp (dev->sane.name, devnam) == 0)
2626 break;
2627 }
2628
2629 if (!dev)
2630 {
2631 status = attach (devnam, &dev);
2632 if (status != SANE_STATUS_GOOD)
2633 return (status);
2634 dev->info.buffers = buffers[0];
2635 dev->info.wanted_bufsize = bufsize[0];
2636 dev->info.queued_reads = queued_reads[0];
2637 }
2638 }
2639 else
2640 {
2641 dev = first_dev;
2642 }
2643
2644 if (!dev)
2645 return (SANE_STATUS_INVAL);
2646
2647 s = malloc (sizeof (*s));
2648 if (!s)
2649 return SANE_STATUS_NO_MEM;
2650 memset (s, 0, sizeof (*s));
2651
2652 s->fd = -1;
2653 s->dev = dev;
2654
2655 s->buffer = 0;
2656 #ifdef USE_CUSTOM_GAMMA
2657 for (i = 0; i < 4; ++i)
2658 for (j = 0; j < 256; ++j)
2659 s->gamma_table[i][j] = j;
2660 #endif
2661 status = init_options (s);
2662 if (status != SANE_STATUS_GOOD)
2663 {
2664 /* xxx clean up mallocs */
2665 return status;
2666 }
2667
2668 s->next = first_handle;
2669 first_handle = s;
2670
2671 *handle = s;
2672
2673 DBG (10, ">>\n");
2674 return SANE_STATUS_GOOD;
2675 }
2676
2677 void
sane_close(SANE_Handle handle)2678 sane_close (SANE_Handle handle)
2679 {
2680 SHARP_Scanner *s = (SHARP_Scanner *) handle;
2681 DBG (10, "<< sane_close ");
2682
2683 if (s->fd != -1)
2684 sanei_scsi_close (s->fd);
2685 #ifdef USE_FORK
2686 {
2687 struct shmid_ds ds;
2688 if (s->shmid != -1)
2689 shmctl(s->shmid, IPC_RMID, &ds);
2690 }
2691 #endif
2692 if (s->buffer)
2693 free(s->buffer);
2694 free (s);
2695
2696 DBG (10, ">>\n");
2697 }
2698
2699 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle handle,SANE_Int option)2700 sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
2701 {
2702 SHARP_Scanner *s = handle;
2703 DBG (10, "<< sane_get_option_descriptor ");
2704
2705 if ((unsigned) option >= NUM_OPTIONS)
2706 return (0);
2707
2708 DBG (10, ">>\n");
2709 return (s->opt + option);
2710 }
2711
2712 SANE_Status
sane_control_option(SANE_Handle handle,SANE_Int option,SANE_Action action,void * val,SANE_Int * info)2713 sane_control_option (SANE_Handle handle, SANE_Int option,
2714 SANE_Action action, void *val, SANE_Int * info)
2715 {
2716 SHARP_Scanner *s = handle;
2717 SANE_Status status;
2718 #ifdef USE_CUSTOM_GAMMA
2719 SANE_Word w, cap;
2720 #else
2721 SANE_Word cap;
2722 #endif
2723 #ifdef USE_RESOLUTION_LIST
2724 int i;
2725 #endif
2726 int range_index;
2727 DBG (10, "<< sane_control_option %i", option);
2728
2729 if (info)
2730 *info = 0;
2731
2732 if (s->scanning)
2733 return (SANE_STATUS_DEVICE_BUSY);
2734 if (option >= NUM_OPTIONS)
2735 return (SANE_STATUS_INVAL);
2736
2737 cap = s->opt[option].cap;
2738 if (!SANE_OPTION_IS_ACTIVE (cap))
2739 return (SANE_STATUS_INVAL);
2740
2741 if (action == SANE_ACTION_GET_VALUE)
2742 {
2743 switch (option)
2744 {
2745 /* word options: */
2746 case OPT_X_RESOLUTION:
2747 #ifdef USE_SEPARATE_Y_RESOLUTION
2748 case OPT_Y_RESOLUTION:
2749 #endif
2750 case OPT_TL_X:
2751 case OPT_TL_Y:
2752 case OPT_BR_X:
2753 case OPT_BR_Y:
2754 case OPT_NUM_OPTS:
2755 case OPT_THRESHOLD:
2756 #ifdef USE_COLOR_THRESHOLD
2757 case OPT_THRESHOLD_R:
2758 case OPT_THRESHOLD_G:
2759 case OPT_THRESHOLD_B:
2760 #endif
2761 case OPT_SPEED:
2762 case OPT_PREVIEW:
2763 #ifdef USE_CUSTOM_GAMMA
2764 case OPT_CUSTOM_GAMMA:
2765 #endif
2766 *(SANE_Word *) val = s->val[option].w;
2767 #if 0 /* here, values are read; reload should not be necessary */
2768 if (info)
2769 *info |= SANE_INFO_RELOAD_PARAMS;
2770 #endif
2771 return (SANE_STATUS_GOOD);
2772
2773 #ifdef USE_CUSTOM_GAMMA
2774 /* word-array options: */
2775 case OPT_GAMMA_VECTOR:
2776 case OPT_GAMMA_VECTOR_R:
2777 case OPT_GAMMA_VECTOR_G:
2778 case OPT_GAMMA_VECTOR_B:
2779 memcpy (val, s->val[option].wa, s->opt[option].size);
2780 return SANE_STATUS_GOOD;
2781 #endif
2782
2783 /* string options: */
2784 case OPT_MODE:
2785 case OPT_HALFTONE:
2786 case OPT_PAPER:
2787 case OPT_GAMMA:
2788 #ifdef USE_RESOLUTION_LIST
2789 case OPT_RESOLUTION_LIST:
2790 #endif
2791 case OPT_EDGE_EMPHASIS:
2792 case OPT_LIGHTCOLOR:
2793 case OPT_SCANSOURCE:
2794 strcpy (val, s->val[option].s);
2795 #if 0
2796 if (info)
2797 *info |= SANE_INFO_RELOAD_PARAMS;
2798 #endif
2799
2800 return (SANE_STATUS_GOOD);
2801
2802 }
2803 }
2804 else if (action == SANE_ACTION_SET_VALUE)
2805 {
2806 if (!SANE_OPTION_IS_SETTABLE (cap))
2807 return (SANE_STATUS_INVAL);
2808
2809 status = sanei_constrain_value (s->opt + option, val, info);
2810 if (status != SANE_STATUS_GOOD)
2811 return status;
2812
2813 switch (option)
2814 {
2815 /* (mostly) side-effect-free word options: */
2816 case OPT_X_RESOLUTION:
2817 #ifdef USE_SEPARATE_Y_RESOLUTION
2818 case OPT_Y_RESOLUTION:
2819 #endif
2820 case OPT_TL_X:
2821 case OPT_TL_Y:
2822 case OPT_BR_X:
2823 case OPT_BR_Y:
2824 if (info && s->val[option].w != *(SANE_Word *) val)
2825 *info |= SANE_INFO_RELOAD_PARAMS;
2826 // fall through
2827 case OPT_NUM_OPTS:
2828 case OPT_THRESHOLD:
2829 /* xxx theoretically, we could use OPT_THRESHOLD in
2830 bi-level color mode to adjust all three other
2831 threshold together. But this would require to set
2832 the bit SANE_INFO_RELOAD_OPTIONS in *info, and that
2833 would unfortunately cause a crash in both xscanimage
2834 and xsane... Therefore, OPT_THRESHOLD is disabled
2835 for bi-level color scan right now.
2836 */
2837 #ifdef USE_COLOR_THRESHOLD
2838 case OPT_THRESHOLD_R:
2839 case OPT_THRESHOLD_G:
2840 case OPT_THRESHOLD_B:
2841 #endif
2842 case OPT_SPEED:
2843 case OPT_PREVIEW:
2844 s->val[option].w = *(SANE_Word *) val;
2845 return (SANE_STATUS_GOOD);
2846
2847
2848 case OPT_MODE:
2849 if (strcmp (val, M_LINEART) == 0)
2850 {
2851 s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
2852 #ifdef USE_COLOR_THRESHOLD
2853 s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
2854 s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
2855 s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
2856 #endif
2857 if (s->dev->sensedat.model == JX330)
2858 s->opt[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE;
2859 }
2860 else if (strcmp (val, M_LINEART_COLOR) == 0)
2861 {
2862 s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
2863 #ifdef USE_COLOR_THRESHOLD
2864 s->opt[OPT_THRESHOLD_R].cap &= ~SANE_CAP_INACTIVE;
2865 s->opt[OPT_THRESHOLD_G].cap &= ~SANE_CAP_INACTIVE;
2866 s->opt[OPT_THRESHOLD_B].cap &= ~SANE_CAP_INACTIVE;
2867 #endif
2868 if (s->dev->sensedat.model == JX330)
2869 s->opt[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE;
2870 }
2871 else
2872 {
2873 s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
2874 #ifdef USE_COLOR_THRESHOLD
2875 s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
2876 s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
2877 s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
2878 #endif
2879 s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
2880 }
2881
2882 if ( strcmp (val, M_LINEART) == 0
2883 || strcmp (val, M_GRAY) == 0)
2884 {
2885 s->opt[OPT_LIGHTCOLOR].cap &= ~SANE_CAP_INACTIVE;
2886 }
2887 else
2888 {
2889 s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
2890 }
2891
2892 strcpy(s->val[option].s, val);
2893 #ifdef USE_CUSTOM_GAMMA
2894 set_gamma_caps(s);
2895 #endif
2896 if (info)
2897 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
2898 return (SANE_STATUS_GOOD);
2899
2900 case OPT_GAMMA:
2901 case OPT_HALFTONE:
2902 case OPT_EDGE_EMPHASIS:
2903 case OPT_LIGHTCOLOR:
2904 #if 0
2905 if (s->val[option].s)
2906 free (s->val[option].s);
2907 s->val[option].s = strdup (val);
2908 #endif
2909 strcpy(s->val[option].s, val);
2910 return (SANE_STATUS_GOOD);
2911
2912 case OPT_SCANSOURCE:
2913 if (info && strcmp (s->val[option].s, (SANE_String) val))
2914 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
2915 #if 0
2916 if (s->val[option].s)
2917 free (s->val[option].s);
2918 s->val[option].s = strdup (val);
2919 #endif
2920 strcpy(s->val[option].s, val);
2921 if (strcmp(val, use_fsu) == 0)
2922 range_index = SCAN_WITH_FSU;
2923 else if (strcmp(val, use_adf) == 0)
2924 range_index = SCAN_WITH_ADF;
2925 else
2926 range_index = SCAN_SIMPLE;
2927
2928 s->opt[OPT_TL_X].constraint.range
2929 = &s->dev->info.tl_x_ranges[range_index];
2930 clip_value (&s->opt[OPT_TL_X], &s->val[OPT_TL_X].w);
2931
2932 s->opt[OPT_TL_Y].constraint.range
2933 = &s->dev->info.tl_y_ranges[range_index];
2934 clip_value (&s->opt[OPT_TL_Y], &s->val[OPT_TL_Y].w);
2935
2936 s->opt[OPT_BR_X].constraint.range
2937 = &s->dev->info.br_x_ranges[range_index];
2938 clip_value (&s->opt[OPT_BR_X], &s->val[OPT_BR_X].w);
2939
2940 s->opt[OPT_BR_Y].constraint.range
2941 = &s->dev->info.br_y_ranges[range_index];
2942 clip_value (&s->opt[OPT_BR_Y], &s->val[OPT_BR_Y].w);
2943
2944 return (SANE_STATUS_GOOD);
2945
2946 case OPT_PAPER:
2947 if (info)
2948 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
2949 #if 0
2950 if (s->val[option].s)
2951 free (s->val[option].s);
2952 s->val[option].s = strdup (val);
2953 #endif
2954 strcpy(s->val[option].s, val);
2955 s->val[OPT_TL_X].w = SANE_FIX(0);
2956 s->val[OPT_TL_Y].w = SANE_FIX(0);
2957 if (strcmp (s->val[option].s, "A3") == 0){
2958 s->val[OPT_BR_X].w = SANE_FIX(297);
2959 s->val[OPT_BR_Y].w = SANE_FIX(420);
2960 }else if (strcmp (s->val[option].s, "A4") == 0){
2961 s->val[OPT_BR_X].w = SANE_FIX(210);
2962 s->val[OPT_BR_Y].w = SANE_FIX(297);
2963 }else if (strcmp (s->val[option].s, "A5") == 0){
2964 s->val[OPT_BR_X].w = SANE_FIX(148.5);
2965 s->val[OPT_BR_Y].w = SANE_FIX(210);
2966 }else if (strcmp (s->val[option].s, "A6") == 0){
2967 s->val[OPT_BR_X].w = SANE_FIX(105);
2968 s->val[OPT_BR_Y].w = SANE_FIX(148.5);
2969 }else if (strcmp (s->val[option].s, "B4") == 0){
2970 s->val[OPT_BR_X].w = SANE_FIX(250);
2971 s->val[OPT_BR_Y].w = SANE_FIX(353);
2972 }else if (strcmp (s->val[option].s, "B5") == 0){
2973 s->val[OPT_BR_X].w = SANE_FIX(182);
2974 s->val[OPT_BR_Y].w = SANE_FIX(257);
2975 }else if (strcmp (s->val[option].s, W_LETTER) == 0){
2976 s->val[OPT_BR_X].w = SANE_FIX(279.4);
2977 s->val[OPT_BR_Y].w = SANE_FIX(431.8);
2978 }else if (strcmp (s->val[option].s, "Legal") == 0){
2979 s->val[OPT_BR_X].w = SANE_FIX(215.9);
2980 s->val[OPT_BR_Y].w = SANE_FIX(355.6);
2981 }else if (strcmp (s->val[option].s, "Letter") == 0){
2982 s->val[OPT_BR_X].w = SANE_FIX(215.9);
2983 s->val[OPT_BR_Y].w = SANE_FIX(279.4);
2984 }else if (strcmp (s->val[option].s, INVOICE) == 0){
2985 s->val[OPT_BR_X].w = SANE_FIX(215.9);
2986 s->val[OPT_BR_Y].w = SANE_FIX(139.7);
2987 }else{
2988 }
2989 return (SANE_STATUS_GOOD);
2990
2991 #ifdef USE_RESOLUTION_LIST
2992 case OPT_RESOLUTION_LIST:
2993 if (info)
2994 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
2995 for (i = 0; s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]; i++) {
2996 if (strcmp (val,
2997 s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]) == 0){
2998 s->val[OPT_X_RESOLUTION].w
2999 = atoi(s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]);
3000 s->val[OPT_Y_RESOLUTION].w
3001 = atoi(s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]);
3002 if (info)
3003 *info |= SANE_INFO_RELOAD_PARAMS;
3004 break;
3005 }
3006 }
3007 return (SANE_STATUS_GOOD);
3008 #endif
3009 #ifdef USE_CUSTOM_GAMMA
3010 /* side-effect-free word-array options: */
3011 case OPT_GAMMA_VECTOR:
3012 case OPT_GAMMA_VECTOR_R:
3013 case OPT_GAMMA_VECTOR_G:
3014 case OPT_GAMMA_VECTOR_B:
3015 memcpy (s->val[option].wa, val, s->opt[option].size);
3016 return SANE_STATUS_GOOD;
3017
3018 case OPT_CUSTOM_GAMMA:
3019 w = *(SANE_Word *) val;
3020
3021 if (w == s->val[OPT_CUSTOM_GAMMA].w)
3022 return SANE_STATUS_GOOD; /* no change */
3023
3024 if (info)
3025 *info |= SANE_INFO_RELOAD_OPTIONS;
3026 s->val[OPT_CUSTOM_GAMMA].w = w;
3027 set_gamma_caps(s);
3028 return SANE_STATUS_GOOD;
3029 #endif
3030 }
3031 }
3032
3033 DBG (10, ">>\n");
3034 return (SANE_STATUS_INVAL);
3035 }
3036
3037 SANE_Status
sane_get_parameters(SANE_Handle handle,SANE_Parameters * params)3038 sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
3039 {
3040 int width, length, xres, yres;
3041 const char *mode;
3042 SHARP_Scanner *s = handle;
3043 DBG (10, "<< sane_get_parameters ");
3044
3045 xres = s->val[OPT_X_RESOLUTION].w;
3046 #ifdef USE_SEPARATE_Y_RESOLUTION
3047 yres = s->val[OPT_Y_RESOLUTION].w;
3048 #else
3049 yres = xres;
3050 #endif
3051 if (!s->scanning)
3052 {
3053 /* make best-effort guess at what parameters will look like once
3054 scanning starts. */
3055 memset (&s->params, 0, sizeof (s->params));
3056
3057 width = MM_TO_PIX( SANE_UNFIX(s->val[OPT_BR_X].w)
3058 - SANE_UNFIX(s->val[OPT_TL_X].w),
3059 s->dev->info.mud);
3060 length = MM_TO_PIX( SANE_UNFIX(s->val[OPT_BR_Y].w)
3061 - SANE_UNFIX(s->val[OPT_TL_Y].w),
3062 s->dev->info.mud);
3063
3064 s->width = width;
3065 s->length = length;
3066 s->params.pixels_per_line = width * xres / s->dev->info.mud;
3067 s->params.lines = length * yres / s->dev->info.mud;
3068 s->unscanned_lines = s->params.lines;
3069 }
3070 else
3071 {
3072 static u_char cmd[] = {READ, 0, 0x81, 0, 0, 0, 0, 0, 4, 0};
3073 static u_char buf[4];
3074 size_t len = 4;
3075 SANE_Status status;
3076
3077 /* if async reads are used, )ie. if USE_FORK is defined,
3078 this command may only be issued immediately after the
3079 "start scan" command. Later calls will confuse the
3080 read queue.
3081 */
3082 if (!s->get_params_called)
3083 {
3084 wait_ready(s->fd);
3085 status = sanei_scsi_cmd (s->fd, cmd, sizeof (cmd), buf, &len);
3086
3087 if (status != SANE_STATUS_GOOD)
3088 {
3089 do_cancel(s);
3090 return (status);
3091 }
3092 s->params.pixels_per_line = (buf[1] << 8) + buf[0];
3093 s->params.lines = (buf[3] << 8) + buf[2];
3094 s->get_params_called = 1;
3095 }
3096 }
3097
3098 xres = s->val[OPT_X_RESOLUTION].w;
3099 #ifdef USE_SEPARATE_Y_RESOLUTION
3100 yres = s->val[OPT_Y_RESOLUTION].w;
3101 #else
3102 yres = xres;
3103 #endif
3104
3105 mode = s->val[OPT_MODE].s;
3106
3107 if (strcmp (mode, M_LINEART) == 0)
3108 {
3109 s->params.format = SANE_FRAME_GRAY;
3110 s->params.bytes_per_line = (s->params.pixels_per_line + 7) / 8;
3111 s->params.depth = 1;
3112 s->modes = MODES_LINEART;
3113 }
3114 else if (strcmp (mode, M_GRAY) == 0)
3115 {
3116 s->params.format = SANE_FRAME_GRAY;
3117 s->params.bytes_per_line = s->params.pixels_per_line;
3118 s->params.depth = 8;
3119 s->modes = MODES_GRAY;
3120 }
3121 else
3122 {
3123 s->params.format = SANE_FRAME_RGB;
3124 s->params.bytes_per_line = 3 * s->params.pixels_per_line;
3125 s->params.depth = 8;
3126 s->modes = MODES_COLOR;
3127 }
3128 s->params.last_frame = SANE_TRUE;
3129
3130 if (params)
3131 *params = s->params;
3132
3133 DBG (10, ">>\n");
3134 return (SANE_STATUS_GOOD);
3135 }
3136
3137 #ifdef USE_CUSTOM_GAMMA
3138
3139 static int
sprint_gamma(Option_Value val,SANE_Byte * dst)3140 sprint_gamma(Option_Value val, SANE_Byte *dst)
3141 {
3142 int i;
3143 SANE_Byte *p = dst;
3144
3145 p += sprintf((char *) p, "%i", val.wa[0] > 255 ? 255 : val.wa[0]);
3146 /* val.wa[i] is over 255, so val.wa[i] is limited to 255 */
3147 for (i = 1; i < 256; i++)
3148 p += sprintf((char *) p, ",%i", val.wa[i] > 255 ? 255 : val.wa[i]);
3149 return p - dst;
3150 }
3151
3152 static SANE_Status
send_ascii_gamma_tables(SHARP_Scanner * s)3153 send_ascii_gamma_tables (SHARP_Scanner *s)
3154 {
3155 SANE_Status status;
3156 int i;
3157
3158 DBG(11, "<< send_ascii_gamma_tables ");
3159
3160 /* we need: 4 bytes for each gamma value (3 digits + delimiter)
3161 + 10 bytes for the command header
3162 i.e. 4 * 4 * 256 + 10 = 4106 bytes
3163 */
3164
3165 if (s->dev->info.bufsize < 4106)
3166 return SANE_STATUS_NO_MEM;
3167
3168 memset(s->buffer, 0, 4106);
3169
3170 i = sprint_gamma(s->val[OPT_GAMMA_VECTOR_R], &s->buffer[10]);
3171 s->buffer[10+i++] = '/';
3172 i += sprint_gamma(s->val[OPT_GAMMA_VECTOR_G], &s->buffer[10+i]);
3173 s->buffer[10+i++] = '/';
3174 i += sprint_gamma(s->val[OPT_GAMMA_VECTOR_B], &s->buffer[10+i]);
3175 s->buffer[10+i++] = '/';
3176 i += sprint_gamma(s->val[OPT_GAMMA_VECTOR], &s->buffer[10+i]);
3177
3178 DBG(11, "%s\n", &s->buffer[10]);
3179
3180 s->buffer[0] = SEND;
3181 s->buffer[2] = 0x03;
3182 s->buffer[7] = i >> 8;
3183 s->buffer[8] = i & 0xff;
3184
3185 wait_ready(s->fd);
3186 status = sanei_scsi_cmd (s->fd, s->buffer, i+10, 0, 0);
3187
3188 DBG(11, ">>\n");
3189
3190 return status;
3191 }
3192 #endif
3193
3194 static SANE_Status
send_binary_g_table(SHARP_Scanner * s,SANE_Word * a,int dtq)3195 send_binary_g_table(SHARP_Scanner *s, SANE_Word *a, int dtq)
3196 {
3197 SANE_Status status;
3198 int i;
3199
3200 DBG(11, "<< send_binary_g_table\n");
3201
3202 memset(s->buffer, 0, 522);
3203
3204 s->buffer[0] = SEND;
3205 s->buffer[2] = 0x03;
3206 s->buffer[5] = dtq;
3207 s->buffer[7] = 2;
3208 s->buffer[8] = 0;
3209
3210 for (i = 0; i < 256; i++)
3211 {
3212 s->buffer[2*i+11] = a[i] > 255 ? 255 : a[i];
3213 }
3214
3215 for (i = 0; i < 256; i += 16)
3216 {
3217 DBG(11, "%02x %02x %02x %02x %02x %02x %02x %02x "
3218 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
3219 a[i ], a[i+1], a[i+2], a[i+3],
3220 a[i+4], a[i+5], a[i+6], a[i+7],
3221 a[i+8], a[i+9], a[i+10], a[i+11],
3222 a[i+12], a[i+13], a[i+14], a[i+15]);
3223 }
3224
3225 wait_ready(s->fd);
3226 status = sanei_scsi_cmd (s->fd, s->buffer, 2*i+10, 0, 0);
3227
3228 DBG(11, ">>\n");
3229
3230 return status;
3231 }
3232
3233 #ifdef USE_CUSTOM_GAMMA
3234 static SANE_Status
send_binary_gamma_tables(SHARP_Scanner * s)3235 send_binary_gamma_tables (SHARP_Scanner *s)
3236 {
3237 SANE_Status status;
3238
3239 status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR].wa, 0x10);
3240 if (status != SANE_STATUS_GOOD)
3241 return status;
3242
3243 status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_R].wa, 0x11);
3244 if (status != SANE_STATUS_GOOD)
3245 return status;
3246
3247 status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_G].wa, 0x12);
3248 if (status != SANE_STATUS_GOOD)
3249 return status;
3250
3251 status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_B].wa, 0x13);
3252
3253 return status;
3254 }
3255
3256 static SANE_Status
send_gamma_tables(SHARP_Scanner * s)3257 send_gamma_tables (SHARP_Scanner *s)
3258 {
3259 if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
3260 {
3261 return send_ascii_gamma_tables(s);
3262 }
3263 else
3264 {
3265 return send_binary_gamma_tables(s);
3266 }
3267
3268 }
3269 #endif
3270
3271 #ifdef USE_COLOR_THRESHOLD
3272 static SANE_Status
send_threshold_data(SHARP_Scanner * s)3273 send_threshold_data(SHARP_Scanner *s)
3274 {
3275 SANE_Status status;
3276 SANE_Byte cmd[26] = {SEND, 0, 0x82, 0, 0, 0, 0, 0, 0, 0};
3277 int len;
3278
3279 memset(cmd, 0, sizeof(cmd));
3280 /* maximum string length: 3 bytes for each number (they are
3281 restricted to the range 0..255), 3 '/' and the null-byte,
3282 total: 16 bytes.
3283 */
3284 len = sprintf((char *) &cmd[10], "%i/%i/%i/%i",
3285 s->val[OPT_THRESHOLD_R].w,
3286 s->val[OPT_THRESHOLD_G].w,
3287 s->val[OPT_THRESHOLD_B].w,
3288 s->val[OPT_THRESHOLD].w);
3289 cmd[8] = len;
3290
3291 wait_ready(s->fd);
3292 status = sanei_scsi_cmd(s->fd, cmd, len + 10, 0, 0);
3293 return status;
3294 }
3295 #endif
3296
3297
3298 SANE_Status
sane_start(SANE_Handle handle)3299 sane_start (SANE_Handle handle)
3300 {
3301 char *mode, *halftone, *gamma, *edge, *lightcolor, *adf_fsu;
3302 SHARP_Scanner *s = handle;
3303 SANE_Status status;
3304 size_t buf_size;
3305 SHARP_Send ss;
3306 window_param wp;
3307 mode_sense_subdevice m_subdev;
3308
3309 DBG (10, "<< sane_start ");
3310
3311 /* First make sure we have a current parameter set. Some of the
3312 parameters will be overwritten below, but that's OK. */
3313 status = sane_get_parameters (s, 0);
3314 if (status != SANE_STATUS_GOOD)
3315 return status;
3316
3317 s->dev->sensedat.complain_on_errors
3318 = COMPLAIN_ON_ADF_ERROR | s->dev->info.complain_on_errors;
3319
3320 #ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
3321 s->dev->info.bufsize = s->dev->info.wanted_bufsize;
3322 if (s->dev->info.bufsize < 32 * 1024)
3323 s->dev->info.bufsize = 32 * 1024;
3324 {
3325 int bsize = s->dev->info.bufsize;
3326 status = sanei_scsi_open_extended (s->dev->sane.name, &s->fd,
3327 &sense_handler, &s->dev->sensedat, &bsize);
3328 s->dev->info.bufsize = bsize;
3329 }
3330
3331 if (status != SANE_STATUS_GOOD)
3332 {
3333 DBG (1, "open of %s failed: %s\n",
3334 s->dev->sane.name, sane_strstatus (status));
3335 return (status);
3336 }
3337
3338 /* make sure that we got at least 32 kB. Even then, the scan will be
3339 awfully slow.
3340
3341 NOTE: If you need to decrease this value, remember that s->buffer
3342 is used in send_ascii_gamma_tables (JX330/JX610) and in
3343 send_binary_g_table (JX250/JX350). send_ascii_gamma_tables needs 4106
3344 bytes, and send_binary_g_table needs 522 bytes.
3345 */
3346 if (s->dev->info.bufsize < 32 * 1024)
3347 {
3348 sanei_scsi_close(s->fd);
3349 s->fd = -1;
3350 return SANE_STATUS_NO_MEM;
3351 }
3352 #else
3353 status = sanei_scsi_open(s->dev->sane.name, &s->fd, &sense_handler,
3354 &s->dev->sensedat);
3355 if (s->dev->info.wanted_bufsize < sanei_scsi_max_request_size)
3356 s->dev->info.bufsize = s->dev->info.wanted_bufsize;
3357 else
3358 s->dev->info.bufsize = sanei_scsi_max_request_size;
3359
3360 if (status != SANE_STATUS_GOOD)
3361 {
3362 DBG (1, "open of %s failed: %s\n",
3363 s->dev->sane.name, sane_strstatus (status));
3364 return (status);
3365 }
3366 #endif
3367
3368 s->buffer = malloc(s->dev->info.bufsize);
3369 if (!s->buffer) {
3370 sanei_scsi_close(s->fd);
3371 s->fd = -1;
3372 free(s);
3373 return SANE_STATUS_NO_MEM;
3374 }
3375
3376 #ifdef USE_FORK
3377 {
3378 struct shmid_ds ds;
3379 size_t n;
3380
3381 s->shmid = shmget(IPC_PRIVATE,
3382 sizeof(SHARP_rdr_ctl)
3383 + s->dev->info.buffers *
3384 (sizeof(SHARP_shmem_ctl) + s->dev->info.bufsize),
3385 IPC_CREAT | 0600);
3386 if (s->shmid == -1)
3387 {
3388 free(s->buffer);
3389 s->buffer = 0;
3390 sanei_scsi_close(s->fd);
3391 s->fd = -1;
3392 return SANE_STATUS_NO_MEM;
3393 }
3394 s->rdr_ctl = (SHARP_rdr_ctl*) shmat(s->shmid, 0, 0);
3395 if (s->rdr_ctl == (void *) -1)
3396 {
3397 shmctl(s->shmid, IPC_RMID, &ds);
3398 free(s->buffer);
3399 s->buffer = 0;
3400 sanei_scsi_close(s->fd);
3401 s->fd = -1;
3402 return SANE_STATUS_NO_MEM;
3403 }
3404
3405 s->rdr_ctl->buf_ctl = (SHARP_shmem_ctl*) &s->rdr_ctl[1];
3406 for (n = 0; n < s->dev->info.buffers; n++)
3407 {
3408 s->rdr_ctl->buf_ctl[n].buffer =
3409 (SANE_Byte*) &s->rdr_ctl->buf_ctl[s->dev->info.buffers]
3410 + n * s->dev->info.bufsize;
3411 }
3412 }
3413 #endif /* USE_FORK */
3414
3415 DBG (5, "start: TEST_UNIT_READY\n");
3416 status = test_unit_ready (s->fd);
3417
3418 if (status != SANE_STATUS_GOOD)
3419 {
3420 DBG (1, "TEST UNIT READY failed: %s\n", sane_strstatus (status));
3421 sanei_scsi_close (s->fd);
3422 s->fd = -1;
3423 return (status);
3424 }
3425
3426 DBG (3, "start: sending MODE SELECT\n");
3427 status = mode_select_mud (s->fd, s->dev->info.mud);
3428 if (status != SANE_STATUS_GOOD)
3429 {
3430 DBG (1, "start: MODE_SELECT6 failed\n");
3431 sanei_scsi_close (s->fd);
3432 s->fd = -1;
3433 return (status);
3434 }
3435
3436 mode = s->val[OPT_MODE].s;
3437 halftone = s->val[OPT_HALFTONE].s;
3438 gamma = s->val[OPT_GAMMA].s;
3439 edge = s->val[OPT_EDGE_EMPHASIS].s;
3440 lightcolor = s->val[OPT_LIGHTCOLOR].s;
3441 adf_fsu = s->val[OPT_SCANSOURCE].s;
3442 s->speed = s->val[OPT_SPEED].w;
3443
3444 s->xres = s->val[OPT_X_RESOLUTION].w;
3445 if (s->val[OPT_PREVIEW].w == SANE_FALSE)
3446 {
3447 #ifdef USE_SEPARATE_Y_RESOLUTION
3448 s->yres = s->val[OPT_Y_RESOLUTION].w;
3449 #else
3450 s->yres = s->val[OPT_X_RESOLUTION].w;
3451 #endif
3452 s->speed = s->val[OPT_SPEED].w;
3453 }
3454 else
3455 {
3456 s->yres = s->val[OPT_X_RESOLUTION].w;
3457 s->speed = SANE_TRUE;
3458 }
3459
3460 s->ulx = MM_TO_PIX(SANE_UNFIX(s->val[OPT_TL_X].w), s->dev->info.mud);
3461 s->uly = MM_TO_PIX(SANE_UNFIX(s->val[OPT_TL_Y].w), s->dev->info.mud);
3462 s->threshold = s->val[OPT_THRESHOLD].w;
3463 s->bpp = s->params.depth;
3464
3465 s->adf_fsu_mode = SCAN_SIMPLE; /* default: scan without ADF and FSU */
3466 #ifdef ALLOW_AUTO_SELECT_ADF
3467 if (strcmp (adf_fsu, use_auto) == 0)
3468 s->adf_fsu_mode = SCAN_ADF_FSU_AUTO;
3469 else
3470 #endif
3471 if (strcmp(adf_fsu, use_fsu) == 0)
3472 s->adf_fsu_mode = SCAN_WITH_FSU;
3473 else if (strcmp(adf_fsu, use_adf) == 0)
3474 s->adf_fsu_mode = SCAN_WITH_ADF;
3475 else if (strcmp(adf_fsu, use_adf) == 0)
3476 s->adf_fsu_mode = SCAN_SIMPLE;
3477
3478 if (strcmp (mode, M_LINEART) == 0)
3479 {
3480 s->reverse = 0;
3481 if (strcmp(halftone, M_BILEVEL) == 0)
3482 {
3483 s->halftone = 1;
3484 s->image_composition = 0;
3485 }
3486 else if (strcmp(halftone, M_BAYER) == 0)
3487 {
3488 s->halftone = 2;
3489 s->image_composition = 1;
3490 }
3491 else if (strcmp(halftone, M_SPIRAL) == 0)
3492 {
3493 s->halftone = 3;
3494 s->image_composition = 1;
3495 }
3496 else if (strcmp(halftone, M_DISPERSED) == 0)
3497 {
3498 s->halftone = 4;
3499 s->image_composition = 1;
3500 }
3501 else if (strcmp(halftone, M_ERRDIFFUSION) == 0)
3502 {
3503 s->halftone = 5;
3504 s->image_composition = 1;
3505 }
3506 }
3507 else if (strcmp (mode, M_GRAY) == 0)
3508 {
3509 s->image_composition = 2;
3510 s->reverse = 1;
3511 }
3512 else if (strcmp (mode, M_LINEART_COLOR) == 0)
3513 {
3514 s->reverse = 1;
3515 if (strcmp(halftone, M_BILEVEL) == 0)
3516 {
3517 s->halftone = 1;
3518 s->image_composition = 3;
3519 }
3520 else if (strcmp(halftone, M_BAYER) == 0)
3521 {
3522 s->halftone = 2;
3523 s->image_composition = 4;
3524 }
3525 else if (strcmp(halftone, M_SPIRAL) == 0)
3526 {
3527 s->halftone = 3;
3528 s->image_composition = 4;
3529 }
3530 else if (strcmp(halftone, M_DISPERSED) == 0)
3531 {
3532 s->halftone = 4;
3533 s->image_composition = 4;
3534 }
3535 else if (strcmp(halftone, M_ERRDIFFUSION) == 0)
3536 {
3537 s->halftone = 5;
3538 s->image_composition = 4;
3539 }
3540 }
3541 else if (strcmp (mode, M_COLOR) == 0)
3542 {
3543 s->image_composition = 5;
3544 s->reverse = 1;
3545 }
3546
3547 if (strcmp (edge, EDGE_NONE) == 0)
3548 {
3549 DBG (11, "EDGE EMPHASIS NONE\n");
3550 s->edge = 0;
3551 }
3552 else if (strcmp (edge, EDGE_MIDDLE) == 0)
3553 {
3554 DBG (11, "EDGE EMPHASIS MIDDLE\n");
3555 s->edge = 1;
3556 }
3557 else if (strcmp (edge, EDGE_STRONG) == 0)
3558 {
3559 DBG (11, "EDGE EMPHASIS STRONG\n");
3560 s->edge = 2;
3561 }
3562 else if (strcmp (edge, EDGE_BLUR) == 0)
3563 {
3564 DBG (11, "EDGE EMPHASIS BLUR\n");
3565 s->edge = 3;
3566 }
3567
3568 s->lightcolor = 3;
3569 if (strcmp(lightcolor, LIGHT_GREEN) == 0)
3570 s->lightcolor = 0;
3571 else if (strcmp(lightcolor, LIGHT_RED) == 0)
3572 s->lightcolor = 1;
3573 else if (strcmp(lightcolor, LIGHT_BLUE) == 0)
3574 s->lightcolor = 2;
3575 else if (strcmp(lightcolor, LIGHT_WHITE) == 0)
3576 s->lightcolor = 3;
3577
3578 s->adf_scan = 0;
3579 if ( s->dev->sensedat.model != JX610
3580 && s->dev->sensedat.model != JX320)
3581 {
3582 status = mode_select_adf_fsu(s->fd, s->adf_fsu_mode);
3583 if (status != SANE_STATUS_GOOD)
3584 {
3585 DBG (10, "sane_start: mode_select_adf_fsu failed: %s\n", sane_strstatus (status));
3586 sanei_scsi_close (s->fd);
3587 s->fd = -1;
3588 return (status);
3589 }
3590 /* if the ADF is selected, check if it is ready */
3591 memset (&m_subdev, 0, sizeof (m_subdev));
3592 buf_size = sizeof (m_subdev);
3593 status = mode_sense (s->fd, &m_subdev, &buf_size, 0x20);
3594 DBG(11, "mode sense result a_mode: %x f_mode: %x\n",
3595 m_subdev.a_mode_type, m_subdev.f_mode_type);
3596 if (status != SANE_STATUS_GOOD)
3597 {
3598 DBG (10, "sane_start: MODE_SENSE/subdevice page failed\n");
3599 sanei_scsi_close (s->fd);
3600 s->fd = -1;
3601 return (status);
3602 }
3603 if (s->adf_fsu_mode == SCAN_WITH_ADF)
3604 s->adf_scan = 1;
3605 #ifdef ALLOW_AUTO_SELECT_ADF
3606 else if (s->adf_fsu_mode == SCAN_ADF_FSU_AUTO)
3607 {
3608 if (m_subdev.a_mode_type & 0x80)
3609 s->adf_scan = 1;
3610 }
3611 #endif
3612 }
3613
3614
3615 #ifdef USE_CUSTOM_GAMMA
3616 if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
3617 {
3618 #endif
3619 if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
3620 {
3621 ss.dtc = 0x03;
3622 if (strcmp (gamma, GAMMA10) == 0)
3623 {
3624 ss.dtq = 0x01;
3625 }else{
3626 ss.dtq = 0x02;
3627 }
3628 ss.length = 0;
3629 DBG (5, "start: SEND\n");
3630 status = send (s->fd, &ss);
3631 if (status != SANE_STATUS_GOOD)
3632 {
3633 DBG (1, "send failed: %s\n", sane_strstatus (status));
3634 sanei_scsi_close (s->fd);
3635 s->fd = -1;
3636 return (status);
3637 }
3638 }
3639 else
3640 {
3641 /* the JX250 does not support the "fixed gamma selection",
3642 therefore, lets calculate & send gamma values
3643 */
3644 int i;
3645 SANE_Word gtbl[256];
3646 if (strcmp (gamma, GAMMA10) == 0)
3647 for (i = 0; i < 256; i++)
3648 gtbl[i] = i;
3649 else
3650 {
3651 gtbl[0] = 0;
3652 for (i = 1; i < 256; i++)
3653 gtbl[i] = 255 * exp(0.45 * log(i/255.0));
3654 }
3655 send_binary_g_table(s, gtbl, 0x10);
3656 send_binary_g_table(s, gtbl, 0x11);
3657 send_binary_g_table(s, gtbl, 0x12);
3658 send_binary_g_table(s, gtbl, 0x13);
3659 }
3660 #ifdef USE_CUSTOM_GAMMA
3661 }
3662 else
3663 status = send_gamma_tables(s);
3664 if (status != SANE_STATUS_GOOD)
3665 {
3666 sanei_scsi_close (s->fd);
3667 s->fd = -1;
3668 return (status);
3669 }
3670 #endif
3671
3672 if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
3673 {
3674 ss.dtc = 0x86;
3675 ss.dtq = 0x05;
3676 ss.length = 0;
3677 DBG (5, "start: SEND\n");
3678 status = send (s->fd, &ss);
3679 if (status != SANE_STATUS_GOOD)
3680 {
3681 DBG (1, "send failed: %s\n", sane_strstatus (status));
3682 sanei_scsi_close (s->fd);
3683 s->fd = -1;
3684 return (status);
3685 }
3686
3687 #ifdef USE_COLOR_THRESHOLD
3688 status = send_threshold_data(s);
3689 if (status != SANE_STATUS_GOOD)
3690 {
3691 DBG (1, "send threshold data failed: %s\n", sane_strstatus (status));
3692 sanei_scsi_close (s->fd);
3693 s->fd = -1;
3694 return (status);
3695 }
3696 #endif
3697 }
3698
3699 memset (&wp, 0, sizeof (wp));
3700 /* every Sharp scanner seems to have a different
3701 window descriptor block...
3702 */
3703 if ( s->dev->sensedat.model == JX610
3704 || s->dev->sensedat.model == JX320)
3705 {
3706 buf_size = sizeof(WDB);
3707 }
3708 else if (s->dev->sensedat.model == JX330)
3709 {
3710 buf_size = sizeof (WDB) + sizeof(WDBX330);
3711 }
3712 else
3713 {
3714 buf_size = sizeof (WDB) + sizeof(WDBX330) + sizeof(WDBX250);
3715 }
3716
3717 wp.wpdh.wdl[0] = buf_size >> 8;
3718 wp.wpdh.wdl[1] = buf_size;
3719 wp.wdb.x_res[0] = s->xres >> 8;
3720 wp.wdb.x_res[1] = s->xres;
3721 wp.wdb.y_res[0] = s->yres >> 8;
3722 wp.wdb.y_res[1] = s->yres;
3723 wp.wdb.x_ul[0] = s->ulx >> 24;
3724 wp.wdb.x_ul[1] = s->ulx >> 16;
3725 wp.wdb.x_ul[2] = s->ulx >> 8;
3726 wp.wdb.x_ul[3] = s->ulx;
3727 wp.wdb.y_ul[0] = s->uly >> 24;
3728 wp.wdb.y_ul[1] = s->uly >> 16;
3729 wp.wdb.y_ul[2] = s->uly >> 8;
3730 wp.wdb.y_ul[3] = s->uly;
3731 wp.wdb.width[0] = s->width >> 24;
3732 wp.wdb.width[1] = s->width >> 16;
3733 wp.wdb.width[2] = s->width >> 8;
3734 wp.wdb.width[3] = s->width;
3735 wp.wdb.length[0] = s->length >> 24;
3736 wp.wdb.length[1] = s->length >> 16;
3737 wp.wdb.length[2] = s->length >> 8;
3738 wp.wdb.length[3] = s->length;
3739 wp.wdb.brightness = 0;
3740 wp.wdb.threshold = s->threshold;
3741 wp.wdb.image_composition = s->image_composition;
3742 if (s->image_composition <= 2 || s->image_composition >= 5)
3743 wp.wdb.bpp = s->bpp;
3744 else
3745 wp.wdb.bpp = 1;
3746 wp.wdb.ht_pattern[0] = 0;
3747 if ( s->dev->sensedat.model == JX610
3748 || s->dev->sensedat.model == JX320)
3749 {
3750 wp.wdb.ht_pattern[1] = 0;
3751 }else{
3752 wp.wdb.ht_pattern[1] = s->halftone;
3753 }
3754 wp.wdb.rif_padding = (s->reverse * 128) + 0;
3755 wp.wdb.eletu = (!s->speed << 2) + (s->edge << 6) + (s->lightcolor << 4);
3756
3757 if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350)
3758 {
3759 wp.wdbx250.threshold_red = s->val[OPT_THRESHOLD_R].w;
3760 wp.wdbx250.threshold_green = s->val[OPT_THRESHOLD_G].w;
3761 wp.wdbx250.threshold_blue = s->val[OPT_THRESHOLD_B].w;
3762 }
3763
3764
3765 DBG (5, "wdl=%d\n", (wp.wpdh.wdl[0] << 8) + wp.wpdh.wdl[1]);
3766 DBG (5, "xres=%d\n", (wp.wdb.x_res[0] << 8) + wp.wdb.x_res[1]);
3767 DBG (5, "yres=%d\n", (wp.wdb.y_res[0] << 8) + wp.wdb.y_res[1]);
3768 DBG (5, "ulx=%d\n", (wp.wdb.x_ul[0] << 24) + (wp.wdb.x_ul[1] << 16) +
3769 (wp.wdb.x_ul[2] << 8) + wp.wdb.x_ul[3]);
3770 DBG (5, "uly=%d\n", (wp.wdb.y_ul[0] << 24) + (wp.wdb.y_ul[1] << 16) +
3771 (wp.wdb.y_ul[2] << 8) + wp.wdb.y_ul[3]);
3772 DBG (5, "width=%d\n", (wp.wdb.width[0] << 8) + (wp.wdb.width[1] << 16) +
3773 (wp.wdb.width[2] << 8) + wp.wdb.width[3]);
3774 DBG (5, "length=%d\n", (wp.wdb.length[0] << 16) + (wp.wdb.length[1] << 16) +
3775 (wp.wdb.length[2] << 8) + wp.wdb.length[3]);
3776
3777 DBG (5, "threshold=%d\n", wp.wdb.threshold);
3778 DBG (5, "image_composition=%d\n", wp.wdb.image_composition);
3779 DBG (5, "bpp=%d\n", wp.wdb.bpp);
3780 DBG (5, "rif_padding=%d\n", wp.wdb.rif_padding);
3781 DBG (5, "eletu=%d\n", wp.wdb.eletu);
3782
3783 #if 0
3784 {
3785 unsigned char *p = (unsigned char*) &wp.wdb;
3786 int i;
3787 DBG(11, "set window:\n");
3788 for (i = 0; i < sizeof(wp.wdb) + + sizeof(wp.wdbx330) + sizeof(wp.wdbx250); i += 16)
3789 {
3790 DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x %2x %2x %2x %2x\n",
3791 p[i], p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6], p[i+7], p[i+8],
3792 p[i+9], p[i+10], p[i+11], p[i+12], p[i+13], p[i+14], p[i+15]);
3793 }
3794 }
3795 #endif
3796
3797 buf_size += sizeof(WPDH);
3798 DBG (5, "start: SET WINDOW\n");
3799 status = set_window (s->fd, &wp, buf_size);
3800 if (status != SANE_STATUS_GOOD)
3801 {
3802 DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
3803 sanei_scsi_close (s->fd);
3804 s->fd = -1;
3805 return (status);
3806 }
3807
3808 memset (&wp, 0, buf_size);
3809 DBG (5, "start: GET WINDOW\n");
3810 status = get_window (s->fd, &wp, &buf_size);
3811 if (status != SANE_STATUS_GOOD)
3812 {
3813 DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
3814 sanei_scsi_close (s->fd);
3815 s->fd = -1;
3816 return (status);
3817 }
3818 DBG (5, "xres=%d\n", (wp.wdb.x_res[0] << 8) + wp.wdb.x_res[1]);
3819 DBG (5, "yres=%d\n", (wp.wdb.y_res[0] << 8) + wp.wdb.y_res[1]);
3820 DBG (5, "ulx=%d\n", (wp.wdb.x_ul[0] << 24) + (wp.wdb.x_ul[1] << 16) +
3821 (wp.wdb.x_ul[2] << 8) + wp.wdb.x_ul[3]);
3822 DBG (5, "uly=%d\n", (wp.wdb.y_ul[0] << 24) + (wp.wdb.y_ul[1] << 16) +
3823 (wp.wdb.y_ul[2] << 8) + wp.wdb.y_ul[3]);
3824 DBG (5, "width=%d\n", (wp.wdb.width[0] << 24) + (wp.wdb.width[1] << 16) +
3825 (wp.wdb.width[2] << 8) + wp.wdb.width[3]);
3826 DBG (5, "length=%d\n", (wp.wdb.length[0] << 24) + (wp.wdb.length[1] << 16) +
3827 (wp.wdb.length[2] << 8) + wp.wdb.length[3]);
3828
3829 if (s->adf_scan)
3830 {
3831 status = object_position(s->fd, LOAD_PAPER);
3832 if (status != SANE_STATUS_GOOD)
3833 {
3834 sanei_scsi_close (s->fd);
3835 s->fd = -1;
3836 s->busy = SANE_FALSE;
3837 s->cancel = SANE_FALSE;
3838 return (status);
3839 }
3840 }
3841
3842 DBG (5, "start: SCAN\n");
3843 s->scanning = SANE_TRUE;
3844 s->busy = SANE_TRUE;
3845 s->cancel = SANE_FALSE;
3846 s->get_params_called = 0;
3847
3848 wait_ready(s->fd);
3849 status = scan (s->fd);
3850 #ifdef DEBUG
3851 {
3852 struct timeval t;
3853 gettimeofday(&t, 0);
3854 DBG(2, "rd: scan started %li.%06li\n", t.tv_sec, t.tv_usec);
3855 }
3856 #endif
3857 if (status != SANE_STATUS_GOOD)
3858 {
3859 DBG (1, "start of scan failed: %s\n", sane_strstatus (status));
3860 do_cancel(s);
3861 return (status);
3862 }
3863
3864 /* ask the scanner for the scan size */
3865 /* wait_ready(s->fd); */
3866 #ifdef DEBUG
3867 {
3868 struct timeval t;
3869 gettimeofday(&t, 0);
3870 DBG(2, "rd: wait_ready ok %li.%06li\n", t.tv_sec, t.tv_usec);
3871 }
3872 #endif
3873 sane_get_parameters(s, 0);
3874 #ifdef DEBUG
3875 {
3876 struct timeval t;
3877 gettimeofday(&t, 0);
3878 DBG(2, "rd: get_params ok %li.%06li\n", t.tv_sec, t.tv_usec);
3879 }
3880 #endif
3881 if (strcmp (mode, M_LINEART_COLOR) != 0)
3882 s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
3883 else
3884 {
3885 s->bytes_to_read = (s->params.pixels_per_line+7) / 8;
3886 s->bytes_to_read *= 3 * s->params.lines;
3887 }
3888
3889 #ifdef USE_FORK
3890 {
3891 size_t i;
3892 for (i = 0; i < s->dev->info.buffers; i++)
3893 s->rdr_ctl->buf_ctl[i].shm_status = SHM_EMPTY;
3894 s->read_buff = 0;
3895 s->rdr_ctl->cancel = 0;
3896 s->rdr_ctl->running = 0;
3897 s->rdr_ctl->status = SANE_STATUS_GOOD;
3898 }
3899 s->reader_pid = fork();
3900 #ifdef DEBUG
3901 {
3902 struct timeval t;
3903 gettimeofday(&t, 0);
3904 DBG(2, "rd: forked %li.%06li %i\n", t.tv_sec, t.tv_usec,
3905 s->reader_pid);
3906 }
3907 #endif
3908 if (s->reader_pid == 0)
3909 {
3910 sigset_t ignore_set;
3911 struct SIGACTION act;
3912
3913 sigfillset (&ignore_set);
3914 sigdelset (&ignore_set, SIGTERM);
3915 sigprocmask (SIG_SETMASK, &ignore_set, 0);
3916
3917 memset (&act, 0, sizeof (act));
3918 sigaction (SIGTERM, &act, 0);
3919
3920 /* don't use exit() since that would run the atexit() handlers... */
3921 _exit (reader_process (s));
3922 }
3923 else if (s->reader_pid == -1)
3924 {
3925 s->busy = SANE_FALSE;
3926 do_cancel(s);
3927 return SANE_STATUS_NO_MEM;
3928 }
3929
3930 #endif /* USE_FORK */
3931
3932
3933 DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, "
3934 "dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line,
3935 s->params.lines, (u_long) s->bytes_to_read, s->val[OPT_X_RESOLUTION].w);
3936
3937 s->busy = SANE_FALSE;
3938 s->buf_used = 0;
3939 s->buf_pos = 0;
3940
3941 if (s->cancel == SANE_TRUE)
3942 {
3943 do_cancel(s);
3944 DBG (10, ">>\n");
3945 return(SANE_STATUS_CANCELLED);
3946 }
3947
3948 DBG (10, ">>\n");
3949 return (SANE_STATUS_GOOD);
3950
3951 }
3952
3953 static SANE_Status
sane_read_direct(SANE_Handle handle,SANE_Byte * dst_buf,SANE_Int max_len,SANE_Int * len)3954 sane_read_direct (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
3955 SANE_Int * len)
3956 {
3957 SHARP_Scanner *s = handle;
3958 SANE_Status status;
3959 size_t nread;
3960 DBG (10, "<< sane_read_direct ");
3961
3962 DBG (20, "remaining: %lu ", (u_long) s->bytes_to_read);
3963 *len = 0;
3964
3965 if (s->bytes_to_read == 0)
3966 {
3967 do_cancel (s);
3968 return (SANE_STATUS_EOF);
3969 }
3970
3971 if (!s->scanning)
3972 return (do_cancel (s));
3973 nread = max_len;
3974 if (nread > s->bytes_to_read)
3975 nread = s->bytes_to_read;
3976 if (nread > s->dev->info.bufsize)
3977 nread = s->dev->info.bufsize;
3978 #ifdef USE_FORK
3979 status = read_data(s, dst_buf, &nread);
3980 #else
3981 wait_ready(s->fd);
3982 status = read_data (s, dst_buf, &nread);
3983 #endif
3984 if (status != SANE_STATUS_GOOD)
3985 {
3986 do_cancel (s);
3987 return (SANE_STATUS_IO_ERROR);
3988 }
3989 *len = nread;
3990 s->bytes_to_read -= nread;
3991 DBG (20, "remaining: %lu ", (u_long) s->bytes_to_read);
3992
3993 DBG (10, ">>\n");
3994 return (SANE_STATUS_GOOD);
3995 }
3996
3997 static SANE_Status
sane_read_shuffled(SANE_Handle handle,SANE_Byte * dst_buf,SANE_Int max_len,SANE_Int * len,int eight_bit_data)3998 sane_read_shuffled (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
3999 SANE_Int * len, int eight_bit_data)
4000 {
4001 SHARP_Scanner *s = handle;
4002 SANE_Status status;
4003 SANE_Byte *dest, *red, *green, *blue, mask;
4004 SANE_Int transfer;
4005 size_t nread, ntest, pixel, max_pixel, line, max_line;
4006 size_t start_input, bytes_per_line_in;
4007 DBG (10, "<< sane_read_shuffled ");
4008
4009 *len = 0;
4010 if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used)
4011 {
4012 do_cancel (s);
4013 DBG (10, ">>\n");
4014 return (SANE_STATUS_EOF);
4015 }
4016
4017 if (!s->scanning)
4018 {
4019 DBG (10, ">>\n");
4020 return(do_cancel(s));
4021 }
4022
4023 if (s->buf_pos < s->buf_used)
4024 {
4025 transfer = s->buf_used - s->buf_pos;
4026 if (transfer > max_len)
4027 transfer = max_len;
4028
4029 memcpy(dst_buf, &(s->buffer[s->buf_pos]), transfer);
4030 s->buf_pos += transfer;
4031 max_len -= transfer;
4032 *len = transfer;
4033 }
4034
4035 while (max_len > 0 && s->bytes_to_read > 0)
4036 {
4037 if (eight_bit_data)
4038 {
4039 nread = s->dev->info.bufsize / s->params.bytes_per_line - 1;
4040 nread *= s->params.bytes_per_line;
4041 if (nread > s->bytes_to_read)
4042 nread = s->bytes_to_read;
4043 max_line = nread / s->params.bytes_per_line;
4044 start_input = s->params.bytes_per_line;
4045 bytes_per_line_in = s->params.bytes_per_line;
4046 }
4047 else
4048 {
4049 bytes_per_line_in = (s->params.pixels_per_line + 7) / 8;
4050 bytes_per_line_in *= 3;
4051 max_line = s->params.bytes_per_line + bytes_per_line_in;
4052 max_line = s->dev->info.bufsize / max_line;
4053 nread = max_line * bytes_per_line_in;
4054 if (nread > s->bytes_to_read)
4055 {
4056 nread = s->bytes_to_read;
4057 max_line = nread / bytes_per_line_in;
4058 }
4059 start_input = s->dev->info.bufsize - nread;
4060 }
4061 ntest = nread;
4062
4063 #ifdef USE_FORK
4064 status = read_data (s, &(s->buffer[start_input]), &nread);
4065 #else
4066 wait_ready(s->fd);
4067 status = read_data (s, &(s->buffer[start_input]), &nread);
4068 #endif
4069 if (status != SANE_STATUS_GOOD)
4070 {
4071 do_cancel (s);
4072 DBG (10, ">>\n");
4073 return (SANE_STATUS_IO_ERROR);
4074 }
4075
4076 if (nread != ntest)
4077 {
4078 /* if this happens, something is wrong in the input buffer
4079 management...
4080 */
4081 DBG(1, "Warning: could not read an integral number of scan lines\n");
4082 DBG(1, " image will be scrambled\n");
4083 }
4084
4085
4086 s->buf_used = max_line * s->params.bytes_per_line;
4087 s->buf_pos = 0;
4088 s->bytes_to_read -= nread;
4089 dest = s->buffer;
4090 max_pixel = s->params.pixels_per_line;
4091
4092 if (eight_bit_data)
4093 for (line = 1; line <= max_line; line++)
4094 {
4095 red = &(s->buffer[line * s->params.bytes_per_line]);
4096 green = &(red[max_pixel]);
4097 blue = &(green[max_pixel]);
4098 for (pixel = 0; pixel < max_pixel; pixel++)
4099 {
4100 *dest++ = *red++;
4101 *dest++ = *green++;
4102 *dest++ = *blue++;
4103 }
4104 }
4105 else
4106 for (line = 0; line < max_line; line++)
4107 {
4108 red = &(s->buffer[start_input + line * bytes_per_line_in]);
4109 green = &(red[(max_pixel+7)/8]);
4110 blue = &(green[(max_pixel+7)/8]);
4111 mask = 0x80;
4112 for (pixel = 0; pixel < max_pixel; pixel++)
4113 {
4114 *dest++ = (*red & mask) ? 0xff : 0;
4115 *dest++ = (*green & mask) ? 0xff : 0;
4116 *dest++ = (*blue & mask) ? 0xff : 0;
4117 mask = mask >> 1;
4118 if (mask == 0)
4119 {
4120 mask = 0x80;
4121 red++;
4122 green++;
4123 blue++;
4124 }
4125 }
4126 }
4127
4128 transfer = max_len;
4129 if (transfer > s->buf_used)
4130 transfer = s->buf_used;
4131 memcpy(&(dst_buf[*len]), s->buffer, transfer);
4132
4133 max_len -= transfer;
4134 s->buf_pos += transfer;
4135 *len += transfer;
4136 }
4137
4138 if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used)
4139 do_cancel (s);
4140 DBG (10, ">>\n");
4141 return (SANE_STATUS_GOOD);
4142 }
4143
4144 SANE_Status
sane_read(SANE_Handle handle,SANE_Byte * dst_buf,SANE_Int max_len,SANE_Int * len)4145 sane_read (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
4146 SANE_Int * len)
4147 {
4148 SHARP_Scanner *s = handle;
4149 SANE_Status status;
4150
4151 s->busy = SANE_TRUE;
4152 if (s->cancel == SANE_TRUE)
4153 {
4154 do_cancel(s);
4155 *len = 0;
4156 return (SANE_STATUS_CANCELLED);
4157 }
4158
4159 /* RGB scans with a JX 250 and bi-level color scans
4160 must be handled differently: */
4161 if (s->image_composition <= 2)
4162 status = sane_read_direct(handle, dst_buf, max_len, len);
4163 else if (s->image_composition <= 4)
4164 status = sane_read_shuffled(handle, dst_buf, max_len, len, 0);
4165 else if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350 )
4166 status = sane_read_direct(handle, dst_buf, max_len, len);
4167 else
4168 status = sane_read_shuffled(handle, dst_buf, max_len, len, 1);
4169
4170 s->busy = SANE_FALSE;
4171 if (s->cancel == SANE_TRUE)
4172 {
4173 do_cancel(s);
4174 return (SANE_STATUS_CANCELLED);
4175 }
4176
4177 return (status);
4178 }
4179
4180 void
sane_cancel(SANE_Handle handle)4181 sane_cancel (SANE_Handle handle)
4182 {
4183 SHARP_Scanner *s = handle;
4184 DBG (10, "<< sane_cancel ");
4185
4186 s->cancel = SANE_TRUE;
4187 if (s->busy == SANE_FALSE)
4188 do_cancel(s);
4189
4190 DBG (10, ">>\n");
4191 }
4192
4193 SANE_Status
sane_set_io_mode(SANE_Handle __sane_unused__ handle,SANE_Bool __sane_unused__ non_blocking)4194 sane_set_io_mode (SANE_Handle __sane_unused__ handle,
4195 SANE_Bool __sane_unused__ non_blocking)
4196 {
4197 DBG (10, "<< sane_set_io_mode");
4198 DBG (10, ">>\n");
4199
4200 return SANE_STATUS_UNSUPPORTED;
4201 }
4202
4203 SANE_Status
sane_get_select_fd(SANE_Handle __sane_unused__ handle,SANE_Int __sane_unused__ * fd)4204 sane_get_select_fd (SANE_Handle __sane_unused__ handle,
4205 SANE_Int __sane_unused__ * fd)
4206 {
4207 DBG (10, "<< sane_get_select_fd");
4208 DBG (10, ">>\n");
4209
4210 return SANE_STATUS_UNSUPPORTED;
4211 }
4212