Lines Matching refs:dev
2 Copyright (C) 2001-2012 Stéphane Voltz <stef.dev@free.fr>
185 #define UMAX_PP_DEFAULT_PORT "/dev/parport0"
191 * or the device name used by ppdev on linux systems (/dev/parport0 )
198 Umax_PP_Descriptor *dev;
289 dev = malloc (sizeof (Umax_PP_Descriptor) * (num_devices + 1));
291 if (dev == NULL)
298 memset (dev, 0, sizeof (Umax_PP_Descriptor) * (num_devices + 1));
302 memcpy (dev + 1, devlist, sizeof (Umax_PP_Descriptor) * (num_devices));
306 devlist = dev;
312 dev->sane.name = strdup (devname);
314 dev->sane.name = strdup (val);
317 dev->sane.vendor = strdup ("UMAX");
319 dev->sane.vendor = strdup (val);
320 dev->sane.type = "flatbed scanner";
323 dev->ppdevice = strdup (devname);
325 dev->port = strdup (devname);
326 dev->buf_size = buf_size;
330 dev->max_res = 1200;
331 dev->ccd_res = 600;
332 dev->max_h_size = 5100;
333 dev->max_v_size = 7000 - 8; /* -8: workaround 'y overflow bug at 600 dpi' */
337 dev->max_res = 600;
338 dev->ccd_res = 300;
339 dev->max_h_size = 2550;
340 dev->max_v_size = 3500;
344 dev->sane.model = strdup (model);
346 dev->sane.model = strdup (val);
498 init_options (Umax_PP_Device * dev)
503 memset (dev->opt, 0, sizeof (dev->opt));
504 memset (dev->val, 0, sizeof (dev->val));
508 dev->opt[i].size = sizeof (SANE_Word);
509 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
512 dev->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
513 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
514 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
515 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
516 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
517 dev->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
521 dev->opt[OPT_MODE_GROUP].title = SANE_TITLE_SCAN_MODE;
522 dev->opt[OPT_MODE_GROUP].name = "";
523 dev->opt[OPT_MODE_GROUP].desc = "";
524 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
525 dev->opt[OPT_MODE_GROUP].size = 0;
526 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
529 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
530 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
531 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
532 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
533 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
534 dev->opt[OPT_MODE].size = 10;
535 dev->opt[OPT_MODE].constraint.string_list = mode_list;
536 dev->val[OPT_MODE].s = strdup (mode_list[1]);
539 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
540 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
541 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
542 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_FIXED;
543 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
544 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
545 dev->opt[OPT_RESOLUTION].constraint.range = &dev->dpi_range;
546 dev->val[OPT_RESOLUTION].w = dev->dpi_range.min;
550 dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
551 dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
552 dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
553 dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
554 dev->opt[OPT_PREVIEW].size = sizeof (SANE_Word);
555 dev->opt[OPT_PREVIEW].unit = SANE_UNIT_NONE;
556 dev->val[OPT_PREVIEW].w = SANE_FALSE;
559 dev->opt[OPT_GRAY_PREVIEW].name = SANE_NAME_GRAY_PREVIEW;
560 dev->opt[OPT_GRAY_PREVIEW].title = SANE_TITLE_GRAY_PREVIEW;
561 dev->opt[OPT_GRAY_PREVIEW].desc = SANE_DESC_GRAY_PREVIEW;
562 dev->opt[OPT_GRAY_PREVIEW].type = SANE_TYPE_BOOL;
563 dev->opt[OPT_GRAY_PREVIEW].size = sizeof (SANE_Word);
564 dev->opt[OPT_GRAY_PREVIEW].unit = SANE_UNIT_NONE;
565 dev->val[OPT_GRAY_PREVIEW].w = SANE_FALSE;
569 dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
570 dev->opt[OPT_GEOMETRY_GROUP].desc = "";
571 dev->opt[OPT_GEOMETRY_GROUP].name = "";
572 dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
573 dev->opt[OPT_GEOMETRY_GROUP].size = 0;
574 dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
577 dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
578 dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
579 dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
580 dev->opt[OPT_TL_X].type = SANE_TYPE_INT;
581 dev->opt[OPT_TL_X].unit = SANE_UNIT_PIXEL;
582 dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
583 dev->opt[OPT_TL_X].constraint.range = &dev->x_range;
584 dev->val[OPT_TL_X].w = 0;
587 dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
588 dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
589 dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
590 dev->opt[OPT_TL_Y].type = SANE_TYPE_INT;
591 dev->opt[OPT_TL_Y].unit = SANE_UNIT_PIXEL;
592 dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
593 dev->opt[OPT_TL_Y].constraint.range = &dev->y_range;
594 dev->val[OPT_TL_Y].w = 0;
597 dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
598 dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
599 dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
600 dev->opt[OPT_BR_X].type = SANE_TYPE_INT;
601 dev->opt[OPT_BR_X].unit = SANE_UNIT_PIXEL;
602 dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
603 dev->opt[OPT_BR_X].constraint.range = &dev->x_range;
604 dev->val[OPT_BR_X].w = dev->x_range.max;
607 dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
608 dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
609 dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
610 dev->opt[OPT_BR_Y].type = SANE_TYPE_INT;
611 dev->opt[OPT_BR_Y].unit = SANE_UNIT_PIXEL;
612 dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
613 dev->opt[OPT_BR_Y].constraint.range = &dev->y_range;
614 dev->val[OPT_BR_Y].w = dev->y_range.max;
618 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
619 dev->opt[OPT_ENHANCEMENT_GROUP].desc = "";
620 dev->opt[OPT_ENHANCEMENT_GROUP].name = "";
621 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
622 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
623 dev->opt[OPT_ENHANCEMENT_GROUP].cap |= SANE_CAP_ADVANCED;
624 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
627 dev->opt[OPT_LAMP_CONTROL].name = "lamp-control";
628 dev->opt[OPT_LAMP_CONTROL].title = SANE_I18N ("Lamp on");
629 dev->opt[OPT_LAMP_CONTROL].desc = SANE_I18N ("Sets lamp on/off");
630 dev->opt[OPT_LAMP_CONTROL].type = SANE_TYPE_BOOL;
631 dev->opt[OPT_LAMP_CONTROL].size = sizeof (SANE_Word);
632 dev->opt[OPT_LAMP_CONTROL].unit = SANE_UNIT_NONE;
633 dev->val[OPT_LAMP_CONTROL].w = SANE_TRUE;
634 dev->opt[OPT_LAMP_CONTROL].cap |= SANE_CAP_ADVANCED;
637 dev->opt[OPT_UTA_CONTROL].name = "UTA-control";
638 dev->opt[OPT_UTA_CONTROL].title = SANE_I18N ("UTA on");
639 dev->opt[OPT_UTA_CONTROL].desc = SANE_I18N ("Sets UTA on/off");
640 dev->opt[OPT_UTA_CONTROL].type = SANE_TYPE_BOOL;
641 dev->opt[OPT_UTA_CONTROL].size = sizeof (SANE_Word);
642 dev->opt[OPT_UTA_CONTROL].unit = SANE_UNIT_NONE;
643 dev->val[OPT_UTA_CONTROL].w = SANE_TRUE;
644 dev->opt[OPT_UTA_CONTROL].cap |= SANE_CAP_ADVANCED | SANE_CAP_INACTIVE;
647 dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
648 dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
649 dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
650 dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
651 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_ADVANCED;
652 dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
655 dev->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
656 dev->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
657 dev->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
658 dev->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
659 dev->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
660 dev->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
661 dev->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
662 dev->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
663 dev->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
664 dev->val[OPT_GAMMA_VECTOR].wa = &dev->gamma_table[0][0];
667 dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
668 dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
669 dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
670 dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
671 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
672 dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
673 dev->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
674 dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
675 dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
676 dev->val[OPT_GAMMA_VECTOR_R].wa = &dev->gamma_table[1][0];
679 dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
680 dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
681 dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
682 dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
683 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
684 dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
685 dev->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
686 dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
687 dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
688 dev->val[OPT_GAMMA_VECTOR_G].wa = &dev->gamma_table[2][0];
691 dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
692 dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
693 dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
694 dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
695 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
696 dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
697 dev->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
698 dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
699 dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
700 dev->val[OPT_GAMMA_VECTOR_B].wa = &dev->gamma_table[3][0];
703 dev->opt[OPT_MANUAL_GAIN].name = "manual-channel-gain";
704 dev->opt[OPT_MANUAL_GAIN].title = SANE_I18N ("Gain");
705 dev->opt[OPT_MANUAL_GAIN].desc = SANE_I18N ("Color channels gain settings");
706 dev->opt[OPT_MANUAL_GAIN].type = SANE_TYPE_BOOL;
707 dev->opt[OPT_MANUAL_GAIN].cap |= SANE_CAP_ADVANCED;
708 dev->val[OPT_MANUAL_GAIN].w = SANE_FALSE;
711 dev->opt[OPT_GRAY_GAIN].name = "gray-gain";
712 dev->opt[OPT_GRAY_GAIN].title = SANE_I18N ("Gray gain");
713 dev->opt[OPT_GRAY_GAIN].desc = SANE_I18N ("Sets gray channel gain");
714 dev->opt[OPT_GRAY_GAIN].type = SANE_TYPE_INT;
715 dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
716 dev->opt[OPT_GRAY_GAIN].unit = SANE_UNIT_NONE;
717 dev->opt[OPT_GRAY_GAIN].size = sizeof (SANE_Int);
718 dev->opt[OPT_GRAY_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
719 dev->opt[OPT_GRAY_GAIN].constraint.range = &u4_range;
720 dev->val[OPT_GRAY_GAIN].w = dev->gray_gain;
723 dev->opt[OPT_RED_GAIN].name = "red-gain";
724 dev->opt[OPT_RED_GAIN].title = SANE_I18N ("Red gain");
725 dev->opt[OPT_RED_GAIN].desc = SANE_I18N ("Sets red channel gain");
726 dev->opt[OPT_RED_GAIN].type = SANE_TYPE_INT;
727 dev->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
728 dev->opt[OPT_RED_GAIN].unit = SANE_UNIT_NONE;
729 dev->opt[OPT_RED_GAIN].size = sizeof (SANE_Int);
730 dev->opt[OPT_RED_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
731 dev->opt[OPT_RED_GAIN].constraint.range = &u4_range;
732 dev->val[OPT_RED_GAIN].w = dev->red_gain;
735 dev->opt[OPT_GREEN_GAIN].name = "green-gain";
736 dev->opt[OPT_GREEN_GAIN].title = SANE_I18N ("Green gain");
737 dev->opt[OPT_GREEN_GAIN].desc = SANE_I18N ("Sets green channel gain");
738 dev->opt[OPT_GREEN_GAIN].type = SANE_TYPE_INT;
739 dev->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
740 dev->opt[OPT_GREEN_GAIN].unit = SANE_UNIT_NONE;
741 dev->opt[OPT_GREEN_GAIN].size = sizeof (SANE_Int);
742 dev->opt[OPT_GREEN_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
743 dev->opt[OPT_GREEN_GAIN].constraint.range = &u4_range;
744 dev->val[OPT_GREEN_GAIN].w = dev->green_gain;
747 dev->opt[OPT_BLUE_GAIN].name = "blue-gain";
748 dev->opt[OPT_BLUE_GAIN].title = SANE_I18N ("Blue gain");
749 dev->opt[OPT_BLUE_GAIN].desc = SANE_I18N ("Sets blue channel gain");
750 dev->opt[OPT_BLUE_GAIN].type = SANE_TYPE_INT;
751 dev->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
752 dev->opt[OPT_BLUE_GAIN].unit = SANE_UNIT_NONE;
753 dev->opt[OPT_BLUE_GAIN].size = sizeof (SANE_Int);
754 dev->opt[OPT_BLUE_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
755 dev->opt[OPT_BLUE_GAIN].constraint.range = &u4_range;
756 dev->val[OPT_BLUE_GAIN].w = dev->blue_gain;
759 dev->opt[OPT_MANUAL_OFFSET].name = "manual-offset";
760 dev->opt[OPT_MANUAL_OFFSET].title = SANE_I18N ("Offset");
761 dev->opt[OPT_MANUAL_OFFSET].desc =
763 dev->opt[OPT_MANUAL_OFFSET].type = SANE_TYPE_BOOL;
764 dev->opt[OPT_MANUAL_OFFSET].cap |= SANE_CAP_ADVANCED;
765 dev->val[OPT_MANUAL_OFFSET].w = SANE_FALSE;
768 dev->opt[OPT_GRAY_OFFSET].name = "gray-offset";
769 dev->opt[OPT_GRAY_OFFSET].title = SANE_I18N ("Gray offset");
770 dev->opt[OPT_GRAY_OFFSET].desc = SANE_I18N ("Sets gray channel offset");
771 dev->opt[OPT_GRAY_OFFSET].type = SANE_TYPE_INT;
772 dev->opt[OPT_GRAY_OFFSET].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
773 dev->opt[OPT_GRAY_OFFSET].unit = SANE_UNIT_NONE;
774 dev->opt[OPT_GRAY_OFFSET].size = sizeof (SANE_Int);
775 dev->opt[OPT_GRAY_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
776 dev->opt[OPT_GRAY_OFFSET].constraint.range = &u4_range;
777 dev->val[OPT_GRAY_OFFSET].w = dev->gray_offset;
780 dev->opt[OPT_RED_OFFSET].name = "red-offset";
781 dev->opt[OPT_RED_OFFSET].title = SANE_I18N ("Red offset");
782 dev->opt[OPT_RED_OFFSET].desc = SANE_I18N ("Sets red channel offset");
783 dev->opt[OPT_RED_OFFSET].type = SANE_TYPE_INT;
784 dev->opt[OPT_RED_OFFSET].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
785 dev->opt[OPT_RED_OFFSET].unit = SANE_UNIT_NONE;
786 dev->opt[OPT_RED_OFFSET].size = sizeof (SANE_Int);
787 dev->opt[OPT_RED_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
788 dev->opt[OPT_RED_OFFSET].constraint.range = &u4_range;
789 dev->val[OPT_RED_OFFSET].w = dev->red_offset;
792 dev->opt[OPT_GREEN_OFFSET].name = "green-offset";
793 dev->opt[OPT_GREEN_OFFSET].title = SANE_I18N ("Green offset");
794 dev->opt[OPT_GREEN_OFFSET].desc = SANE_I18N ("Sets green channel offset");
795 dev->opt[OPT_GREEN_OFFSET].type = SANE_TYPE_INT;
796 dev->opt[OPT_GREEN_OFFSET].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
797 dev->opt[OPT_GREEN_OFFSET].unit = SANE_UNIT_NONE;
798 dev->opt[OPT_GREEN_OFFSET].size = sizeof (SANE_Int);
799 dev->opt[OPT_GREEN_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
800 dev->opt[OPT_GREEN_OFFSET].constraint.range = &u4_range;
801 dev->val[OPT_GREEN_OFFSET].w = dev->green_offset;
804 dev->opt[OPT_BLUE_OFFSET].name = "blue-offset";
805 dev->opt[OPT_BLUE_OFFSET].title = SANE_I18N ("Blue offset");
806 dev->opt[OPT_BLUE_OFFSET].desc = SANE_I18N ("Sets blue channel offset");
807 dev->opt[OPT_BLUE_OFFSET].type = SANE_TYPE_INT;
808 dev->opt[OPT_BLUE_OFFSET].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
809 dev->opt[OPT_BLUE_OFFSET].unit = SANE_UNIT_NONE;
810 dev->opt[OPT_BLUE_OFFSET].size = sizeof (SANE_Int);
811 dev->opt[OPT_BLUE_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
812 dev->opt[OPT_BLUE_OFFSET].constraint.range = &u4_range;
813 dev->val[OPT_BLUE_OFFSET].w = dev->blue_offset;
978 Umax_PP_Device *dev;
986 dev = first_dev;
987 sane_close (dev);
1059 Umax_PP_Device *dev;
1172 dev = (Umax_PP_Device *) malloc (sizeof (*dev));
1174 if (dev == NULL)
1181 memset (dev, 0, sizeof (*dev));
1183 dev->desc = desc;
1187 dev->gamma_table[i][j] = j;
1191 dev->buf = malloc (dev->desc->buf_size + UMAX_PP_RESERVE);
1192 dev->bufsize = dev->desc->buf_size;
1194 dev->dpi_range.min = SANE_FIX (75);
1195 dev->dpi_range.max = SANE_FIX (dev->desc->max_res);
1196 dev->dpi_range.quant = 0;
1198 dev->x_range.min = 0;
1199 dev->x_range.max = dev->desc->max_h_size;
1200 dev->x_range.quant = 0;
1202 dev->y_range.min = 0;
1203 dev->y_range.max = dev->desc->max_v_size;
1204 dev->y_range.quant = 0;
1206 dev->gray_gain = 0;
1209 dev->red_gain = red_gain;
1210 dev->green_gain = green_gain;
1211 dev->blue_gain = blue_gain;
1212 dev->red_offset = red_offset;
1213 dev->green_offset = green_offset;
1214 dev->blue_offset = blue_offset;
1217 if (dev->buf == NULL)
1220 (long int) dev->desc->buf_size);
1222 free (dev);
1226 init_options (dev);
1228 dev->next = first_dev;
1229 first_dev = dev;
1233 dev->opt[OPT_UTA_CONTROL].cap &= ~SANE_CAP_INACTIVE;
1235 *handle = dev;
1245 Umax_PP_Device *prev, *dev;
1252 for (dev = first_dev; dev; dev = dev->next)
1254 if (dev == handle)
1256 prev = dev;
1259 if (dev == NULL)
1266 if (dev->state == UMAX_PP_STATE_SCANNING)
1272 while (dev->state == UMAX_PP_STATE_CANCELLED)
1281 dev->state = UMAX_PP_STATE_IDLE;
1286 if (dev->val[OPT_LAMP_CONTROL].w == SANE_TRUE)
1300 prev->next = dev->next;
1302 first_dev = dev->next;
1304 free (dev->buf);
1314 Umax_PP_Device *dev = handle;
1324 option, dev->opt[option].name);
1326 return dev->opt + option;
1333 Umax_PP_Device *dev = handle;
1343 if (dev->state == UMAX_PP_STATE_SCANNING)
1356 cap = dev->opt[option].cap;
1365 dev->opt[option].name, action);
1395 *(SANE_Word *) val = dev->val[option].w;
1403 memcpy (val, dev->val[option].wa, dev->opt[option].size);
1409 strcpy (val, dev->val[option].s);
1423 status = sanei_constrain_value (dev->opt + option, val, info);
1464 dev->val[option].w = *(SANE_Word *) val;
1466 if (dev->val[OPT_BR_Y].w < dev->val[OPT_TL_Y].w)
1468 tmpw = dev->val[OPT_BR_Y].w;
1469 dev->val[OPT_BR_Y].w = dev->val[OPT_TL_Y].w;
1470 dev->val[OPT_TL_Y].w = tmpw;
1475 if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
1477 dpi = (int) (SANE_UNFIX (dev->val[OPT_RESOLUTION].w));
1478 if (dev->val[OPT_TL_Y].w < 2 * umax_pp_get_sync (dpi))
1481 dev->val[OPT_TL_Y].w = 2 * umax_pp_get_sync (dpi);
1494 memcpy (dev->val[option].wa, val, dev->opt[option].size);
1500 dev->val[option].w = *(SANE_Word *) val;
1504 if (dev->state != UMAX_PP_STATE_IDLE)
1516 dev->state = UMAX_PP_STATE_IDLE;
1518 dev->val[option].w = *(SANE_Word *) val;
1519 if (dev->val[option].w == SANE_TRUE)
1531 dpi = (int) (SANE_UNFIX (dev->val[OPT_RESOLUTION].w));
1532 dev->val[option].w = *(SANE_Word *) val;
1537 if (dev->val[option].w & 0x03)
1541 dev->val[option].w = dev->val[option].w & 0xFFFC;
1542 *(SANE_Word *) val = dev->val[option].w;
1548 if (dev->val[OPT_BR_X].w < dev->val[OPT_TL_X].w)
1550 tmpw = dev->val[OPT_BR_X].w;
1551 dev->val[OPT_BR_X].w = dev->val[OPT_TL_X].w;
1552 dev->val[OPT_TL_X].w = tmpw;
1584 dev->val[option].w = *(SANE_Word *) val;
1589 dev->val[OPT_TL_X].w = dev->val[OPT_TL_X].w & 0xFFFC;
1590 dev->val[OPT_BR_X].w = dev->val[OPT_BR_X].w & 0xFFFC;
1593 if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
1595 if (dev->val[OPT_TL_Y].w < 2 * umax_pp_get_sync (dpi))
1598 dev->val[OPT_TL_Y].w = 2 * umax_pp_get_sync (dpi);
1608 if (w == dev->val[OPT_MANUAL_OFFSET].w)
1614 dev->val[OPT_MANUAL_OFFSET].w = w;
1618 const char *mode = dev->val[OPT_MODE].s;
1622 dev->opt[OPT_GRAY_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1625 dev->opt[OPT_GRAY_OFFSET].cap |= SANE_CAP_INACTIVE;
1626 dev->opt[OPT_RED_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1627 dev->opt[OPT_GREEN_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1628 dev->opt[OPT_BLUE_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1633 dev->opt[OPT_GRAY_OFFSET].cap |= SANE_CAP_INACTIVE;
1634 dev->opt[OPT_RED_OFFSET].cap |= SANE_CAP_INACTIVE;
1635 dev->opt[OPT_GREEN_OFFSET].cap |= SANE_CAP_INACTIVE;
1636 dev->opt[OPT_BLUE_OFFSET].cap |= SANE_CAP_INACTIVE;
1645 if (w == dev->val[OPT_MANUAL_GAIN].w)
1651 dev->val[OPT_MANUAL_GAIN].w = w;
1655 const char *mode = dev->val[OPT_MODE].s;
1659 dev->opt[OPT_GRAY_GAIN].cap &= ~SANE_CAP_INACTIVE;
1662 dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE;
1663 dev->opt[OPT_RED_GAIN].cap &= ~SANE_CAP_INACTIVE;
1664 dev->opt[OPT_GREEN_GAIN].cap &= ~SANE_CAP_INACTIVE;
1665 dev->opt[OPT_BLUE_GAIN].cap &= ~SANE_CAP_INACTIVE;
1670 dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE;
1671 dev->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE;
1672 dev->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE;
1673 dev->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE;
1683 if (w == dev->val[OPT_CUSTOM_GAMMA].w)
1689 dev->val[OPT_CUSTOM_GAMMA].w = w;
1693 const char *mode = dev->val[OPT_MODE].s;
1698 dev->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
1699 sanei_umax_pp_gamma (NULL, dev->val[OPT_GAMMA_VECTOR].wa,
1704 dev->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
1705 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1706 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1707 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1708 sanei_umax_pp_gamma (dev->val[OPT_GAMMA_VECTOR_R].wa,
1709 dev->val[OPT_GAMMA_VECTOR_G].wa,
1710 dev->val[OPT_GAMMA_VECTOR_B].wa);
1715 dev->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
1716 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1717 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1718 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1726 char *old_val = dev->val[option].s;
1739 dev->val[option].s = strdup (val);
1744 dpi = (int) (SANE_UNFIX (dev->val[OPT_RESOLUTION].w));
1745 if (dev->val[OPT_TL_Y].w < 2 * umax_pp_get_sync (dpi))
1747 dev->val[OPT_TL_Y].w = 2 * umax_pp_get_sync (dpi);
1754 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
1755 dev->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
1756 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1757 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1758 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1762 if (dev->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE)
1767 dev->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
1768 sanei_umax_pp_gamma (NULL, dev->val[OPT_GAMMA_VECTOR].wa,
1773 dev->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
1774 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1775 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1776 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1777 sanei_umax_pp_gamma (dev->val[OPT_GAMMA_VECTOR_R].wa,
1778 dev->val[OPT_GAMMA_VECTOR_G].wa,
1779 dev->val[OPT_GAMMA_VECTOR_B].wa);
1784 dev->opt[OPT_GRAY_OFFSET].cap |= SANE_CAP_INACTIVE;
1785 dev->opt[OPT_RED_OFFSET].cap |= SANE_CAP_INACTIVE;
1786 dev->opt[OPT_GREEN_OFFSET].cap |= SANE_CAP_INACTIVE;
1787 dev->opt[OPT_BLUE_OFFSET].cap |= SANE_CAP_INACTIVE;
1790 if (dev->val[OPT_MANUAL_OFFSET].w == SANE_TRUE)
1794 dev->opt[OPT_GRAY_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1797 dev->opt[OPT_RED_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1798 dev->opt[OPT_GREEN_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1799 dev->opt[OPT_BLUE_OFFSET].cap &= ~SANE_CAP_INACTIVE;
1804 dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE;
1805 dev->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE;
1806 dev->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE;
1807 dev->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE;
1810 if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE)
1814 dev->opt[OPT_GRAY_GAIN].cap &= ~SANE_CAP_INACTIVE;
1817 dev->opt[OPT_RED_GAIN].cap &= ~SANE_CAP_INACTIVE;
1818 dev->opt[OPT_GREEN_GAIN].cap &= ~SANE_CAP_INACTIVE;
1819 dev->opt[OPT_BLUE_GAIN].cap &= ~SANE_CAP_INACTIVE;
1837 Umax_PP_Device *dev = handle;
1840 memset (&(dev->params), 0, sizeof (dev->params));
1844 if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) != 0)
1846 if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) != 0)
1847 dev->color = UMAX_PP_MODE_LINEART;
1849 dev->color = UMAX_PP_MODE_GRAYSCALE;
1852 dev->color = UMAX_PP_MODE_COLOR;
1855 if (dev->val[OPT_MANUAL_OFFSET].w == SANE_TRUE)
1857 if (dev->color != UMAX_PP_MODE_COLOR)
1859 dev->red_offset = 0;
1860 dev->green_offset = (int) (dev->val[OPT_GRAY_OFFSET].w);
1861 dev->blue_offset = 0;
1865 dev->red_offset = (int) (dev->val[OPT_RED_OFFSET].w);
1866 dev->green_offset = (int) (dev->val[OPT_GREEN_OFFSET].w);
1867 dev->blue_offset = (int) (dev->val[OPT_BLUE_OFFSET].w);
1872 dev->red_offset = 6;
1873 dev->green_offset = 6;
1874 dev->blue_offset = 6;
1878 if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE)
1880 if (dev->color != UMAX_PP_MODE_COLOR)
1882 dev->red_gain = 0;
1883 dev->green_gain = (int) (dev->val[OPT_GRAY_GAIN].w);
1884 dev->blue_gain = 0;
1888 dev->red_gain = (int) (dev->val[OPT_RED_GAIN].w);
1889 dev->green_gain = (int) (dev->val[OPT_GREEN_GAIN].w);
1890 dev->blue_gain = (int) (dev->val[OPT_BLUE_GAIN].w);
1895 dev->red_gain = red_gain;
1896 dev->green_gain = green_gain;
1897 dev->blue_gain = blue_gain;
1901 dev->TopX = dev->val[OPT_TL_X].w;
1902 dev->TopY = dev->val[OPT_TL_Y].w;
1903 dev->BottomX = dev->val[OPT_BR_X].w;
1904 dev->BottomY = dev->val[OPT_BR_Y].w;
1907 dpi = (int) (SANE_UNFIX (dev->val[OPT_RESOLUTION].w));
1918 dev->dpi = dpi;
1925 remain = (dev->BottomX - dev->TopX) & 0x03;
1929 dev->BottomX, dev->TopX, remain);
1930 if (dev->BottomX + remain < dev->desc->max_h_size)
1931 dev->BottomX += remain;
1934 remain -= (dev->desc->max_h_size - dev->BottomX);
1935 dev->BottomX = dev->desc->max_h_size;
1936 dev->TopX -= remain;
1941 if (dev->val[OPT_PREVIEW].w == SANE_TRUE)
1944 if (dev->val[OPT_GRAY_PREVIEW].w == SANE_TRUE)
1947 dev->color = UMAX_PP_MODE_GRAYSCALE;
1948 dev->params.format = SANE_FRAME_GRAY;
1953 dev->color = UMAX_PP_MODE_COLOR;
1954 dev->params.format = SANE_FRAME_RGB;
1957 dev->dpi = 75;
1958 dev->TopX = 0;
1959 dev->TopY = 0;
1960 dev->BottomX = dev->desc->max_h_size;
1961 dev->BottomY = dev->desc->max_v_size;
1966 dev->params.last_frame = SANE_TRUE;
1967 dev->params.lines =
1968 ((dev->BottomY - dev->TopY) * dev->dpi) / dev->desc->ccd_res;
1969 if (dev->dpi >= dev->desc->ccd_res)
1970 dpi = dev->desc->ccd_res;
1972 dpi = dev->dpi;
1973 dev->params.pixels_per_line =
1974 ((dev->BottomX - dev->TopX) * dpi) / dev->desc->ccd_res;
1975 if (dev->color == UMAX_PP_MODE_COLOR)
1977 dev->params.bytes_per_line = dev->params.pixels_per_line * 3;
1978 dev->params.format = SANE_FRAME_RGB;
1982 dev->params.bytes_per_line = dev->params.pixels_per_line;
1983 dev->params.format = SANE_FRAME_GRAY;
1985 dev->params.depth = 8;
1989 memcpy (params, &(dev->params), sizeof (dev->params));
1997 Umax_PP_Device *dev = handle;
2002 if (dev->state == UMAX_PP_STATE_SCANNING)
2011 if (dev->state == UMAX_PP_STATE_CANCELLED)
2033 dev->state = UMAX_PP_STATE_IDLE;
2041 dev->val[OPT_LAMP_CONTROL].w = SANE_TRUE;
2044 if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE)
2051 if (dev->color == UMAX_PP_MODE_COLOR)
2053 delta = umax_pp_get_sync (dev->dpi);
2059 dev->TopX,
2060 dev->TopY - points,
2061 dev->BottomX - dev->TopX,
2062 dev->BottomY - dev->TopY + points,
2063 dev->dpi,
2064 (dev->red_gain << 8) + (dev->green_gain << 4) +
2065 dev->blue_gain,
2066 (dev->red_offset << 8) + (dev->green_offset << 4) +
2067 dev->blue_offset);
2069 rc = sanei_umax_pp_start (dev->TopX,
2070 dev->TopY - points,
2071 dev->BottomX - dev->TopX,
2072 dev->BottomY - dev->TopY + points,
2073 dev->dpi,
2076 (dev->red_gain << 8) |
2077 (dev->green_gain << 4) |
2078 dev->blue_gain,
2079 (dev->red_offset << 8) |
2080 (dev->green_offset << 4) |
2081 dev->blue_offset, &(dev->bpp), &(dev->tw),
2082 &(dev->th));
2087 dev->th -= points;
2088 DBG (64, "sane_start: bpp=%d,tw=%d,th=%d\n", dev->bpp, dev->tw,
2089 dev->th);
2094 dev->TopX,
2095 dev->TopY,
2096 dev->BottomX - dev->TopX,
2097 dev->BottomY - dev->TopY, dev->dpi, dev->gray_gain << 4,
2098 dev->gray_offset << 4);
2099 rc = sanei_umax_pp_start (dev->TopX,
2100 dev->TopY,
2101 dev->BottomX - dev->TopX,
2102 dev->BottomY - dev->TopY,
2103 dev->dpi,
2106 dev->gray_gain << 4,
2107 dev->gray_offset << 4, &(dev->bpp),
2108 &(dev->tw), &(dev->th));
2109 DBG (64, "sane_start: bpp=%d,tw=%d,th=%d\n", dev->bpp, dev->tw,
2110 dev->th);
2120 dev->state = UMAX_PP_STATE_SCANNING;
2121 dev->buflen = 0;
2122 dev->bufread = 0;
2123 dev->read = 0;
2128 && (dev->color == UMAX_PP_MODE_COLOR))
2131 sanei_umax_pp_read (2 * delta * dev->tw * dev->bpp, dev->tw, dev->dpi,
2133 dev->buf + UMAX_PP_RESERVE -
2134 2 * delta * dev->tw * dev->bpp);
2144 if ((dev->color == UMAX_PP_MODE_COLOR) && (delta > 0))
2147 sanei_umax_pp_read (2 * delta * dev->tw * dev->bpp, dev->tw, dev->dpi,
2149 dev->buf + UMAX_PP_RESERVE -
2150 2 * delta * dev->tw * dev->bpp);
2167 Umax_PP_Device *dev = handle;
2180 ll = dev->tw * dev->bpp;
2183 if (dev->state == UMAX_PP_STATE_CANCELLED)
2192 if (dev->read >= dev->th * ll)
2199 if ((dev->buflen == 0) || (dev->bufread >= dev->buflen))
2203 length = ll * dev->th - dev->read;
2206 if (length <= dev->bufsize)
2214 length = (dev->bufsize / ll) * ll;
2218 if (dev->color == UMAX_PP_MODE_COLOR)
2220 delta = umax_pp_get_sync (dev->dpi);
2222 sanei_umax_pp_read (length, dev->tw, dev->dpi, last,
2223 dev->buf + UMAX_PP_RESERVE);
2226 rc = sanei_umax_pp_read (length, dev->tw, dev->dpi, last, dev->buf);
2229 dev->buflen = length;
2233 if (dev->color == UMAX_PP_MODE_LINEART)
2239 if (dev->buf[y] > max)
2240 max = dev->buf[y];
2241 if (dev->buf[y] < min)
2242 min = dev->buf[y];
2247 if (dev->buf[y] > max)
2248 dev->buf[y] = 255;
2250 dev->buf[y] = 0;
2253 else if (dev->color == UMAX_PP_MODE_COLOR)
2256 nl = dev->buflen / ll;
2259 lbuf = (SANE_Byte *) malloc (dev->bufsize + UMAX_PP_RESERVE);
2263 dev->bufsize + UMAX_PP_RESERVE);
2269 for (x = 0; x < dev->tw; x++)
2275 lbuf[x * dev->bpp + y * ll + 1 + UMAX_PP_RESERVE] =
2276 dev->buf[x + y * ll + 2 * dev->tw + UMAX_PP_RESERVE];
2279 lbuf[x * dev->bpp + y * ll + 2 + UMAX_PP_RESERVE] =
2280 dev->buf[x + (y - delta) * ll + dev->tw +
2284 lbuf[x * dev->bpp + y * ll + UMAX_PP_RESERVE] =
2285 dev->buf[x + (y - 2 * delta) * ll + UMAX_PP_RESERVE];
2290 lbuf[x * dev->bpp + y * ll + UMAX_PP_RESERVE] =
2291 dev->buf[x + y * ll + 2 * dev->tw + UMAX_PP_RESERVE];
2294 lbuf[x * dev->bpp + y * ll + 1 + UMAX_PP_RESERVE] =
2295 dev->buf[x + (y - delta) * ll + dev->tw +
2299 lbuf[x * dev->bpp + y * ll + 2 + UMAX_PP_RESERVE] =
2300 dev->buf[x + (y - 2 * delta) * ll + UMAX_PP_RESERVE];
2307 dev->buf + UMAX_PP_RESERVE + dev->buflen - 2 * delta * ll,
2309 free (dev->buf);
2310 dev->buf = lbuf;
2312 dev->bufread = 0;
2316 length = dev->buflen - dev->bufread;
2323 if (dev->color == UMAX_PP_MODE_COLOR)
2324 memcpy (buf, dev->buf + dev->bufread + UMAX_PP_RESERVE, length);
2326 memcpy (buf, dev->buf + dev->bufread, length);
2328 dev->bufread += length;
2329 dev->read += length;
2339 Umax_PP_Device *dev = handle;
2343 if (dev->state == UMAX_PP_STATE_IDLE)
2348 if (dev->state == UMAX_PP_STATE_SCANNING)
2352 dev->buflen = 0;
2354 dev->state = UMAX_PP_STATE_CANCELLED;
2370 dev->state = UMAX_PP_STATE_IDLE;