1 /*
2 * SANE backend for Xerox Phaser 3200MFP et al.
3 * Copyright 2008-2016 ABC <abc@telekom.ru>
4 *
5 * Network Scanners Support
6 * Copyright 2010 Alexander Kuznetsov <acca(at)cpan.org>
7 *
8 * Color scanning on Samsung M2870 model and Xerox Cognac 3215 & 3225
9 * models by Laxmeesh Onkar Markod <m.laxmeesh@samsung.com>
10 *
11 * This program is licensed under GPL + SANE exception.
12 * More info at http://www.sane-project.org/license.html
13 */
14
15 #define DEBUG_NOT_STATIC
16 #define BACKEND_NAME xerox_mfp
17
18 #include "../include/sane/config.h"
19 #include "../include/lassert.h"
20 #include <ctype.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <math.h>
26 #include <unistd.h>
27 #include <sys/time.h>
28 #include <sys/types.h>
29 #include "../include/sane/sane.h"
30 #include "../include/sane/sanei.h"
31 #include "../include/sane/saneopts.h"
32 #include "../include/sane/sanei_thread.h"
33 #include "../include/sane/sanei_usb.h"
34 #include "../include/sane/sanei_config.h"
35 #include "../include/sane/sanei_backend.h"
36 #ifdef HAVE_LIBJPEG
37 #include <jpeglib.h>
38 #endif
39 #include "xerox_mfp.h"
40
41 #define BACKEND_BUILD 13
42 #define XEROX_CONFIG_FILE "xerox_mfp.conf"
43
44 static const SANE_Device **devlist = NULL; /* sane_get_devices array */
45 static struct device *devices_head = NULL; /* sane_get_devices list */
46
47 enum { TRANSPORT_USB, TRANSPORT_TCP, TRANSPORTS_MAX };
48 transport available_transports[TRANSPORTS_MAX] = {
49 { "usb", usb_dev_request, usb_dev_open, usb_dev_close, usb_configure_device },
50 { "tcp", tcp_dev_request, tcp_dev_open, tcp_dev_close, tcp_configure_device },
51 };
52
resolv_state(int state)53 static int resolv_state(int state)
54 {
55 if (state & STATE_DOCUMENT_JAM)
56 return SANE_STATUS_JAMMED;
57 if (state & STATE_NO_DOCUMENT)
58 return SANE_STATUS_NO_DOCS;
59 if (state & STATE_COVER_OPEN)
60 return SANE_STATUS_COVER_OPEN;
61 if (state & STATE_INVALID_AREA)
62 return SANE_STATUS_INVAL; /* sane_start: implies SANE_INFO_RELOAD_OPTIONS */
63 if (state & STATE_WARMING)
64 #ifdef SANE_STATUS_WARMING_UP
65 return SANE_STATUS_WARMING_UP;
66 #else
67 return SANE_STATUS_DEVICE_BUSY;
68 #endif
69 if (state & STATE_LOCKING)
70 #ifdef SANE_STATUS_HW_LOCKED
71 return SANE_STATUS_HW_LOCKED;
72 #else
73 return SANE_STATUS_JAMMED;
74 #endif
75 if (state & ~STATE_NO_ERROR)
76 return SANE_STATUS_DEVICE_BUSY;
77 return 0;
78 }
79
str_cmd(int cmd)80 static char *str_cmd(int cmd)
81 {
82 switch (cmd) {
83 case CMD_ABORT: return "ABORT";
84 case CMD_INQUIRY: return "INQUIRY";
85 case CMD_RESERVE_UNIT: return "RESERVE_UNIT";
86 case CMD_RELEASE_UNIT: return "RELEASE_UNIT";
87 case CMD_SET_WINDOW: return "SET_WINDOW";
88 case CMD_READ: return "READ";
89 case CMD_READ_IMAGE: return "READ_IMAGE";
90 case CMD_OBJECT_POSITION: return "OBJECT_POSITION";
91 }
92 return "unknown";
93 }
94
95 #define MAX_DUMP 70
96 const char *encTmpFileName = "/tmp/stmp_enc.tmp";
97
98 /*
99 * Decode jpeg from `infilename` into dev->decData of dev->decDataSize size.
100 */
decompress(struct device __sane_unused__ *dev, const char __sane_unused__ *infilename)101 static int decompress(struct device __sane_unused__ *dev,
102 const char __sane_unused__ *infilename)
103 {
104 #ifdef HAVE_LIBJPEG
105 int rc;
106 int row_stride, width, height, pixel_size;
107 struct jpeg_decompress_struct cinfo;
108 struct jpeg_error_mgr jerr;
109 unsigned long bmp_size = 0;
110 FILE *pInfile = NULL;
111 JSAMPARRAY buffer;
112
113 if ((pInfile = fopen(infilename, "rb")) == NULL) {
114 fprintf(stderr, "can't open %s\n", infilename);
115 return -1;
116 }
117
118 cinfo.err = jpeg_std_error(&jerr);
119
120 jpeg_create_decompress(&cinfo);
121
122 jpeg_stdio_src(&cinfo, pInfile);
123
124 rc = jpeg_read_header(&cinfo, TRUE);
125 if (rc != 1) {
126 jpeg_destroy_decompress(&cinfo);
127 fclose(pInfile);
128 return -1;
129 }
130
131 jpeg_start_decompress(&cinfo);
132
133 width = cinfo.output_width;
134 height = cinfo.output_height;
135 pixel_size = cinfo.output_components;
136 bmp_size = width * height * pixel_size;
137 assert(bmp_size <= POST_DATASIZE);
138 dev->decDataSize = bmp_size;
139
140 row_stride = width * pixel_size;
141
142 buffer = (*cinfo.mem->alloc_sarray)
143 ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
144
145 while (cinfo.output_scanline < cinfo.output_height) {
146 buffer[0] = dev->decData + \
147 (cinfo.output_scanline) * row_stride;
148 jpeg_read_scanlines(&cinfo, buffer, 1);
149 }
150 jpeg_finish_decompress(&cinfo);
151 jpeg_destroy_decompress(&cinfo);
152 fclose(pInfile);
153 return 0;
154 #else
155 return -1;
156 #endif
157 }
158
159 /* copy from decoded jpeg image (dev->decData) into user's buffer (pDest) */
160 /* returns 0 if there is no data to copy */
copy_decompress_data(struct device *dev, unsigned char *pDest, int maxlen, int *destLen)161 static int copy_decompress_data(struct device *dev, unsigned char *pDest, int maxlen, int *destLen)
162 {
163 int data_size = 0;
164
165 if (destLen)
166 *destLen = 0;
167 if (!dev->decDataSize)
168 return 0;
169 data_size = dev->decDataSize - dev->currentDecDataIndex;
170 if (data_size > maxlen)
171 data_size = maxlen;
172 if (data_size && pDest) {
173 memcpy(pDest, dev->decData + dev->currentDecDataIndex, data_size);
174 if (destLen)
175 *destLen = data_size;
176 dev->currentDecDataIndex += data_size;
177 }
178 if (dev->decDataSize == dev->currentDecDataIndex) {
179 dev->currentDecDataIndex = 0;
180 dev->decDataSize = 0;
181 }
182 return 1;
183 }
184
decompress_tempfile(struct device *dev)185 static int decompress_tempfile(struct device *dev)
186 {
187 decompress(dev, encTmpFileName);
188 remove(encTmpFileName);
189 return 0;
190 }
191
dump_to_tmp_file(struct device *dev)192 static int dump_to_tmp_file(struct device *dev)
193 {
194 unsigned char *pSrc = dev->data;
195 int srcLen = dev->datalen;
196 FILE *pInfile;
197 if ((pInfile = fopen(encTmpFileName, "a")) == NULL) {
198 fprintf(stderr, "can't open %s\n", encTmpFileName);
199 return 0;
200 }
201
202 fwrite(pSrc, 1, srcLen, pInfile);
203 fclose(pInfile);
204 return srcLen;
205 }
206
isSupportedDevice(struct device __sane_unused__ *dev)207 static int isSupportedDevice(struct device __sane_unused__ *dev)
208 {
209 #ifdef HAVE_LIBJPEG
210 /* Checking device which supports JPEG Lossy compression for color scanning*/
211 if (dev->compressionTypes & (1 << 6)) {
212 /* blacklist malfunctioning device(s) */
213 if (!strncmp(dev->sane.model, "SCX-4500W", 9) ||
214 !strncmp(dev->sane.model, "C460", 4) ||
215 !!strstr(dev->sane.model, "CLX-3170") ||
216 !!strstr(dev->sane.model, "4x24") ||
217 !!strstr(dev->sane.model, "4x28") ||
218 !strncmp(dev->sane.model, "M288x", 5))
219 return 0;
220 return 1;
221 } else
222 return 0;
223 #else
224 return 0;
225 #endif
226 }
227
isJPEGEnabled(struct device __sane_unused__ *dev)228 static int isJPEGEnabled(struct device __sane_unused__ *dev)
229 {
230 return isSupportedDevice(dev) && dev->compressionEnabled;
231 }
232
dbg_dump(struct device *dev)233 static void dbg_dump(struct device *dev)
234 {
235 int i;
236 char dbuf[MAX_DUMP * 3 + 1], *dptr = dbuf;
237 int nzlen = dev->reslen;
238 int dlen = MIN(dev->reslen, MAX_DUMP);
239
240 for (i = dev->reslen - 1; i >= 0; i--, nzlen--)
241 if (dev->res[i] != 0)
242 break;
243
244 dlen = MIN(dlen, nzlen + 1);
245
246 for (i = 0; i < dlen; i++, dptr += 3)
247 sprintf(dptr, " %02x", dev->res[i]);
248
249 DBG(5, "[%lu]%s%s\n", (u_long)dev->reslen, dbuf,
250 (dlen < (int)dev->reslen)? "..." : "");
251 }
252
253 /* one command to device */
254 /* return 0: on error, 1: success */
dev_command(struct device *dev, SANE_Byte *cmd, size_t reqlen)255 static int dev_command(struct device *dev, SANE_Byte *cmd, size_t reqlen)
256 {
257 SANE_Status status;
258 size_t sendlen = cmd[3] + 4;
259 SANE_Byte *res = dev->res;
260
261
262 assert(reqlen <= sizeof(dev->res)); /* requested len */
263 dev->reslen = sizeof(dev->res); /* doing full buffer to flush stalled commands */
264
265 if (cmd[2] == CMD_SET_WINDOW) {
266 /* Set Window have wrong packet length, huh. */
267 sendlen = 25;
268 }
269
270 if (cmd[2] == CMD_READ_IMAGE) {
271 /* Read Image is raw data, don't need to read response */
272 res = NULL;
273 }
274
275 dev->state = 0;
276 DBG(4, ":: dev_command(%s[%#x], %lu)\n", str_cmd(cmd[2]), cmd[2],
277 (u_long)reqlen);
278 status = dev->io->dev_request(dev, cmd, sendlen, res, &dev->reslen);
279 if (status != SANE_STATUS_GOOD) {
280 DBG(1, "%s: dev_request: %s\n", __func__, sane_strstatus(status));
281 dev->state = SANE_STATUS_IO_ERROR;
282 return 0;
283 }
284
285 if (!res) {
286 /* if not need response just return success */
287 return 1;
288 }
289
290 /* normal command reply, some sanity checking */
291 if (dev->reslen < reqlen) {
292 DBG(1, "%s: illegal response len %lu, need %lu\n",
293 __func__, (u_long)dev->reslen, (u_long)reqlen);
294 dev->state = SANE_STATUS_IO_ERROR;
295 return 0;
296 } else {
297 size_t pktlen; /* len specified in packet */
298
299 if (DBG_LEVEL > 3)
300 dbg_dump(dev);
301
302 if (dev->res[0] != RES_CODE) {
303 DBG(2, "%s: illegal data header %02x\n", __func__, dev->res[0]);
304 dev->state = SANE_STATUS_IO_ERROR;
305 return 0;
306 }
307 pktlen = dev->res[2] + 3;
308 if (dev->reslen != pktlen) {
309 DBG(2, "%s: illegal response len %lu, should be %lu\n",
310 __func__, (u_long)pktlen, (u_long)dev->reslen);
311 dev->state = SANE_STATUS_IO_ERROR;
312 return 0;
313 }
314 if (dev->reslen > reqlen)
315 DBG(2, "%s: too big packet len %lu, need %lu\n",
316 __func__, (u_long)dev->reslen, (u_long)reqlen);
317 }
318
319 dev->state = 0;
320 if (cmd[2] == CMD_SET_WINDOW ||
321 cmd[2] == CMD_OBJECT_POSITION ||
322 cmd[2] == CMD_READ ||
323 cmd[2] == CMD_RESERVE_UNIT) {
324 if (dev->res[1] == STATUS_BUSY)
325 dev->state = SANE_STATUS_DEVICE_BUSY;
326 else if (dev->res[1] == STATUS_CANCEL)
327 dev->state = SANE_STATUS_CANCELLED;
328 else if (dev->res[1] == STATUS_CHECK)
329 dev->state = resolv_state((cmd[2] == CMD_READ)?
330 (dev->res[12] << 8 | dev->res[13]) :
331 (dev->res[4] << 8 | dev->res[5]));
332
333 if (dev->state)
334 DBG(3, "%s(%s[%#x]): => %d: %s\n",
335 __func__, str_cmd(cmd[2]), cmd[2],
336 dev->state, sane_strstatus(dev->state));
337 }
338
339 return 1;
340 }
341
342 /* one short command to device */
dev_cmd(struct device *dev, SANE_Byte command)343 static int dev_cmd(struct device *dev, SANE_Byte command)
344 {
345 SANE_Byte cmd[4] = { REQ_CODE_A, REQ_CODE_B };
346 cmd[2] = command;
347 return dev_command(dev, cmd, (command == CMD_INQUIRY)? 70 : 32);
348 }
349
350 /* stop scanning operation. return previous status */
dev_stop(struct device *dev)351 static SANE_Status dev_stop(struct device *dev)
352 {
353 int state = dev->state;
354
355 DBG(3, "%s: %p, scanning %d, reserved %d\n", __func__,
356 (void *)dev, dev->scanning, dev->reserved);
357 dev->scanning = 0;
358
359 /* release */
360 if (!dev->reserved)
361 return state;
362 dev->reserved = 0;
363 dev_cmd(dev, CMD_RELEASE_UNIT);
364 DBG(3, "total image %d*%d size %d (win %d*%d), %d*%d %d data: %d, out %d bytes\n",
365 dev->para.pixels_per_line, dev->para.lines,
366 dev->total_img_size,
367 dev->win_width, dev->win_len,
368 dev->pixels_per_line, dev->ulines, dev->blocks,
369 dev->total_data_size, dev->total_out_size);
370 dev->state = state;
371 return state;
372 }
373
ret_cancel(struct device *dev, SANE_Status ret)374 SANE_Status ret_cancel(struct device *dev, SANE_Status ret)
375 {
376 dev_cmd(dev, CMD_ABORT);
377 if (dev->scanning) {
378 dev_stop(dev);
379 dev->state = SANE_STATUS_CANCELLED;
380 }
381 return ret;
382 }
383
cancelled(struct device *dev)384 static int cancelled(struct device *dev)
385 {
386 if (dev->cancel)
387 return ret_cancel(dev, 1);
388 return 0;
389 }
390
391 /* issue command and wait until scanner is not busy */
392 /* return 0 on error/blocking, 1 is ok and ready */
dev_cmd_wait(struct device *dev, int cmd)393 static int dev_cmd_wait(struct device *dev, int cmd)
394 {
395 int sleeptime = 10;
396
397 do {
398 if (cancelled(dev))
399 return 0;
400 if (!dev_cmd(dev, cmd)) {
401 dev->state = SANE_STATUS_IO_ERROR;
402 return 0;
403 } else if (dev->state) {
404 if (dev->state != SANE_STATUS_DEVICE_BUSY)
405 return 0;
406 else {
407 if (dev->non_blocking) {
408 dev->state = SANE_STATUS_GOOD;
409 return 0;
410 } else {
411 if (sleeptime > 1000)
412 sleeptime = 1000;
413 DBG(4, "(%s) sleeping(%d ms).. [%x %x]\n",
414 str_cmd(cmd), sleeptime, dev->res[4], dev->res[5]);
415 usleep(sleeptime * 1000);
416 if (sleeptime < 1000)
417 sleeptime *= (sleeptime < 100)? 10 : 2;
418 }
419 } /* BUSY */
420 }
421 } while (dev->state == SANE_STATUS_DEVICE_BUSY);
422
423 return 1;
424 }
425
426 static int inq_dpi_bits[] = {
427 75, 150, 0, 0,
428 200, 300, 0, 0,
429 600, 0, 0, 1200,
430 100, 0, 0, 2400,
431 0, 4800, 0, 9600
432 };
433
434 static int res_dpi_codes[] = {
435 75, 0, 150, 0,
436 0, 300, 0, 600,
437 1200, 200, 100, 2400,
438 4800, 9600
439 };
440
SANE_Word_sort(const void *a, const void *b)441 static int SANE_Word_sort(const void *a, const void *b)
442 {
443 return *(const SANE_Word *)a - *(const SANE_Word *)b;
444 }
445
446 /* resolve inquired dpi list to dpi_list array */
resolv_inq_dpi(struct device *dev)447 static void resolv_inq_dpi(struct device *dev)
448 {
449 unsigned int i;
450 int res = dev->resolutions;
451
452 assert(sizeof(inq_dpi_bits) < sizeof(dev->dpi_list));
453 for (i = 0; i < sizeof(inq_dpi_bits) / sizeof(int); i++)
454 if (inq_dpi_bits[i] && (res & (1 << i)))
455 dev->dpi_list[++dev->dpi_list[0]] = inq_dpi_bits[i];
456 qsort(&dev->dpi_list[1], dev->dpi_list[0], sizeof(SANE_Word), SANE_Word_sort);
457 }
458
dpi_to_code(int dpi)459 static unsigned int dpi_to_code(int dpi)
460 {
461 unsigned int i;
462
463 for (i = 0; i < sizeof(res_dpi_codes) / sizeof(int); i++) {
464 if (dpi == res_dpi_codes[i])
465 return i;
466 }
467 return 0;
468 }
469
string_match_index(const SANE_String_Const s[], SANE_String m)470 static int string_match_index(const SANE_String_Const s[], SANE_String m)
471 {
472 int i;
473
474 for (i = 0; *s; i++) {
475 SANE_String_Const x = *s++;
476 if (strcasecmp(x, m) == 0)
477 return i;
478 }
479 return 0;
480 }
481
string_match(const SANE_String_Const s[], SANE_String m)482 static SANE_String string_match(const SANE_String_Const s[], SANE_String m)
483 {
484 return UNCONST(s[string_match_index(s, m)]);
485 }
486
max_string_size(SANE_String_Const s[])487 static size_t max_string_size(SANE_String_Const s[])
488 {
489 size_t max = 0;
490
491 while (*s) {
492 size_t size = strlen(*s++) + 1;
493 if (size > max)
494 max = size;
495 }
496 return max;
497 }
498
499 static SANE_String_Const doc_sources[] = {
500 "Flatbed", "ADF", "Auto", NULL
501 };
502
503 static int doc_source_to_code[] = {
504 0x40, 0x20, 0x80
505 };
506
507 static SANE_String_Const scan_modes[] = {
508 SANE_VALUE_SCAN_MODE_LINEART,
509 SANE_VALUE_SCAN_MODE_HALFTONE,
510 SANE_VALUE_SCAN_MODE_GRAY,
511 SANE_VALUE_SCAN_MODE_COLOR,
512 NULL
513 };
514
515 static int scan_mode_to_code[] = {
516 0x00, 0x01, 0x03, 0x05
517 };
518
519 static SANE_Range threshold = {
520 SANE_FIX(30), SANE_FIX(70), SANE_FIX(10)
521 };
522
reset_options(struct device *dev)523 static void reset_options(struct device *dev)
524 {
525 dev->val[OPT_RESOLUTION].w = 150;
526 dev->val[OPT_MODE].s = string_match(scan_modes, SANE_VALUE_SCAN_MODE_COLOR);
527
528 /* if docs loaded in adf use it as default source, flatbed otherwise */
529 dev->val[OPT_SOURCE].s = UNCONST(doc_sources[(dev->doc_loaded)? 1 : 0]);
530
531 dev->val[OPT_THRESHOLD].w = SANE_FIX(50);
532
533 /* this is reported maximum window size, will be fixed later */
534 dev->win_x_range.min = SANE_FIX(0);
535 dev->win_x_range.max = SANE_FIX((double)dev->max_win_width / PNT_PER_MM);
536 dev->win_x_range.quant = SANE_FIX(1);
537 dev->win_y_range.min = SANE_FIX(0);
538 dev->win_y_range.max = SANE_FIX((double)dev->max_win_len / PNT_PER_MM);
539 dev->win_y_range.quant = SANE_FIX(1);
540 dev->val[OPT_SCAN_TL_X].w = dev->win_x_range.min;
541 dev->val[OPT_SCAN_TL_Y].w = dev->win_y_range.min;
542 dev->val[OPT_SCAN_BR_X].w = dev->win_x_range.max;
543 dev->val[OPT_SCAN_BR_Y].w = dev->win_y_range.max;
544 }
545
init_options(struct device *dev)546 static void init_options(struct device *dev)
547 {
548 int i;
549
550 for (i = 0; i < NUM_OPTIONS; i++) {
551 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
552 dev->opt[i].size = sizeof(SANE_Word);
553 dev->opt[i].type = SANE_TYPE_FIXED;
554 dev->val[i].s = NULL;
555 }
556
557 dev->opt[OPT_NUMOPTIONS].name = SANE_NAME_NUM_OPTIONS;
558 dev->opt[OPT_NUMOPTIONS].title = SANE_TITLE_NUM_OPTIONS;
559 dev->opt[OPT_NUMOPTIONS].desc = SANE_DESC_NUM_OPTIONS;
560 dev->opt[OPT_NUMOPTIONS].type = SANE_TYPE_INT;
561 dev->opt[OPT_NUMOPTIONS].cap = SANE_CAP_SOFT_DETECT;
562 dev->val[OPT_NUMOPTIONS].w = NUM_OPTIONS;
563
564 dev->opt[OPT_GROUP_STD].name = SANE_NAME_STANDARD;
565 dev->opt[OPT_GROUP_STD].title = SANE_TITLE_STANDARD;
566 dev->opt[OPT_GROUP_STD].desc = SANE_DESC_STANDARD;
567 dev->opt[OPT_GROUP_STD].type = SANE_TYPE_GROUP;
568 dev->opt[OPT_GROUP_STD].cap = 0;
569
570 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
571 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
572 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
573 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
574 dev->opt[OPT_RESOLUTION].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
575 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
576 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
577 dev->opt[OPT_RESOLUTION].constraint.word_list = dev->dpi_list;
578
579 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
580 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
581 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
582 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
583 dev->opt[OPT_MODE].size = max_string_size(scan_modes);
584 dev->opt[OPT_MODE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
585 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
586 dev->opt[OPT_MODE].constraint.string_list = scan_modes;
587
588 dev->opt[OPT_THRESHOLD].name = SANE_NAME_HIGHLIGHT;
589 dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
590 dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
591 dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT;
592 dev->opt[OPT_THRESHOLD].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
593 dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
594 dev->opt[OPT_THRESHOLD].constraint.range = &threshold;
595
596 dev->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
597 dev->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
598 dev->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
599 dev->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
600 dev->opt[OPT_SOURCE].size = max_string_size(doc_sources);
601 dev->opt[OPT_SOURCE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
602 dev->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
603 dev->opt[OPT_SOURCE].constraint.string_list = doc_sources;
604
605 dev->opt[OPT_JPEG].name = "jpeg";
606 dev->opt[OPT_JPEG].title = SANE_I18N("jpeg compression");
607 dev->opt[OPT_JPEG].desc = SANE_I18N("JPEG Image Compression");
608 dev->opt[OPT_JPEG].unit = SANE_UNIT_NONE;
609 dev->opt[OPT_JPEG].type = SANE_TYPE_BOOL;
610 dev->opt[OPT_JPEG].cap |= SANE_CAP_ADVANCED;
611 #ifdef HAVE_LIBJPEG
612 dev->compressionEnabled = SANE_TRUE;
613 if (!isSupportedDevice(dev))
614 dev->opt[OPT_JPEG].cap |= SANE_CAP_INACTIVE;
615 dev->val[OPT_JPEG].b = SANE_TRUE;
616 #else
617 dev->opt[OPT_JPEG].cap |= SANE_CAP_INACTIVE;
618 dev->val[OPT_JPEG].b = SANE_FALSE;
619 #endif
620
621 dev->opt[OPT_GROUP_GEO].name = SANE_NAME_GEOMETRY;
622 dev->opt[OPT_GROUP_GEO].title = SANE_TITLE_GEOMETRY;
623 dev->opt[OPT_GROUP_GEO].desc = SANE_DESC_GEOMETRY;
624 dev->opt[OPT_GROUP_GEO].type = SANE_TYPE_GROUP;
625 dev->opt[OPT_GROUP_GEO].cap = 0;
626
627 dev->opt[OPT_SCAN_TL_X].name = SANE_NAME_SCAN_TL_X;
628 dev->opt[OPT_SCAN_TL_X].title = SANE_TITLE_SCAN_TL_X;
629 dev->opt[OPT_SCAN_TL_X].desc = SANE_DESC_SCAN_TL_X;
630 dev->opt[OPT_SCAN_TL_X].unit = SANE_UNIT_MM;
631 dev->opt[OPT_SCAN_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
632 dev->opt[OPT_SCAN_TL_X].constraint.range = &dev->win_x_range;
633
634 dev->opt[OPT_SCAN_TL_Y].name = SANE_NAME_SCAN_TL_Y;
635 dev->opt[OPT_SCAN_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
636 dev->opt[OPT_SCAN_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
637 dev->opt[OPT_SCAN_TL_Y].unit = SANE_UNIT_MM;
638 dev->opt[OPT_SCAN_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
639 dev->opt[OPT_SCAN_TL_Y].constraint.range = &dev->win_y_range;
640
641 dev->opt[OPT_SCAN_BR_X].name = SANE_NAME_SCAN_BR_X;
642 dev->opt[OPT_SCAN_BR_X].title = SANE_TITLE_SCAN_BR_X;
643 dev->opt[OPT_SCAN_BR_X].desc = SANE_DESC_SCAN_BR_X;
644 dev->opt[OPT_SCAN_BR_X].unit = SANE_UNIT_MM;
645 dev->opt[OPT_SCAN_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
646 dev->opt[OPT_SCAN_BR_X].constraint.range = &dev->win_x_range;
647
648 dev->opt[OPT_SCAN_BR_Y].name = SANE_NAME_SCAN_BR_Y;
649 dev->opt[OPT_SCAN_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
650 dev->opt[OPT_SCAN_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
651 dev->opt[OPT_SCAN_BR_Y].unit = SANE_UNIT_MM;
652 dev->opt[OPT_SCAN_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
653 dev->opt[OPT_SCAN_BR_Y].constraint.range = &dev->win_y_range;
654 }
655
656 /* fill parameters from options */
set_parameters(struct device *dev)657 static void set_parameters(struct device *dev)
658 {
659 double px_to_len;
660
661 dev->para.last_frame = SANE_TRUE;
662 dev->para.lines = -1;
663 px_to_len = 1200.0 / dev->val[OPT_RESOLUTION].w;
664 #define BETTER_BASEDPI 1
665 /* tests prove that 1200dpi base is very inexact
666 * so I calculated better values for each axis */
667 #if BETTER_BASEDPI
668 px_to_len = 1180.0 / dev->val[OPT_RESOLUTION].w;
669 #endif
670 dev->para.pixels_per_line = dev->win_width / px_to_len;
671 dev->para.bytes_per_line = dev->para.pixels_per_line;
672
673 DBG(5, dev->val[OPT_JPEG].b ? "JPEG compression enabled\n" : "JPEG compression disabled\n" );
674 dev->compressionEnabled = dev->val[OPT_JPEG].b;
675
676 if (!isJPEGEnabled(dev)) {
677 #if BETTER_BASEDPI
678 px_to_len = 1213.9 / dev->val[OPT_RESOLUTION].w;
679 #endif
680 }
681 dev->para.lines = dev->win_len / px_to_len;
682 if (dev->composition == MODE_LINEART ||
683 dev->composition == MODE_HALFTONE) {
684 dev->para.format = SANE_FRAME_GRAY;
685 dev->para.depth = 1;
686 dev->para.bytes_per_line = (dev->para.pixels_per_line + 7) / 8;
687 } else if (dev->composition == MODE_GRAY8) {
688 dev->para.format = SANE_FRAME_GRAY;
689 dev->para.depth = 8;
690 dev->para.bytes_per_line = dev->para.pixels_per_line;
691 } else if (dev->composition == MODE_RGB24) {
692 dev->para.format = SANE_FRAME_RGB;
693 dev->para.depth = 8;
694 dev->para.bytes_per_line *= 3;
695 } else {
696 /* this will never happen */
697 DBG(1, "%s: impossible image composition %d\n",
698 __func__, dev->composition);
699 dev->para.format = SANE_FRAME_GRAY;
700 dev->para.depth = 8;
701 }
702 }
703
704 /* resolve all options related to scan window */
705 /* called after option changed and in set_window */
fix_window(struct device *dev)706 static int fix_window(struct device *dev)
707 {
708 double win_width_mm, win_len_mm;
709 int i;
710 int threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w);
711
712 dev->resolution = dpi_to_code(dev->val[OPT_RESOLUTION].w);
713 dev->composition = scan_mode_to_code[string_match_index(scan_modes, dev->val[OPT_MODE].s)];
714
715 if (dev->composition == MODE_LINEART ||
716 dev->composition == MODE_HALFTONE) {
717 dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
718 } else {
719 dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
720 }
721 if (threshold < 30) {
722 dev->val[OPT_THRESHOLD].w = SANE_FIX(30);
723 } else if (threshold > 70) {
724 dev->val[OPT_THRESHOLD].w = SANE_FIX(70);
725 }
726 threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w);
727 dev->threshold = (threshold - 30) / 10;
728 dev->val[OPT_THRESHOLD].w = SANE_FIX(dev->threshold * 10 + 30);
729
730 dev->doc_source = doc_source_to_code[string_match_index(doc_sources, dev->val[OPT_SOURCE].s)];
731
732 /* max window len is dependent of document source */
733 if (dev->doc_source == DOC_FLATBED ||
734 (dev->doc_source == DOC_AUTO && !dev->doc_loaded))
735 dev->max_len = dev->max_len_fb;
736 else
737 dev->max_len = dev->max_len_adf;
738
739 /* parameters */
740 dev->win_y_range.max = SANE_FIX((double)dev->max_len / PNT_PER_MM);
741
742 /* window sanity checking */
743 for (i = OPT_SCAN_TL_X; i <= OPT_SCAN_BR_Y; i++) {
744 if (dev->val[i].w < dev->opt[i].constraint.range->min)
745 dev->val[i].w = dev->opt[i].constraint.range->min;
746 if (dev->val[i].w > dev->opt[i].constraint.range->max)
747 dev->val[i].w = dev->opt[i].constraint.range->max;
748 }
749
750 if (dev->val[OPT_SCAN_TL_X].w > dev->val[OPT_SCAN_BR_X].w)
751 SWAP_Word(dev->val[OPT_SCAN_TL_X].w, dev->val[OPT_SCAN_BR_X].w);
752 if (dev->val[OPT_SCAN_TL_Y].w > dev->val[OPT_SCAN_BR_Y].w)
753 SWAP_Word(dev->val[OPT_SCAN_TL_Y].w, dev->val[OPT_SCAN_BR_Y].w);
754
755 /* recalculate millimeters to inches */
756 dev->win_off_x = SANE_UNFIX(dev->val[OPT_SCAN_TL_X].w) / MM_PER_INCH;
757 dev->win_off_y = SANE_UNFIX(dev->val[OPT_SCAN_TL_Y].w) / MM_PER_INCH;
758
759 /* calc win size in mm */
760 win_width_mm = SANE_UNFIX(dev->val[OPT_SCAN_BR_X].w) -
761 SANE_UNFIX(dev->val[OPT_SCAN_TL_X].w);
762 win_len_mm = SANE_UNFIX(dev->val[OPT_SCAN_BR_Y].w) -
763 SANE_UNFIX(dev->val[OPT_SCAN_TL_Y].w);
764 /* convert mm to 1200 dpi points */
765 dev->win_width = (int)(win_width_mm * PNT_PER_MM);
766 dev->win_len = (int)(win_len_mm * PNT_PER_MM);
767
768 /* don't scan if window is zero size */
769 if (!dev->win_width || !dev->win_len) {
770 /* "The scan cannot be started with the current set of options." */
771 dev->state = SANE_STATUS_INVAL;
772 return 0;
773 }
774
775 return 1;
776 }
777
dev_set_window(struct device *dev)778 static int dev_set_window(struct device *dev)
779 {
780 SANE_Byte cmd[0x19] = {
781 REQ_CODE_A, REQ_CODE_B, CMD_SET_WINDOW, 0x13, MSG_SCANNING_PARAM
782 };
783
784 if (!fix_window(dev))
785 return 0;
786
787 cmd[0x05] = dev->win_width >> 24;
788 cmd[0x06] = dev->win_width >> 16;
789 cmd[0x07] = dev->win_width >> 8;
790 cmd[0x08] = dev->win_width;
791 cmd[0x09] = dev->win_len >> 24;
792 cmd[0x0a] = dev->win_len >> 16;
793 cmd[0x0b] = dev->win_len >> 8;
794 cmd[0x0c] = dev->win_len;
795 cmd[0x0d] = dev->resolution; /* x */
796 cmd[0x0e] = dev->resolution; /* y */
797 cmd[0x0f] = (SANE_Byte)floor(dev->win_off_x);
798 cmd[0x10] = (SANE_Byte)((dev->win_off_x - floor(dev->win_off_x)) * 100);
799 cmd[0x11] = (SANE_Byte)floor(dev->win_off_y);
800 cmd[0x12] = (SANE_Byte)((dev->win_off_y - floor(dev->win_off_y)) * 100);
801 cmd[0x13] = dev->composition;
802 /* Set to JPEG Lossy Compression, if mode is color (only for supported model)...
803 * else go with Uncompressed (For backard compatibility with old models )*/
804 if (dev->composition == MODE_RGB24) {
805 if (isJPEGEnabled(dev)) {
806 cmd[0x14] = 0x6;
807 }
808 }
809 cmd[0x16] = dev->threshold;
810 cmd[0x17] = dev->doc_source;
811
812 DBG(5, "OFF xi: %02x%02x yi: %02x%02x,"
813 " WIN xp: %02x%02x%02x%02x yp %02x%02x%02x%02x,"
814 " MAX %08x %08x\n",
815 cmd[0x0f], cmd[0x10], cmd[0x11], cmd[0x12],
816 cmd[0x05], cmd[0x06], cmd[0x07], cmd[0x08],
817 cmd[0x09], cmd[0x0a], cmd[0x0b], cmd[0x0c],
818 dev->max_win_width, dev->max_win_len);
819
820 return dev_command(dev, cmd, 32);
821 }
822
823 static SANE_Status
dev_inquiry(struct device *dev)824 dev_inquiry(struct device *dev)
825 {
826 SANE_Byte *ptr;
827 SANE_Char *optr, *xptr;
828
829 if (!dev_cmd(dev, CMD_INQUIRY))
830 return SANE_STATUS_IO_ERROR;
831 ptr = dev->res;
832 if (ptr[3] != MSG_PRODUCT_INFO) {
833 DBG(1, "%s: illegal INQUIRY response %02x\n", __func__, ptr[3]);
834 return SANE_STATUS_IO_ERROR;
835 }
836
837 /* parse reported manufacturer/product names */
838 dev->sane.vendor = optr = (SANE_Char *) malloc(33);
839 for (ptr += 4; ptr < &dev->res[0x24] && *ptr && *ptr != ' ';)
840 *optr++ = *ptr++;
841 *optr++ = 0;
842
843 for (; ptr < &dev->res[0x24] && (!*ptr || *ptr == ' '); ptr++)
844 /* skip spaces */;
845
846 dev->sane.model = optr = (SANE_Char *) malloc(33);
847 xptr = optr; /* is last non space character + 1 */
848 for (; ptr < &dev->res[0x24] && *ptr;) {
849 if (*ptr != ' ')
850 xptr = optr + 1;
851 *optr++ = *ptr++;
852 }
853 *optr++ = 0;
854 *xptr = 0;
855
856 DBG(1, "%s: found %s/%s\n", __func__, dev->sane.vendor, dev->sane.model);
857 dev->sane.type = strdup("multi-function peripheral");
858
859 dev->resolutions = dev->res[0x37] << 16 |
860 dev->res[0x24] << 8 |
861 dev->res[0x25];
862 dev->compositions = dev->res[0x27];
863 dev->max_win_width = dev->res[0x28] << 24 |
864 dev->res[0x29] << 16 |
865 dev->res[0x2a] << 8 |
866 dev->res[0x2b];
867 dev->max_win_len = dev->res[0x2c] << 24 |
868 dev->res[0x2d] << 16 |
869 dev->res[0x2e] << 8 |
870 dev->res[0x2f];
871 dev->max_len_adf = dev->res[0x38] << 24 |
872 dev->res[0x39] << 16 |
873 dev->res[0x3a] << 8 |
874 dev->res[0x3b];
875 dev->max_len_fb = dev->res[0x3c] << 24 |
876 dev->res[0x3d] << 16 |
877 dev->res[0x3e] << 8 |
878 dev->res[0x3f];
879 dev->line_order = dev->res[0x31];
880 dev->compressionTypes = dev->res[0x32];
881 dev->doc_loaded = (dev->res[0x35] == 0x02) &&
882 (dev->res[0x26] & 0x03);
883
884 init_options(dev);
885 reset_options(dev);
886 fix_window(dev);
887 set_parameters(dev);
888 resolv_inq_dpi(dev);
889
890 return SANE_STATUS_GOOD;
891 }
892
893 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle h, SANE_Int opt)894 sane_get_option_descriptor(SANE_Handle h, SANE_Int opt)
895 {
896 struct device *dev = h;
897
898 DBG(3, "%s: %p, %d\n", __func__, h, opt);
899 if (opt >= NUM_OPTIONS || opt < 0)
900 return NULL;
901 return &dev->opt[opt];
902 }
903
904 SANE_Status
sane_control_option(SANE_Handle h, SANE_Int opt, SANE_Action act, void *val, SANE_Word *info)905 sane_control_option(SANE_Handle h, SANE_Int opt, SANE_Action act,
906 void *val, SANE_Word *info)
907 {
908 struct device *dev = h;
909
910 DBG(3, "%s: %p, %d, <%d>, %p, %p\n", __func__, h, opt, act, val, (void *)info);
911 if (!dev || opt >= NUM_OPTIONS || opt < 0)
912 return SANE_STATUS_INVAL;
913
914 if (info)
915 *info = 0;
916
917 if (act == SANE_ACTION_GET_VALUE) { /* GET */
918 if (dev->opt[opt].type == SANE_TYPE_STRING)
919 strcpy(val, dev->val[opt].s);
920 else
921 *(SANE_Word *)val = dev->val[opt].w;
922 } else if (act == SANE_ACTION_SET_VALUE) { /* SET */
923 SANE_Parameters xpara = dev->para;
924 SANE_Option_Descriptor xopt[NUM_OPTIONS];
925 Option_Value xval[NUM_OPTIONS];
926 int i;
927
928 if (dev->opt[opt].constraint_type == SANE_CONSTRAINT_STRING_LIST) {
929 dev->val[opt].s = string_match(dev->opt[opt].constraint.string_list, val);
930 if (info && strcasecmp(dev->val[opt].s, val))
931 *info |= SANE_INFO_INEXACT;
932 } else if (opt == OPT_RESOLUTION)
933 dev->val[opt].w = res_dpi_codes[dpi_to_code(*(SANE_Word *)val)];
934 else
935 dev->val[opt].w = *(SANE_Word *)val;
936
937 memcpy(&xopt, &dev->opt, sizeof(xopt));
938 memcpy(&xval, &dev->val, sizeof(xval));
939 fix_window(dev);
940 set_parameters(dev);
941
942 /* check for side effects */
943 if (info) {
944 if (memcmp(&xpara, &dev->para, sizeof(xpara)))
945 *info |= SANE_INFO_RELOAD_PARAMS;
946 if (memcmp(&xopt, &dev->opt, sizeof(xopt)))
947 *info |= SANE_INFO_RELOAD_OPTIONS;
948 for (i = 0; i < NUM_OPTIONS; i++)
949 if (xval[i].w != dev->val[i].w) {
950 if (i == opt)
951 *info |= SANE_INFO_INEXACT;
952 else
953 *info |= SANE_INFO_RELOAD_OPTIONS;
954 }
955 }
956 }
957
958 DBG(4, "%s: %d, <%d> => %08x, %x\n", __func__, opt, act,
959 val? *(SANE_Word *)val : 0, info? *info : 0);
960 return SANE_STATUS_GOOD;
961 }
962
963 static void
dev_free(struct device *dev)964 dev_free(struct device *dev)
965 {
966 if (!dev)
967 return;
968
969 if (dev->sane.name)
970 free(UNCONST(dev->sane.name));
971 if (dev->sane.vendor)
972 free(UNCONST(dev->sane.vendor));
973 if (dev->sane.model)
974 free(UNCONST(dev->sane.model));
975 if (dev->sane.type)
976 free(UNCONST(dev->sane.type));
977 if (dev->data)
978 free(dev->data);
979 if (dev->decData) {
980 free(dev->decData);
981 dev->decData = NULL;
982 }
983 memset(dev, 0, sizeof(*dev));
984 free(dev);
985 }
986
987 static void
free_devices(void)988 free_devices(void)
989 {
990 struct device *next;
991 struct device *dev;
992
993 if (devlist) {
994 free(devlist);
995 devlist = NULL;
996 }
997 for (dev = devices_head; dev; dev = next) {
998 next = dev->next;
999 dev_free(dev);
1000 }
1001 devices_head = NULL;
1002 }
1003
tr_from_devname(SANE_String_Const devname)1004 static transport *tr_from_devname(SANE_String_Const devname)
1005 {
1006 if (strncmp("tcp", devname, 3) == 0)
1007 return &available_transports[TRANSPORT_TCP];
1008 return &available_transports[TRANSPORT_USB];
1009 }
1010
1011 static SANE_Status
list_one_device(SANE_String_Const devname)1012 list_one_device(SANE_String_Const devname)
1013 {
1014 struct device *dev;
1015 SANE_Status status;
1016 transport *tr;
1017
1018 DBG(4, "%s: %s\n", __func__, devname);
1019
1020 for (dev = devices_head; dev; dev = dev->next) {
1021 if (strcmp(dev->sane.name, devname) == 0)
1022 return SANE_STATUS_GOOD;
1023 }
1024
1025 tr = tr_from_devname(devname);
1026
1027 dev = calloc(1, sizeof(struct device));
1028 if (dev == NULL)
1029 return SANE_STATUS_NO_MEM;
1030
1031 dev->sane.name = strdup(devname);
1032 dev->io = tr;
1033 status = tr->dev_open(dev);
1034 if (status != SANE_STATUS_GOOD) {
1035 dev_free(dev);
1036 return status;
1037 }
1038
1039 /* status = dev_cmd (dev, CMD_ABORT);*/
1040 status = dev_inquiry(dev);
1041 tr->dev_close(dev);
1042 if (status != SANE_STATUS_GOOD) {
1043 DBG(1, "%s: dev_inquiry(%s): %s\n", __func__,
1044 dev->sane.name, sane_strstatus(status));
1045 dev_free(dev);
1046 return status;
1047 }
1048
1049 /* good device, add it to list */
1050 dev->next = devices_head;
1051 devices_head = dev;
1052 return SANE_STATUS_GOOD;
1053 }
1054
1055 /* SANE API ignores return code of this callback */
1056 static SANE_Status
list_conf_devices(SANEI_Config __sane_unused__ *config, const char *devname, void __sane_unused__ *data)1057 list_conf_devices(SANEI_Config __sane_unused__ *config, const char *devname,
1058 void __sane_unused__ *data)
1059 {
1060 return tr_from_devname(devname)->configure_device(devname, list_one_device);
1061 }
1062
1063 SANE_Status
sane_init(SANE_Int *version_code, SANE_Auth_Callback cb)1064 sane_init(SANE_Int *version_code, SANE_Auth_Callback cb)
1065 {
1066 DBG_INIT();
1067 DBG(2, "sane_init: Xerox backend (build %d), version %s null, authorize %s null\n", BACKEND_BUILD,
1068 (version_code) ? "!=" : "==", (cb) ? "!=" : "==");
1069
1070 if (version_code)
1071 *version_code = SANE_VERSION_CODE(SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BACKEND_BUILD);
1072
1073 sanei_usb_init();
1074 return SANE_STATUS_GOOD;
1075 }
1076
1077 void
sane_exit(void)1078 sane_exit(void)
1079 {
1080 struct device *dev;
1081
1082 for (dev = devices_head; dev; dev = dev->next)
1083 if (dev->dn != -1)
1084 sane_close(dev); /* implies flush */
1085
1086 free_devices();
1087 }
1088
1089 SANE_Status
sane_get_devices(const SANE_Device *** device_list, SANE_Bool local)1090 sane_get_devices(const SANE_Device *** device_list, SANE_Bool local)
1091 {
1092 SANEI_Config config;
1093 struct device *dev;
1094 int dev_count;
1095 int i;
1096
1097 DBG(3, "%s: %p, %d\n", __func__, (const void *)device_list, local);
1098
1099 if (devlist) {
1100 if (device_list)
1101 *device_list = devlist;
1102 return SANE_STATUS_GOOD;
1103 }
1104
1105 free_devices();
1106
1107 config.count = 0;
1108 config.descriptors = NULL;
1109 config.values = NULL;
1110 sanei_configure_attach(XEROX_CONFIG_FILE, &config, list_conf_devices, NULL);
1111
1112 for (dev_count = 0, dev = devices_head; dev; dev = dev->next)
1113 dev_count++;
1114
1115 devlist = malloc((dev_count + 1) * sizeof(*devlist));
1116 if (!devlist) {
1117 DBG(1, "%s: malloc: no memory\n", __func__);
1118 return SANE_STATUS_NO_MEM;
1119 }
1120
1121 for (i = 0, dev = devices_head; dev; dev = dev->next)
1122 devlist[i++] = &dev->sane;
1123 devlist[i++] = NULL;
1124
1125 if (device_list)
1126 *device_list = devlist;
1127 return SANE_STATUS_GOOD;
1128 }
1129
1130 void
sane_close(SANE_Handle h)1131 sane_close(SANE_Handle h)
1132 {
1133 struct device *dev = h;
1134
1135 if (!dev)
1136 return;
1137
1138 DBG(3, "%s: %p (%s)\n", __func__, (void *)dev, dev->sane.name);
1139 dev->io->dev_close(dev);
1140 }
1141
1142 SANE_Status
sane_open(SANE_String_Const name, SANE_Handle *h)1143 sane_open(SANE_String_Const name, SANE_Handle *h)
1144 {
1145 struct device *dev;
1146
1147 DBG(3, "%s: '%s'\n", __func__, name);
1148
1149 if (!devlist)
1150 sane_get_devices(NULL, SANE_TRUE);
1151
1152 if (!name || !*name) {
1153 /* special case of empty name: open first available device */
1154 for (dev = devices_head; dev; dev = dev->next) {
1155 if (dev->dn != -1) {
1156 if (sane_open(dev->sane.name, h) == SANE_STATUS_GOOD)
1157 return SANE_STATUS_GOOD;
1158 }
1159 }
1160 } else {
1161 for (dev = devices_head; dev; dev = dev->next) {
1162 if (strcmp(name, dev->sane.name) == 0) {
1163 *h = dev;
1164 return dev->io->dev_open(dev);
1165 }
1166 }
1167 }
1168
1169 return SANE_STATUS_INVAL;
1170 }
1171
1172 SANE_Status
sane_get_parameters(SANE_Handle h, SANE_Parameters *para)1173 sane_get_parameters(SANE_Handle h, SANE_Parameters *para)
1174 {
1175 struct device *dev = h;
1176
1177 DBG(3, "%s: %p, %p\n", __func__, h, (void *)para);
1178 if (!para)
1179 return SANE_STATUS_INVAL;
1180
1181 *para = dev->para;
1182 return SANE_STATUS_GOOD;
1183 }
1184
1185 /* check if image data is ready, and wait if not */
1186 /* 1: image is acquired, 0: error or non_blocking mode */
dev_acquire(struct device *dev)1187 static int dev_acquire(struct device *dev)
1188 {
1189 if (!dev_cmd_wait(dev, CMD_READ))
1190 return 0;
1191
1192 dev->state = SANE_STATUS_GOOD;
1193 dev->vertical = dev->res[0x08] << 8 | dev->res[0x09];
1194 dev->horizontal = dev->res[0x0a] << 8 | dev->res[0x0b];
1195 dev->blocklen = dev->res[4] << 24 |
1196 dev->res[5] << 16 |
1197 dev->res[6] << 8 |
1198 dev->res[7];
1199 dev->final_block = (dev->res[3] == MSG_END_BLOCK)? 1 : 0;
1200
1201 dev->pixels_per_line = dev->horizontal;
1202 dev->bytes_per_line = dev->horizontal;
1203
1204 if (dev->composition == MODE_RGB24)
1205 dev->bytes_per_line *= 3;
1206 else if (dev->composition == MODE_LINEART ||
1207 dev->composition == MODE_HALFTONE)
1208 dev->pixels_per_line *= 8;
1209
1210 DBG(4, "acquiring, size per band v: %d, h: %d, %sblock: %d, slack: %d\n",
1211 dev->vertical, dev->horizontal, dev->final_block? "last " : "",
1212 dev->blocklen, dev->blocklen - (dev->vertical * dev->bytes_per_line));
1213
1214 if (dev->bytes_per_line > DATASIZE) {
1215 DBG(1, "%s: unsupported line size: %d bytes > %d\n",
1216 __func__, dev->bytes_per_line, DATASIZE);
1217 ret_cancel(dev, SANE_STATUS_NO_MEM);
1218 return 0;
1219 }
1220
1221 dev->reading = 0; /* need to issue READ_IMAGE */
1222
1223 dev->dataindex = 0;
1224 dev->datalen = 0;
1225 dev->dataoff = 0;
1226
1227 return 1;
1228 }
1229
fill_slack(struct device *dev, SANE_Byte *buf, int maxlen)1230 static int fill_slack(struct device *dev, SANE_Byte *buf, int maxlen)
1231 {
1232 const int slack = dev->total_img_size - dev->total_out_size;
1233 const int havelen = MIN(slack, maxlen);
1234 int j;
1235
1236 if (havelen <= 0)
1237 return 0;
1238 for (j = 0; j < havelen; j++)
1239 buf[j] = 255;
1240 return havelen;
1241 }
1242
copy_plain_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)1243 static int copy_plain_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)
1244 {
1245 int j;
1246 const int linesize = dev->bytes_per_line;
1247 int k = dev->dataindex;
1248 *olenp = 0;
1249 for (j = 0; j < dev->datalen && *olenp < maxlen; j++, k++) {
1250 const int x = k % linesize;
1251 const int y = k / linesize;
1252 if (y >= dev->vertical)
1253 break; /* slack */
1254 if (x < dev->para.bytes_per_line &&
1255 (y + dev->y_off) < dev->para.lines) {
1256 *buf++ = dev->data[(dev->dataoff + j) & DATAMASK];
1257 (*olenp)++;
1258 }
1259 }
1260 dev->dataindex = k;
1261 return j;
1262 }
1263
1264 /* return: how much data could be freed from cyclic buffer */
1265 /* convert from RRGGBB to RGBRGB */
copy_mix_bands_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)1266 static int copy_mix_bands_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)
1267 {
1268 int j;
1269
1270 const int linesize = dev->bytes_per_line; /* caching real line size */
1271
1272 /* line number of the head of input buffer,
1273 * input buffer is always aligned to whole line */
1274 const int y_off = dev->dataindex / linesize;
1275
1276 int k = dev->dataindex; /* caching current index of input buffer */
1277
1278 /* can only copy as much as full lines we have */
1279 int havelen = dev->datalen / linesize * linesize - k % linesize;
1280
1281 const int bands = 3;
1282 *olenp = 0;
1283
1284 /* while we have data && they can receive */
1285 for (j = 0; j < havelen && *olenp < maxlen; j++, k++) {
1286 const int band = (k % bands) * dev->horizontal;
1287 const int x = k % linesize / bands;
1288 const int y = k / linesize - y_off; /* y relative to buffer head */
1289 const int y_rly = y + y_off + dev->y_off; /* global y */
1290
1291 if (x < dev->para.pixels_per_line &&
1292 y_rly < dev->para.lines) {
1293 *buf++ = dev->data[(dev->dataoff + band + x + y * linesize) & DATAMASK];
1294 (*olenp)++;
1295 }
1296 }
1297 dev->dataindex = k;
1298
1299 /* how much full lines are finished */
1300 return (k / linesize - y_off) * linesize;
1301 }
1302
1303 SANE_Status
sane_read(SANE_Handle h, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *lenp)1304 sane_read(SANE_Handle h, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *lenp)
1305 {
1306 SANE_Status status;
1307 struct device *dev = h;
1308
1309 DBG(3, "%s: %p, %p, %d, %p\n", __func__, h, (void *) buf, maxlen, (void *) lenp);
1310
1311 if (lenp)
1312 *lenp = 0;
1313 if (!dev)
1314 return SANE_STATUS_INVAL;
1315
1316 if (!dev->scanning)
1317 return SANE_STATUS_EOF;
1318
1319 /* if there is no data to read or output from buffer */
1320 if (!dev->blocklen && dev->datalen <= PADDING_SIZE) {
1321
1322 /* copying uncompressed data */
1323 if (dev->composition == MODE_RGB24 &&
1324 isJPEGEnabled(dev) &&
1325 dev->decDataSize > 0) {
1326 int diff = dev->total_img_size - dev->total_out_size;
1327 int bufLen = (diff < maxlen) ? diff : maxlen;
1328 if (diff &&
1329 copy_decompress_data(dev, buf, bufLen, lenp)) {
1330 if (lenp)
1331 dev->total_out_size += *lenp;
1332 return SANE_STATUS_GOOD;
1333 }
1334 }
1335
1336 /* and we don't need to acquire next block */
1337 if (dev->final_block) {
1338 int slack = dev->total_img_size - dev->total_out_size;
1339
1340 /* but we may need to fill slack */
1341 if (buf && lenp && slack > 0) {
1342 *lenp = fill_slack(dev, buf, maxlen);
1343 dev->total_out_size += *lenp;
1344 DBG(9, "<> slack: %d, filled: %d, maxlen %d\n",
1345 slack, *lenp, maxlen);
1346 return SANE_STATUS_GOOD;
1347 } else if (slack < 0) {
1348 /* this will never happen */
1349 DBG(1, "image overflow %d bytes\n", dev->total_img_size - dev->total_out_size);
1350 }
1351 if (isJPEGEnabled(dev) &&
1352 dev->composition == MODE_RGB24) {
1353 remove(encTmpFileName);
1354 }
1355 /* that's all */
1356 dev_stop(dev);
1357 return SANE_STATUS_EOF;
1358 }
1359
1360 /* queue next image block */
1361 if (!dev_acquire(dev))
1362 return dev->state;
1363 }
1364
1365 if (!dev->reading) {
1366 if (cancelled(dev))
1367 return dev->state;
1368 DBG(5, "READ_IMAGE\n");
1369 if (!dev_cmd(dev, CMD_READ_IMAGE))
1370 return SANE_STATUS_IO_ERROR;
1371 dev->reading++;
1372 dev->ulines += dev->vertical;
1373 dev->y_off = dev->ulines - dev->vertical;
1374 dev->total_data_size += dev->blocklen;
1375 dev->blocks++;
1376 }
1377
1378 do {
1379 size_t datalen;
1380 int clrlen; /* cleared lines len */
1381 int olen; /* output len */
1382
1383 /* read as much data into the buffer */
1384 datalen = DATAROOM(dev) & USB_BLOCK_MASK;
1385 while (datalen && dev->blocklen) {
1386 SANE_Byte *rbuf = dev->data + DATATAIL(dev);
1387
1388 DBG(9, "<> request len: %lu, [%d, %d; %d]\n",
1389 (u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen);
1390 if ((status = dev->io->dev_request(dev, NULL, 0, rbuf, &datalen)) !=
1391 SANE_STATUS_GOOD)
1392 return status;
1393 dev->datalen += datalen;
1394 dev->blocklen -= datalen;
1395 DBG(9, "<> got %lu, [%d, %d; %d]\n",
1396 (u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen);
1397 if (dev->blocklen < 0)
1398 return ret_cancel(dev, SANE_STATUS_IO_ERROR);
1399
1400 datalen = DATAROOM(dev) & USB_BLOCK_MASK;
1401 }
1402
1403 if (buf && lenp) { /* read mode */
1404 /* copy will do minimal of valid data */
1405 if (dev->para.format == SANE_FRAME_RGB && dev->line_order) {
1406 if (isJPEGEnabled(dev)) {
1407 clrlen = dump_to_tmp_file(dev);
1408 /* decompress after reading entire block data*/
1409 if (0 == dev->blocklen) {
1410 decompress_tempfile(dev);
1411 }
1412 copy_decompress_data(dev, buf, maxlen, &olen);
1413 } else {
1414 clrlen = copy_mix_bands_trim(dev, buf, maxlen, &olen);
1415 }
1416 } else
1417 clrlen = copy_plain_trim(dev, buf, maxlen, &olen);
1418
1419 dev->datalen -= clrlen;
1420 dev->dataoff = (dev->dataoff + clrlen) & DATAMASK;
1421 buf += olen;
1422 maxlen -= olen;
1423 *lenp += olen;
1424 dev->total_out_size += olen;
1425
1426 DBG(9, "<> olen: %d, clrlen: %d, blocklen: %d/%d, maxlen %d (%d %d %d)\n",
1427 olen, clrlen, dev->blocklen, dev->datalen, maxlen,
1428 dev->dataindex / dev->bytes_per_line + dev->y_off,
1429 dev->y_off, dev->para.lines);
1430
1431 /* slack beyond last line */
1432 if (dev->dataindex / dev->bytes_per_line + dev->y_off >= dev->para.lines) {
1433 dev->datalen = 0;
1434 dev->dataoff = 0;
1435 }
1436
1437 if (!clrlen || maxlen <= 0)
1438 break;
1439 } else { /* flush mode */
1440 dev->datalen = 0;
1441 dev->dataoff = 0;
1442 }
1443
1444 } while (dev->blocklen);
1445
1446 if (lenp)
1447 DBG(9, " ==> %d\n", *lenp);
1448
1449 return SANE_STATUS_GOOD;
1450 }
1451
1452 SANE_Status
sane_start(SANE_Handle h)1453 sane_start(SANE_Handle h)
1454 {
1455 struct device *dev = h;
1456
1457 DBG(3, "%s: %p\n", __func__, h);
1458
1459 dev->cancel = 0;
1460 dev->scanning = 0;
1461 dev->total_img_size = 0;
1462 dev->total_out_size = 0;
1463 dev->total_data_size = 0;
1464 dev->blocks = 0;
1465
1466 if (!dev->reserved) {
1467 if (!dev_cmd_wait(dev, CMD_RESERVE_UNIT))
1468 return dev->state;
1469 dev->reserved++;
1470 }
1471
1472 if (!dev_set_window(dev) ||
1473 (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY))
1474 return dev_stop(dev);
1475
1476 if (!dev_cmd_wait(dev, CMD_OBJECT_POSITION))
1477 return dev_stop(dev);
1478
1479 if (!dev_cmd(dev, CMD_READ) ||
1480 (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY))
1481 return dev_stop(dev);
1482
1483 dev->scanning = 1;
1484 dev->final_block = 0;
1485 dev->blocklen = 0;
1486 dev->pixels_per_line = 0;
1487 dev->bytes_per_line = 0;
1488 dev->ulines = 0;
1489
1490 set_parameters(dev);
1491
1492 if (!dev->data && !(dev->data = malloc(DATASIZE)))
1493 return ret_cancel(dev, SANE_STATUS_NO_MEM);
1494
1495 /* this is for jpeg mode only */
1496 if (!dev->decData && !(dev->decData = malloc(POST_DATASIZE)))
1497 return ret_cancel(dev, SANE_STATUS_NO_MEM);
1498
1499 if (!dev_acquire(dev))
1500 return dev->state;
1501
1502 /* make sure to have dev->para <= of real size */
1503 if (dev->para.pixels_per_line > dev->pixels_per_line) {
1504 dev->para.pixels_per_line = dev->pixels_per_line;
1505 dev->para.bytes_per_line = dev->pixels_per_line;
1506 }
1507
1508 if (dev->composition == MODE_RGB24)
1509 dev->para.bytes_per_line = dev->para.pixels_per_line * 3;
1510 else if (dev->composition == MODE_LINEART ||
1511 dev->composition == MODE_HALFTONE) {
1512 dev->para.bytes_per_line = (dev->para.pixels_per_line + 7) / 8;
1513 dev->para.pixels_per_line = dev->para.bytes_per_line * 8;
1514 } else {
1515 dev->para.bytes_per_line = dev->para.pixels_per_line;
1516 }
1517
1518 dev->total_img_size = dev->para.bytes_per_line * dev->para.lines;
1519
1520 if (isJPEGEnabled(dev) &&
1521 dev->composition == MODE_RGB24) {
1522 int fd;
1523 remove(encTmpFileName);
1524
1525 /* Precreate temporary file in exclusive mode. */
1526 fd = open(encTmpFileName, O_CREAT|O_EXCL, 0600);
1527 if (fd == -1) {
1528 DBG(3, "%s: %p, can't create temporary file %s: %s\n", __func__,
1529 (void *)dev, encTmpFileName, strerror(errno));
1530 return ret_cancel(dev, SANE_STATUS_ACCESS_DENIED);
1531 }
1532 close(fd);
1533 }
1534 dev->currentDecDataIndex = 0;
1535
1536 return SANE_STATUS_GOOD;
1537 }
1538
sane_set_io_mode(SANE_Handle h, SANE_Bool non_blocking)1539 SANE_Status sane_set_io_mode(SANE_Handle h, SANE_Bool non_blocking)
1540 {
1541 struct device *dev = h;
1542
1543 DBG(3, "%s: %p, %d\n", __func__, h, non_blocking);
1544
1545 if (non_blocking)
1546 return SANE_STATUS_UNSUPPORTED;
1547
1548 dev->non_blocking = non_blocking;
1549 return SANE_STATUS_GOOD;
1550 }
1551
sane_get_select_fd(SANE_Handle h, SANE_Int *fdp)1552 SANE_Status sane_get_select_fd(SANE_Handle h, SANE_Int *fdp)
1553 {
1554 DBG(3, "%s: %p, %p\n", __func__, h, (void *)fdp);
1555 /* supporting of this will require thread creation */
1556 return SANE_STATUS_UNSUPPORTED;
1557 }
1558
sane_cancel(SANE_Handle h)1559 void sane_cancel(SANE_Handle h)
1560 {
1561 struct device *dev = h;
1562
1563 DBG(3, "%s: %p\n", __func__, h);
1564 dev->cancel = 1;
1565 }
1566
1567 /* xerox_mfp.c */
1568