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