Lines Matching refs:dev
99 * Decode jpeg from `infilename` into dev->decData of dev->decDataSize size.
101 static int decompress(struct device __sane_unused__ *dev,
138 dev->decDataSize = bmp_size;
146 buffer[0] = dev->decData + \
159 /* copy from decoded jpeg image (dev->decData) into user's buffer (pDest) */
161 static int copy_decompress_data(struct device *dev, unsigned char *pDest, int maxlen, int *destLen)
167 if (!dev->decDataSize)
169 data_size = dev->decDataSize - dev->currentDecDataIndex;
173 memcpy(pDest, dev->decData + dev->currentDecDataIndex, data_size);
176 dev->currentDecDataIndex += data_size;
178 if (dev->decDataSize == dev->currentDecDataIndex) {
179 dev->currentDecDataIndex = 0;
180 dev->decDataSize = 0;
185 static int decompress_tempfile(struct device *dev)
187 decompress(dev, encTmpFileName);
192 static int dump_to_tmp_file(struct device *dev)
194 unsigned char *pSrc = dev->data;
195 int srcLen = dev->datalen;
207 static int isSupportedDevice(struct device __sane_unused__ *dev)
211 if (dev->compressionTypes & (1 << 6)) {
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))
228 static int isJPEGEnabled(struct device __sane_unused__ *dev)
230 return isSupportedDevice(dev) && dev->compressionEnabled;
233 static void dbg_dump(struct device *dev)
237 int nzlen = dev->reslen;
238 int dlen = MIN(dev->reslen, MAX_DUMP);
240 for (i = dev->reslen - 1; i >= 0; i--, nzlen--)
241 if (dev->res[i] != 0)
247 sprintf(dptr, " %02x", dev->res[i]);
249 DBG(5, "[%lu]%s%s\n", (u_long)dev->reslen, dbuf,
250 (dlen < (int)dev->reslen)? "..." : "");
255 static int dev_command(struct device *dev, SANE_Byte *cmd, size_t reqlen)
259 SANE_Byte *res = dev->res;
262 assert(reqlen <= sizeof(dev->res)); /* requested len */
263 dev->reslen = sizeof(dev->res); /* doing full buffer to flush stalled commands */
275 dev->state = 0;
278 status = dev->io->dev_request(dev, cmd, sendlen, res, &dev->reslen);
281 dev->state = SANE_STATUS_IO_ERROR;
291 if (dev->reslen < reqlen) {
293 __func__, (u_long)dev->reslen, (u_long)reqlen);
294 dev->state = SANE_STATUS_IO_ERROR;
300 dbg_dump(dev);
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;
307 pktlen = dev->res[2] + 3;
308 if (dev->reslen != pktlen) {
310 __func__, (u_long)pktlen, (u_long)dev->reslen);
311 dev->state = SANE_STATUS_IO_ERROR;
314 if (dev->reslen > reqlen)
316 __func__, (u_long)dev->reslen, (u_long)reqlen);
319 dev->state = 0;
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]));
333 if (dev->state)
336 dev->state, sane_strstatus(dev->state));
343 static int dev_cmd(struct device *dev, SANE_Byte command)
347 return dev_command(dev, cmd, (command == CMD_INQUIRY)? 70 : 32);
351 static SANE_Status dev_stop(struct device *dev)
353 int state = dev->state;
356 (void *)dev, dev->scanning, dev->reserved);
357 dev->scanning = 0;
360 if (!dev->reserved)
362 dev->reserved = 0;
363 dev_cmd(dev, CMD_RELEASE_UNIT);
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;
374 SANE_Status ret_cancel(struct device *dev, SANE_Status ret)
376 dev_cmd(dev, CMD_ABORT);
377 if (dev->scanning) {
378 dev_stop(dev);
379 dev->state = SANE_STATUS_CANCELLED;
384 static int cancelled(struct device *dev)
386 if (dev->cancel)
387 return ret_cancel(dev, 1);
393 static int dev_cmd_wait(struct device *dev, int cmd)
398 if (cancelled(dev))
400 if (!dev_cmd(dev, cmd)) {
401 dev->state = SANE_STATUS_IO_ERROR;
403 } else if (dev->state) {
404 if (dev->state != SANE_STATUS_DEVICE_BUSY)
407 if (dev->non_blocking) {
408 dev->state = SANE_STATUS_GOOD;
414 str_cmd(cmd), sleeptime, dev->res[4], dev->res[5]);
421 } while (dev->state == SANE_STATUS_DEVICE_BUSY);
447 static void resolv_inq_dpi(struct device *dev)
450 int res = dev->resolutions;
452 assert(sizeof(inq_dpi_bits) < sizeof(dev->dpi_list));
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);
523 static void reset_options(struct device *dev)
525 dev->val[OPT_RESOLUTION].w = 150;
526 dev->val[OPT_MODE].s = string_match(scan_modes, SANE_VALUE_SCAN_MODE_COLOR);
529 dev->val[OPT_SOURCE].s = UNCONST(doc_sources[(dev->doc_loaded)? 1 : 0]);
531 dev->val[OPT_THRESHOLD].w = SANE_FIX(50);
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;
546 static void init_options(struct device *dev)
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;
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;
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;
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;
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;
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;
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;
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;
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;
617 dev->opt[OPT_JPEG].cap |= SANE_CAP_INACTIVE;
618 dev->val[OPT_JPEG].b = SANE_FALSE;
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;
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;
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;
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;
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;
657 static void set_parameters(struct device *dev)
661 dev->para.last_frame = SANE_TRUE;
662 dev->para.lines = -1;
663 px_to_len = 1200.0 / dev->val[OPT_RESOLUTION].w;
668 px_to_len = 1180.0 / dev->val[OPT_RESOLUTION].w;
670 dev->para.pixels_per_line = dev->win_width / px_to_len;
671 dev->para.bytes_per_line = dev->para.pixels_per_line;
673 DBG(5, dev->val[OPT_JPEG].b ? "JPEG compression enabled\n" : "JPEG compression disabled\n" );
674 dev->compressionEnabled = dev->val[OPT_JPEG].b;
676 if (!isJPEGEnabled(dev)) {
678 px_to_len = 1213.9 / dev->val[OPT_RESOLUTION].w;
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;
698 __func__, dev->composition);
699 dev->para.format = SANE_FRAME_GRAY;
700 dev->para.depth = 8;
706 static int fix_window(struct device *dev)
710 int threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w);
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)];
715 if (dev->composition == MODE_LINEART ||
716 dev->composition == MODE_HALFTONE) {
717 dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
719 dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
722 dev->val[OPT_THRESHOLD].w = SANE_FIX(30);
724 dev->val[OPT_THRESHOLD].w = SANE_FIX(70);
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);
730 dev->doc_source = doc_source_to_code[string_match_index(doc_sources, dev->val[OPT_SOURCE].s)];
733 if (dev->doc_source == DOC_FLATBED ||
734 (dev->doc_source == DOC_AUTO && !dev->doc_loaded))
735 dev->max_len = dev->max_len_fb;
737 dev->max_len = dev->max_len_adf;
740 dev->win_y_range.max = SANE_FIX((double)dev->max_len / PNT_PER_MM);
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;
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);
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;
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);
765 dev->win_width = (int)(win_width_mm * PNT_PER_MM);
766 dev->win_len = (int)(win_len_mm * PNT_PER_MM);
769 if (!dev->win_width || !dev->win_len) {
771 dev->state = SANE_STATUS_INVAL;
778 static int dev_set_window(struct device *dev)
784 if (!fix_window(dev))
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;
804 if (dev->composition == MODE_RGB24) {
805 if (isJPEGEnabled(dev)) {
809 cmd[0x16] = dev->threshold;
810 cmd[0x17] = dev->doc_source;
818 dev->max_win_width, dev->max_win_len);
820 return dev_command(dev, cmd, 32);
824 dev_inquiry(struct device *dev)
829 if (!dev_cmd(dev, CMD_INQUIRY))
831 ptr = dev->res;
838 dev->sane.vendor = optr = (SANE_Char *) malloc(33);
839 for (ptr += 4; ptr < &dev->res[0x24] && *ptr && *ptr != ' ';)
843 for (; ptr < &dev->res[0x24] && (!*ptr || *ptr == ' '); ptr++)
846 dev->sane.model = optr = (SANE_Char *) malloc(33);
848 for (; ptr < &dev->res[0x24] && *ptr;) {
856 DBG(1, "%s: found %s/%s\n", __func__, dev->sane.vendor, dev->sane.model);
857 dev->sane.type = strdup("multi-function peripheral");
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);
884 init_options(dev);
885 reset_options(dev);
886 fix_window(dev);
887 set_parameters(dev);
888 resolv_inq_dpi(dev);
896 struct device *dev = h;
901 return &dev->opt[opt];
908 struct device *dev = h;
911 if (!dev || opt >= NUM_OPTIONS || opt < 0)
918 if (dev->opt[opt].type == SANE_TYPE_STRING)
919 strcpy(val, dev->val[opt].s);
921 *(SANE_Word *)val = dev->val[opt].w;
923 SANE_Parameters xpara = dev->para;
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))
933 dev->val[opt].w = res_dpi_codes[dpi_to_code(*(SANE_Word *)val)];
935 dev->val[opt].w = *(SANE_Word *)val;
937 memcpy(&xopt, &dev->opt, sizeof(xopt));
938 memcpy(&xval, &dev->val, sizeof(xval));
939 fix_window(dev);
940 set_parameters(dev);
944 if (memcmp(&xpara, &dev->para, sizeof(xpara)))
946 if (memcmp(&xopt, &dev->opt, sizeof(xopt)))
949 if (xval[i].w != dev->val[i].w) {
964 dev_free(struct device *dev)
966 if (!dev)
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;
983 memset(dev, 0, sizeof(*dev));
984 free(dev);
991 struct device *dev;
997 for (dev = devices_head; dev; dev = next) {
998 next = dev->next;
999 dev_free(dev);
1014 struct device *dev;
1020 for (dev = devices_head; dev; dev = dev->next) {
1021 if (strcmp(dev->sane.name, devname) == 0)
1027 dev = calloc(1, sizeof(struct device));
1028 if (dev == NULL)
1031 dev->sane.name = strdup(devname);
1032 dev->io = tr;
1033 status = tr->dev_open(dev);
1035 dev_free(dev);
1039 /* status = dev_cmd (dev, CMD_ABORT);*/
1040 status = dev_inquiry(dev);
1041 tr->dev_close(dev);
1044 dev->sane.name, sane_strstatus(status));
1045 dev_free(dev);
1050 dev->next = devices_head;
1051 devices_head = dev;
1080 struct device *dev;
1082 for (dev = devices_head; dev; dev = dev->next)
1083 if (dev->dn != -1)
1084 sane_close(dev); /* implies flush */
1093 struct device *dev;
1112 for (dev_count = 0, dev = devices_head; dev; dev = dev->next)
1121 for (i = 0, dev = devices_head; dev; dev = dev->next)
1122 devlist[i++] = &dev->sane;
1133 struct device *dev = h;
1135 if (!dev)
1138 DBG(3, "%s: %p (%s)\n", __func__, (void *)dev, dev->sane.name);
1139 dev->io->dev_close(dev);
1145 struct device *dev;
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)
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);
1175 struct device *dev = h;
1181 *para = dev->para;
1187 static int dev_acquire(struct device *dev)
1189 if (!dev_cmd_wait(dev, CMD_READ))
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;
1201 dev->pixels_per_line = dev->horizontal;
1202 dev->bytes_per_line = dev->horizontal;
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;
1211 dev->vertical, dev->horizontal, dev->final_block? "last " : "",
1212 dev->blocklen, dev->blocklen - (dev->vertical * dev->bytes_per_line));
1214 if (dev->bytes_per_line > DATASIZE) {
1216 __func__, dev->bytes_per_line, DATASIZE);
1217 ret_cancel(dev, SANE_STATUS_NO_MEM);
1221 dev->reading = 0; /* need to issue READ_IMAGE */
1223 dev->dataindex = 0;
1224 dev->datalen = 0;
1225 dev->dataoff = 0;
1230 static int fill_slack(struct device *dev, SANE_Byte *buf, int maxlen)
1232 const int slack = dev->total_img_size - dev->total_out_size;
1243 static int copy_plain_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)
1246 const int linesize = dev->bytes_per_line;
1247 int k = dev->dataindex;
1249 for (j = 0; j < dev->datalen && *olenp < maxlen; j++, k++) {
1252 if (y >= dev->vertical)
1254 if (x < dev->para.bytes_per_line &&
1255 (y + dev->y_off) < dev->para.lines) {
1256 *buf++ = dev->data[(dev->dataoff + j) & DATAMASK];
1260 dev->dataindex = k;
1266 static int copy_mix_bands_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)
1270 const int linesize = dev->bytes_per_line; /* caching real line size */
1274 const int y_off = dev->dataindex / linesize;
1276 int k = dev->dataindex; /* caching current index of input buffer */
1279 int havelen = dev->datalen / linesize * linesize - k % linesize;
1286 const int band = (k % bands) * dev->horizontal;
1289 const int y_rly = y + y_off + dev->y_off; /* global y */
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];
1297 dev->dataindex = k;
1307 struct device *dev = h;
1313 if (!dev)
1316 if (!dev->scanning)
1320 if (!dev->blocklen && dev->datalen <= PADDING_SIZE) {
1323 if (dev->composition == MODE_RGB24 &&
1324 isJPEGEnabled(dev) &&
1325 dev->decDataSize > 0) {
1326 int diff = dev->total_img_size - dev->total_out_size;
1329 copy_decompress_data(dev, buf, bufLen, lenp)) {
1331 dev->total_out_size += *lenp;
1337 if (dev->final_block) {
1338 int slack = dev->total_img_size - dev->total_out_size;
1342 *lenp = fill_slack(dev, buf, maxlen);
1343 dev->total_out_size += *lenp;
1349 DBG(1, "image overflow %d bytes\n", dev->total_img_size - dev->total_out_size);
1351 if (isJPEGEnabled(dev) &&
1352 dev->composition == MODE_RGB24) {
1356 dev_stop(dev);
1361 if (!dev_acquire(dev))
1362 return dev->state;
1365 if (!dev->reading) {
1366 if (cancelled(dev))
1367 return dev->state;
1369 if (!dev_cmd(dev, CMD_READ_IMAGE))
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++;
1384 datalen = DATAROOM(dev) & USB_BLOCK_MASK;
1385 while (datalen && dev->blocklen) {
1386 SANE_Byte *rbuf = dev->data + DATATAIL(dev);
1389 (u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen);
1390 if ((status = dev->io->dev_request(dev, NULL, 0, rbuf, &datalen)) !=
1393 dev->datalen += datalen;
1394 dev->blocklen -= datalen;
1396 (u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen);
1397 if (dev->blocklen < 0)
1398 return ret_cancel(dev, SANE_STATUS_IO_ERROR);
1400 datalen = DATAROOM(dev) & USB_BLOCK_MASK;
1405 if (dev->para.format == SANE_FRAME_RGB && dev->line_order) {
1406 if (isJPEGEnabled(dev)) {
1407 clrlen = dump_to_tmp_file(dev);
1409 if (0 == dev->blocklen) {
1410 decompress_tempfile(dev);
1412 copy_decompress_data(dev, buf, maxlen, &olen);
1414 clrlen = copy_mix_bands_trim(dev, buf, maxlen, &olen);
1417 clrlen = copy_plain_trim(dev, buf, maxlen, &olen);
1419 dev->datalen -= clrlen;
1420 dev->dataoff = (dev->dataoff + clrlen) & DATAMASK;
1424 dev->total_out_size += olen;
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);
1432 if (dev->dataindex / dev->bytes_per_line + dev->y_off >= dev->para.lines) {
1433 dev->datalen = 0;
1434 dev->dataoff = 0;
1440 dev->datalen = 0;
1441 dev->dataoff = 0;
1444 } while (dev->blocklen);
1455 struct device *dev = h;
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;
1466 if (!dev->reserved) {
1467 if (!dev_cmd_wait(dev, CMD_RESERVE_UNIT))
1468 return dev->state;
1469 dev->reserved++;
1472 if (!dev_set_window(dev) ||
1473 (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY))
1474 return dev_stop(dev);
1476 if (!dev_cmd_wait(dev, CMD_OBJECT_POSITION))
1477 return dev_stop(dev);
1479 if (!dev_cmd(dev, CMD_READ) ||
1480 (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY))
1481 return dev_stop(dev);
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;
1490 set_parameters(dev);
1492 if (!dev->data && !(dev->data = malloc(DATASIZE)))
1493 return ret_cancel(dev, SANE_STATUS_NO_MEM);
1496 if (!dev->decData && !(dev->decData = malloc(POST_DATASIZE)))
1497 return ret_cancel(dev, SANE_STATUS_NO_MEM);
1499 if (!dev_acquire(dev))
1500 return dev->state;
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;
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;
1515 dev->para.bytes_per_line = dev->para.pixels_per_line;
1518 dev->total_img_size = dev->para.bytes_per_line * dev->para.lines;
1520 if (isJPEGEnabled(dev) &&
1521 dev->composition == MODE_RGB24) {
1529 (void *)dev, encTmpFileName, strerror(errno));
1530 return ret_cancel(dev, SANE_STATUS_ACCESS_DENIED);
1534 dev->currentDecDataIndex = 0;
1541 struct device *dev = h;
1548 dev->non_blocking = non_blocking;
1561 struct device *dev = h;
1564 dev->cancel = 1;