diff options
Diffstat (limited to 'backend/mustek_usb_high.c')
| -rw-r--r-- | backend/mustek_usb_high.c | 2751 |
1 files changed, 2751 insertions, 0 deletions
diff --git a/backend/mustek_usb_high.c b/backend/mustek_usb_high.c new file mode 100644 index 0000000..f6a0125 --- /dev/null +++ b/backend/mustek_usb_high.c @@ -0,0 +1,2751 @@ +/* sane - Scanner Access Now Easy. + + Copyright (C) 2000 Mustek. + Originally maintained by Tom Wang <tom.wang@mustek.com.tw> + + Copyright (C) 2001, 2002 by Henning Meier-Geinitz. + + This file is part of the SANE package. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + This file implements a SANE backend for Mustek 1200UB and similar + USB flatbed scanners. */ + +#include "mustek_usb_high.h" +#include "mustek_usb_mid.c" + +/* ------------------------ calibration functions ------------------------- */ + +static SANE_Byte gray_map[8] = { + 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 +}; + +static inline double +filter_lower_end (SANE_Int * buffer, SANE_Word total_count, + SANE_Word filter_count) +{ + SANE_Word bound = total_count - 1; + SANE_Word left_count = total_count - filter_count; + SANE_Int temp = 0; + SANE_Word i, j; + SANE_Int sum = 0; + + for (i = 0; i < bound; i++) + { + for (j = 0; j < bound - i; j++) + { + if (buffer[j + 1] > buffer[j]) + { + temp = buffer[j]; + buffer[j] = buffer[j + 1]; + buffer[j + 1] = temp; + } + } + } + for (i = 0; i < left_count; i++) + sum += buffer[i]; + return (double) sum; +} + +SANE_Status +usb_high_cal_init (Calibrator * cal, SANE_Byte type, SANE_Word target_white, + SANE_Word target_dark) +{ + DBG (5, "usb_high_cal_init: start, cal=%p, type=%d, target_white=%d " + "target_dark=%d\n", (void *) cal, type, target_white, target_dark); + cal->is_prepared = SANE_FALSE; + cal->k_white = NULL; + cal->k_dark = NULL; + /* Working Buffer */ + cal->white_line = NULL; + cal->dark_line = NULL; + cal->white_buffer = NULL; + /* Necessary Parameters */ + cal->k_white_level = 240 << 8; + cal->k_dark_level = 0; + cal->threshold = 2048; + cal->major_average = 0; + cal->minor_average = 0; + cal->filter = 0; + cal->white_needed = 0; + cal->dark_needed = 0; + cal->max_width = 0; + cal->width = 100; + cal->gamma_table = 0; + cal->calibrator_type = type; + cal->k_white_level = target_white / 16; + cal->k_dark_level = 0; + DBG (5, "usb_high_cal_init: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_exit (Calibrator * cal) +{ + DBG (5, "usb_high_cal_exit: start\n"); + + if (!cal) + { + DBG (3, "usb_high_cal_exit: cal == NULL\n"); + return SANE_STATUS_INVAL; + } + + if (!cal->is_prepared) + { + DBG (3, "usb_high_cal_exit: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + DBG (5, "usb_high_cal_exit: 1\n"); + + if (cal->k_dark) + { + free (cal->k_dark); + } + cal->k_dark = NULL; + DBG (5, "usb_high_cal_exit: 2\n"); + if (cal->k_white) + { + free (cal->k_white); + } + cal->k_white = NULL; + DBG (5, "usb_high_cal_exit: 3\n"); + + cal->is_prepared = SANE_FALSE; + DBG (5, "usb_high_cal_exit: 4\n"); + DBG (5, "usb_high_cal_exit: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_embed_gamma (Calibrator * cal, SANE_Word * gamma_table) +{ + DBG (5, "usb_high_cal_embed_gamma: start\n"); + cal->gamma_table = gamma_table; + DBG (5, "usb_high_cal_embed_gamma: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_prepare (Calibrator * cal, SANE_Word max_width) +{ + DBG (5, "usb_high_cal_Parepare: start\n"); + + if (cal->is_prepared) + { + DBG (3, "usb_high_cal_Parepare: is_prepared\n"); + return SANE_STATUS_INVAL; + } + + if (cal->k_white) + { + free (cal->k_white); + } + cal->k_white = (SANE_Word *) malloc (max_width * sizeof (SANE_Word)); + if (!cal->k_white) + return SANE_STATUS_NO_MEM; + + if (cal->k_dark) + { + free (cal->k_dark); + } + cal->k_dark = (SANE_Word *) malloc (max_width * sizeof (SANE_Word)); + if (!cal->k_dark) + return SANE_STATUS_NO_MEM; + + cal->max_width = max_width; + + cal->is_prepared = SANE_TRUE; + + DBG (5, "usb_high_cal_Parepare: exit\n"); + return SANE_STATUS_GOOD; +} + + +SANE_Status +usb_high_cal_setup (Calibrator * cal, SANE_Word major_average, + SANE_Word minor_average, SANE_Word filter, + SANE_Word width, SANE_Word * white_needed, + SANE_Word * dark_needed) +{ + SANE_Int i; + + DBG (5, "usb_high_cal_setup: start\n"); + + if (!cal->is_prepared) + { + DBG (3, "usb_high_cal_setup: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + if (major_average == 0) + { + DBG (3, "usb_high_cal_setup: major_average==0\n"); + return SANE_STATUS_INVAL; + } + if (minor_average == 0) + { + DBG (3, "usb_high_cal_setup: minor_average==0\n"); + return SANE_STATUS_INVAL; + } + if (width > cal->max_width) + { + DBG (3, "usb_high_cal_setup: width>max_width\n"); + return SANE_STATUS_INVAL; + } + + cal->major_average = major_average; + cal->minor_average = minor_average; + cal->filter = filter; + cal->width = width; + cal->white_needed = major_average * 16 + filter; + cal->dark_needed = major_average * 16; + *white_needed = cal->white_needed; + *dark_needed = cal->dark_needed; + + if (cal->white_line) + { + free (cal->white_line); + } + cal->white_line = (double *) malloc (cal->width * sizeof (double)); + if (!cal->white_line) + return SANE_STATUS_NO_MEM; + + if (cal->dark_line) + { + free (cal->dark_line); + } + cal->dark_line = (double *) malloc (cal->width * sizeof (double)); + if (!cal->dark_line) + return SANE_STATUS_NO_MEM; + + for (i = 0; i < cal->width; i++) + { + cal->white_line[i] = 0.0; + cal->dark_line[i] = 0.0; + } + + if (cal->white_buffer) + { + free (cal->white_buffer); + } + cal->white_buffer = + (SANE_Int *) malloc (cal->white_needed * cal->width * sizeof (SANE_Int)); + if (!cal->white_buffer) + return SANE_STATUS_NO_MEM; + + for (i = 0; i < cal->white_needed * cal->width; i++) + { + *(cal->white_buffer + i) = 0; + } + + return SANE_STATUS_GOOD; + DBG (5, "usb_high_cal_setup: start\n"); +} + +SANE_Status +usb_high_cal_evaluate_white (Calibrator * cal, double factor) +{ + /* Caculate white_line */ + double loop_division; + double average; + SANE_Int *buffer; + SANE_Word i, j; + + DBG (5, "usb_high_cal_evaluate_white: start\n"); + loop_division = (double) (cal->major_average * cal->minor_average); + buffer = (SANE_Int *) malloc (cal->white_needed * sizeof (SANE_Int)); + if (!buffer) + return SANE_STATUS_NO_MEM; + + if (cal->white_buffer == NULL) + { + DBG (3, "usb_high_cal_evaluate_white: white_buffer==NULL\n"); + return SANE_STATUS_NO_MEM; + } + + for (i = 0; i < cal->width; i++) + { + for (j = 0; j < cal->white_needed; j++) + { + *(buffer + j) = *(cal->white_buffer + j * cal->width + i); + } + average = + filter_lower_end (buffer, cal->white_needed, + cal->filter) * factor / loop_division; + if (average >= 4096.0) + cal->white_line[i] = 4095.9999; + else if (average < 0.0) + cal->white_line[i] = 0.0; + else + cal->white_line[i] = average; + } + free (buffer); + buffer = NULL; + free (cal->white_buffer); + cal->white_buffer = NULL; + DBG (5, "usb_high_cal_evaluate_white: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_evaluate_dark (Calibrator * cal, double factor) +{ + SANE_Word i; + double loop_division; + + DBG (5, "usb_high_cal_evaluate_dark: start\n"); + /* Caculate dark_line */ + factor *= 16.0; + loop_division = (double) (cal->major_average * cal->minor_average); + for (i = 0; i < cal->width; i++) + { + cal->dark_line[i] /= loop_division; + cal->dark_line[i] -= factor; + if (cal->dark_line[i] < 0.0) + cal->dark_line[i] = 0.0; + } + DBG (5, "usb_high_cal_evaluate_dark: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_evaluate_calibrator (Calibrator * cal) +{ + SANE_Int average = 0; + SANE_Word i; + + DBG (5, "usb_high_cal_evaluate_calibrator: start\n"); + if (cal->white_line == NULL) + { + DBG (3, "usb_high_cal_evaluate_calibrator: white_line==NULL\n"); + return SANE_FALSE; + } + if (cal->dark_line == NULL) + { + DBG (3, "usb_high_cal_evaluate_calibrator: dark_line==NULL\n"); + return SANE_FALSE; + } + + for (i = 0; i < cal->width; i++) + { + average = (SANE_Int) (cal->white_line[i]) + - (SANE_Int) (cal->dark_line[i]); + if (average <= 0) + average = 1; + else if (average >= 4096) + average = 4095; + cal->k_white[i] = (SANE_Word) (average); + cal->k_dark[i] = (SANE_Word) (cal->dark_line[i]); + } + free (cal->dark_line); + cal->dark_line = NULL; + free (cal->white_line); + cal->white_line = NULL; + + DBG (5, "usb_high_cal_evaluate_calibrator: start\n"); + return SANE_STATUS_GOOD; +} + +/* virtual function switcher */ +SANE_Status +usb_high_cal_fill_in_white (Calibrator * cal, SANE_Word major, + SANE_Word minor, void *white_pattern) +{ + DBG (5, "usb_high_cal_fill_in_white: start\n"); + switch (cal->calibrator_type) + { + case I8O8RGB: + case I8O8MONO: + return usb_high_cal_i8o8_fill_in_white (cal, major, minor, + white_pattern); + break; + case I4O1MONO: + return usb_high_cal_i4o1_fill_in_white (cal, major, minor, + white_pattern); + break; + } + DBG (5, "usb_high_cal_fill_in_white: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_fill_in_dark (Calibrator * cal, SANE_Word major, SANE_Word minor, + void *dark_pattern) +{ + DBG (5, "usb_high_cal_fill_in_dark: start\n"); + switch (cal->calibrator_type) + { + case I8O8RGB: + case I8O8MONO: + return usb_high_cal_i8o8_fill_in_dark (cal, major, minor, dark_pattern); + break; + case I4O1MONO: + return usb_high_cal_i4o1_fill_in_dark (cal, major, minor, dark_pattern); + break; + } + DBG (5, "usb_high_cal_fill_in_dark: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_calibrate (Calibrator * cal, void *src, void *target) +{ + DBG (5, "usb_high_cal_calibrate: start\n"); + switch (cal->calibrator_type) + { + case I8O8RGB: + return usb_high_cal_i8o8_rgb_calibrate (cal, src, target); + break; + case I8O8MONO: + return usb_high_cal_i8o8_mono_calibrate (cal, src, target); + break; + case I4O1MONO: + return usb_high_cal_i4o1_calibrate (cal, src, target); + break; + } + DBG (5, "usb_high_cal_calibrate: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i8o8_fill_in_white (Calibrator * cal, SANE_Word major, + SANE_Word minor, void *white_pattern) +{ + SANE_Byte *pattern; + SANE_Word j; + + pattern = (SANE_Byte *) white_pattern; + + DBG (5, "usb_high_cal_i8o8_fill_in_white: start, minor=%d\n", minor); + if (!cal->is_prepared) + { + DBG (3, "usb_high_cal_i8o8_fill_in_white: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + if (cal->white_needed == 0) + { + DBG (3, "usb_high_cal_i8o8_fill_in_white: white_needed==0\n"); + return SANE_STATUS_INVAL; + } + + for (j = 0; j < cal->width; j++) + { + *(cal->white_buffer + major * cal->width + j) += + (SANE_Int) (pattern[j]); + } + DBG (5, "usb_high_cal_i8o8_fill_in_white: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i8o8_fill_in_dark (Calibrator * cal, SANE_Word major, + SANE_Word minor, void *dark_pattern) +{ + SANE_Byte *pattern = (SANE_Byte *) dark_pattern; + SANE_Word j; + + DBG (5, "usb_high_cal_i8o8_fill_in_dark: start, major=%d, minor=%d\n", + major, minor); + if (!cal->is_prepared) + { + DBG (3, "usb_high_cal_i8o8_fill_in_dark: !is_prepared\n"); + return SANE_FALSE; + } + if (cal->dark_needed == 0) + { + DBG (3, "usb_high_cal_i8o8_fill_in_dark: dark_needed==0\n"); + return SANE_FALSE; + } + + for (j = 0; j < cal->width; j++) + { + cal->dark_line[j] += (double) (pattern[j]); + } + DBG (5, "usb_high_cal_i8o8_fill_in_dark: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i4o1_fill_in_white (Calibrator * cal, SANE_Word major, + SANE_Word minor, void *white_pattern) +{ + SANE_Byte *pattern; + SANE_Word j = 0; + + pattern = (SANE_Byte *) white_pattern; + + DBG (5, "usb_high_cal_i4o1_fill_in_white: minor=%d\n", minor); + if (!cal->is_prepared) + { + DBG (3, "usb_high_cal_i4o1_fill_in_white: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + if (cal->white_needed == 0) + { + DBG (3, "usb_high_cal_i4o1_fill_in_white: white_needed==0\n"); + return SANE_STATUS_INVAL; + } + + while (j < cal->width) + { + *(cal->white_buffer + major * cal->width + j) += + (SANE_Int) (*(pattern) & 0xf0); + j++; + if (j >= cal->width) + break; + *(cal->white_buffer + major * cal->width + j) += + (SANE_Int) ((SANE_Byte) (*(pattern++) << 4)); + j++; + } + DBG (5, "usb_high_cal_i8o8_fill_in_white: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i4o1_fill_in_dark (Calibrator * cal, SANE_Word major, + SANE_Word minor, void *dark_pattern) +{ + SANE_Byte *pattern; + SANE_Word j = 0; + + pattern = (SANE_Byte *) dark_pattern; + + DBG (5, "usb_high_cal_i4o1_fill_in_dark: start, major=%d, minor=%d\n", + major, minor); + if (!cal->is_prepared) + { + DBG (3, "usb_high_cal_i4o1_fill_in_dark: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + if (cal->dark_needed == 0) + { + DBG (5, "usb_high_cal_i4o1_fill_in_dark: dark_needed==0\n"); + return SANE_STATUS_INVAL; + } + + while (j < cal->width) + { + cal->dark_line[j++] += (double) (*(pattern) & 0xf0); + if (j >= cal->width) + break; + cal->dark_line[j++] += (double) ((SANE_Byte) (*(pattern++) << 4)); + } + DBG (5, "usb_high_cal_i4o1_fill_in_dark: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i8o8_mono_calibrate (Calibrator * cal, void *src, void *target) +{ + SANE_Byte *gray_src; + SANE_Byte *gray_target; + SANE_Int base = 0; + SANE_Word value = 0; + SANE_Word i; + + DBG (5, "usb_high_cal_i8o8_mono_calibrate: start\n"); + + gray_src = (SANE_Byte *) src; + gray_target = (SANE_Byte *) target; + + if (cal->gamma_table == NULL) + { + SANE_Word k_white_level = cal->k_white_level >> 4; + for (i = 0; i < cal->width; i++) + { + base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4) + - (SANE_Int) (cal->k_dark[i]); + if (base < 0) + base = 0; + value = ((SANE_Word) (base) * k_white_level) / cal->k_white[i]; + if (value > 0x00ff) + value = 0x00ff; + gray_target[i] = (SANE_Byte) (value); + } + } + else + { + for (i = 0; i < cal->width; i++) + { + base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4) + - (SANE_Int) (cal->k_dark[i]); + if (base < 0) + base = 0; + value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[i]; + if (value > 0x0fff) + value = 0x0fff; + gray_target[i] = (SANE_Byte) (cal->gamma_table[value]); + } + } + DBG (5, "usb_high_cal_i8o8_mono_calibrate: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i8o8_rgb_calibrate (Calibrator * cal, void *src, void *target) +{ + SANE_Byte *gray_src; + SANE_Byte *rgb_target; + SANE_Int base = 0; + SANE_Word value = 0; + SANE_Word i; + + DBG (5, "usb_high_cal_i8o8_rgb_calibrate: start\n"); + gray_src = (SANE_Byte *) src; + rgb_target = (SANE_Byte *) target; + + if (cal->gamma_table == NULL) + { + SANE_Word k_white_level = cal->k_white_level >> 4; + for (i = 0; i < cal->width; i++) + { + base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4) + - (SANE_Int) (cal->k_dark[i]); + if (base < 0) + base = 0; + value = ((SANE_Word) (base) * k_white_level) / cal->k_white[i]; + if (value > 0x00ff) + value = 0x00ff; + *rgb_target = (SANE_Byte) (value); + rgb_target += 3; + } + } + else + { + for (i = 0; i < cal->width; i++) + { + base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4) + - (SANE_Int) (cal->k_dark[i]); + if (base < 0) + base = 0; + value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[i]; + if (value > 0x0fff) + value = 0x0fff; + *(rgb_target) = (SANE_Byte) (cal->gamma_table[value]); + rgb_target += 3; + } + } + DBG (5, "usb_high_cal_i8o8_rgb_calibrate: start\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_cal_i4o1_calibrate (Calibrator * cal, void *src, void *target) +{ + SANE_Byte *local_src; + SANE_Byte *local_target; + SANE_Int base = 0; + SANE_Word value = 0; + SANE_Word j = 0; + SANE_Int count = 0; + + DBG (5, "usb_high_cal_i4o1_calibrate: start\n"); + local_src = (SANE_Byte *) src; + local_target = (SANE_Byte *) target; + + *local_target = 0; + while (j < cal->width) + { + base = + (SANE_Int) ((SANE_Word) (*local_src & 0xf0) << 4) + - (SANE_Int) (cal->k_dark[j]); + if (base < 0) + base = 0; + value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[j]; + if (value > 0x0fff) + value = 0x0fff; + if (value >= cal->threshold) + *(local_target) |= gray_map[count]; + count++; + j++; + if (j >= cal->width) + break; + base = (SANE_Int) ((SANE_Word) (*(local_src++) & 0x0f) << 8) - + (SANE_Int) (cal->k_dark[j]); + if (base < 0) + base = 0; + value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[j]; + if (value > 0x0fff) + value = 0x0fff; + if (value >= cal->threshold) + *(local_target) |= gray_map[count]; + count++; + if (count >= 8) + { + local_target++; + *local_target = 0; + count = 0; + } + j++; + } + DBG (5, "usb_high_cal_i4o1_calibrate: exit\n"); + return SANE_STATUS_GOOD; +} + + +/* --------------------------- scan functions ----------------------------- */ + + +SANE_Status +usb_high_scan_init (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_init: start\n"); + + dev->init_bytes_per_strip = 8 * 1024; + dev->adjust_length_300 = 2560; + dev->adjust_length_600 = 5120; + dev->init_min_expose_time = 4992; + dev->init_skips_per_row_300 = 56; /* this value must be times of 6 */ + dev->init_skips_per_row_600 = 72; /* this value must be times of 6 */ + dev->init_j_lines = 154; + dev->init_k_lines = 16; + dev->init_k_filter = 8; + dev->init_k_loops = 2; + dev->init_pixel_rate_lines = 50; + dev->init_pixel_rate_filts = 37; + dev->init_powerdelay_lines = 2; + dev->init_home_lines = 160; + dev->init_dark_lines = 50; + dev->init_k_level = 245; + dev->init_max_power_delay = 240; + dev->init_min_power_delay = 136; + dev->init_adjust_way = 1; + dev->init_green_black_factor = 0.0; + dev->init_blue_black_factor = 0.0; + dev->init_red_black_factor = 0.0; + dev->init_gray_black_factor = 0.0; + dev->init_green_factor = 0.82004; + dev->init_blue_factor = 0.84954; + dev->init_red_factor = 0.826375; + dev->init_gray_factor = 0.833375; + + dev->init_red_rgb_600_pga = 8; + dev->init_green_rgb_600_pga = 8; + dev->init_blue_rgb_600_pga = 8; + dev->init_mono_600_pga = 8; + dev->init_red_rgb_300_pga = 8; + dev->init_green_rgb_300_pga = 8; + dev->init_blue_rgb_300_pga = 8; + dev->init_mono_300_pga = 8; + dev->init_expose_time = 9024; + dev->init_red_rgb_600_power_delay = 80; + dev->init_green_rgb_600_power_delay = 80; + dev->init_blue_rgb_600_power_delay = 80; + dev->init_red_mono_600_power_delay = 80; + dev->init_green_mono_600_power_delay = 80; + dev->init_blue_mono_600_power_delay = 80; + dev->init_red_rgb_300_power_delay = 80; + dev->init_green_rgb_300_power_delay = 80; + dev->init_blue_rgb_300_power_delay = 80; + dev->init_red_mono_300_power_delay = 80; + dev->init_green_mono_300_power_delay = 80; + dev->init_blue_mono_300_power_delay = 80; + dev->init_threshold = 128; + + dev->init_top_ref = 128; + dev->init_front_end = 16; + dev->init_red_offset = 0; + dev->init_green_offset = 0; + dev->init_blue_offset = 0; + + dev->init_rgb_24_back_track = 80; + dev->init_mono_8_back_track = 80; + + dev->is_open = SANE_FALSE; + dev->is_prepared = SANE_FALSE; + dev->expose_time = 4000; + dev->width = 2550; + dev->x_dpi = 300; + dev->y_dpi = 300; + dev->scan_mode = RGB24EXT; + dev->bytes_per_row = 2550 * 3; + dev->dummy = 0; + dev->bytes_per_strip = 2550; + dev->image_buffer = NULL; + dev->red = NULL; + dev->green = NULL; + dev->blue = NULL; + dev->get_line = NULL; + dev->backtrack = NULL; + dev->is_adjusted_rgb_600_power_delay = SANE_FALSE; + dev->is_adjusted_mono_600_power_delay = SANE_FALSE; + dev->is_adjusted_rgb_300_power_delay = SANE_FALSE; + dev->is_adjusted_mono_300_power_delay = SANE_FALSE; + dev->is_evaluate_pixel_rate = SANE_FALSE; + dev->red_rgb_600_pga = 0; + dev->green_rgb_600_pga = 0; + dev->blue_rgb_600_pga = 0; + dev->mono_600_pga = 0; + dev->red_rgb_600_power_delay = 0; + dev->green_rgb_600_power_delay = 0; + dev->blue_rgb_600_power_delay = 0; + dev->red_mono_600_power_delay = 0; + dev->green_mono_600_power_delay = 0; + dev->blue_mono_600_power_delay = 0; + dev->red_rgb_300_pga = 0; + dev->green_rgb_300_pga = 0; + dev->blue_rgb_300_pga = 0; + dev->mono_300_pga = 0; + dev->red_rgb_300_power_delay = 0; + dev->green_rgb_300_power_delay = 0; + dev->blue_rgb_300_power_delay = 0; + dev->red_mono_300_power_delay = 0; + dev->green_mono_300_power_delay = 0; + dev->blue_mono_300_power_delay = 0; + dev->pixel_rate = 2000; + dev->threshold = 128; + dev->gamma_table = 0; + dev->skips_per_row = 0; + + + dev->red_calibrator = NULL; + dev->green_calibrator = NULL; + dev->blue_calibrator = NULL; + dev->mono_calibrator = NULL; + + dev->is_cis_detected = SANE_FALSE; + dev->is_sensor_detected = SANE_FALSE; + + RIE (usb_low_init (&dev->chip)); + + DBG (5, "usb_high_scan_init: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_exit (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_exit: start\n"); + if (!dev->chip) + { + DBG (5, "usb_high_scan_exit: already exited (`%s')\n", dev->name); + return SANE_STATUS_INVAL; + } + + RIE (usb_low_exit (dev->chip)); + dev->chip = 0; + DBG (5, "usb_high_scan_exit: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_prepare: start dev=%p\n", (void *) dev); + if (dev->is_prepared) + { + DBG (5, "usb_high_scan_prepare: is already prepared\n"); + return SANE_STATUS_GOOD; + } + if (dev->image_buffer) + { + free (dev->image_buffer); + } + dev->image_buffer = (SANE_Byte *) malloc (dev->init_bytes_per_strip * 3); + if (!dev->image_buffer) + return SANE_STATUS_NO_MEM; + + dev->red = dev->image_buffer; + dev->green = dev->image_buffer + dev->init_bytes_per_strip; + dev->blue = dev->image_buffer + dev->init_bytes_per_strip * 2; + + dev->is_prepared = SANE_TRUE; + DBG (5, "usb_high_scan_prepare: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_clearup (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_clearup: start, dev=%p\n", (void *) dev); + if (!dev->is_prepared) + { + DBG (3, "usb_high_scan_clearup: is not prepared\n"); + return SANE_STATUS_INVAL; + } + if (dev->image_buffer) + { + free (dev->image_buffer); + } + dev->image_buffer = NULL; + dev->red = NULL; + dev->green = NULL; + dev->blue = NULL; + + dev->is_prepared = SANE_FALSE; + DBG (5, "usb_high_scan_clearup: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_turn_power (Mustek_Usb_Device * dev, SANE_Bool is_on) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_turn_power: start, turn %s power\n", + is_on ? "on" : "off"); + + if (is_on) + { + if (dev->is_open) + { + DBG (3, "usb_high_scan_turn_power: wanted to turn on power, " + "but scanner already open\n"); + return SANE_STATUS_INVAL; + } + RIE (usb_low_open (dev->chip, dev->device_name)); + dev->is_open = SANE_TRUE; + RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + } + else + { + if (!dev->is_open) + { + DBG (3, "usb_high_scan_turn_power: wanted to turn off power, " + "but scanner already closed\n"); + return SANE_STATUS_INVAL; + } + RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE)); + RIE (usb_low_close (dev->chip)); + dev->is_open = SANE_FALSE; + } + + DBG (5, "usb_high_scan_turn_power: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_back_home (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_back_home: start\n"); + + if (!dev->is_open) + { + DBG (3, "usb_high_scan_back_home: not open\n"); + return SANE_STATUS_INVAL; + } + + RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time)); + RIE (usb_mid_motor_prepare_home (dev->chip)); + + DBG (5, "usb_high_scan_back_home: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_set_threshold (Mustek_Usb_Device * dev, SANE_Byte threshold) +{ + DBG (5, "usb_high_scan_set_threshold: start, dev=%p, threshold=%d\n", + (void *) dev, threshold); + + dev->threshold = threshold; + DBG (5, "usb_high_scan_set_threshold: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_embed_gamma (Mustek_Usb_Device * dev, SANE_Word * gamma_table) +{ + DBG (5, "usb_high_scan_embed_gamma: start, dev=%p, gamma_table=%p\n", + (void *) dev, (void *) gamma_table); + if (!dev->is_prepared) + { + DBG (5, "usb_high_scan_embed_gamma !is_prepared\n"); + return SANE_STATUS_INVAL; + } + + dev->gamma_table = gamma_table; + DBG (5, "usb_high_scan_embed_gamma: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_reset (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_reset: start\n"); + + if (!dev->is_open) + { + DBG (3, "usb_high_scan_reset: not open\n"); + return SANE_STATUS_INVAL; + } + if (!dev->is_prepared) + { + DBG (3, "usb_high_scan_reset: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + RIE (usb_high_scan_init_asic (dev, dev->chip->sensor)); + RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time)); + RIE (usb_mid_motor_prepare_home (dev->chip)); + RIE (usb_high_scan_set_threshold (dev, dev->init_threshold)); + RIE (usb_high_scan_embed_gamma (dev, NULL)); + dev->is_adjusted_rgb_600_power_delay = SANE_FALSE; + dev->is_adjusted_mono_600_power_delay = SANE_FALSE; + dev->is_adjusted_rgb_300_power_delay = SANE_FALSE; + dev->is_adjusted_mono_300_power_delay = SANE_FALSE; + dev->is_evaluate_pixel_rate = SANE_FALSE; + DBG (5, "usb_high_scan_reset: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_wait_carriage_home (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_wait_carriage_home: start\n"); + + status = usb_low_get_home_sensor (dev->chip); + + if (status != SANE_STATUS_GOOD) + { + RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time)); + RIE (usb_mid_motor_prepare_home (dev->chip)); + do + { + status = usb_low_get_home_sensor (dev->chip); + if (status != SANE_STATUS_GOOD) + usleep (18 * 1000); + } + while (status != SANE_STATUS_GOOD); + } + + /* No Motor & Forward */ + RIE (usb_low_move_motor_home (dev->chip, SANE_FALSE, SANE_FALSE)); + DBG (5, "usb_high_scan_wait_carriage_home: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_hardware_calibration (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_hardware_calibration: start\n"); + + if (dev->is_cis_detected) + RIE (usb_high_scan_safe_forward (dev, dev->init_home_lines)); + + switch (dev->init_adjust_way) + { + case 1: /* CIS */ + switch (dev->scan_mode) + { + case RGB24EXT: + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + { + dev->expose_time = dev->init_expose_time; + dev->red_rgb_600_pga = dev->init_red_rgb_600_pga; + dev->green_rgb_600_pga = dev->init_green_rgb_600_pga; + dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga; + RIE (usb_high_scan_adjust_rgb_600_power_delay (dev)); + } + else + { + dev->expose_time = dev->init_expose_time; + dev->red_rgb_300_pga = dev->init_red_rgb_300_pga; + dev->green_rgb_300_pga = dev->init_green_rgb_300_pga; + dev->blue_rgb_300_pga = dev->init_blue_rgb_300_pga; + RIE (usb_high_scan_adjust_rgb_300_power_delay (dev)); + } + break; + case GRAY8EXT: + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + { + dev->expose_time = dev->init_expose_time; + dev->mono_600_pga = dev->init_mono_600_pga; + RIE (usb_high_scan_evaluate_pixel_rate (dev)); + RIE (usb_high_scan_adjust_mono_600_power_delay (dev)); + } + else + { + dev->expose_time = dev->init_expose_time; + dev->mono_300_pga = dev->init_mono_300_pga; + RIE (usb_high_scan_evaluate_pixel_rate (dev)); + RIE (usb_high_scan_adjust_mono_300_power_delay (dev)); + } + break; + default: + break; + } + break; + case 3: /* CCD */ + switch (dev->scan_mode) + { + case RGB24EXT: + dev->red_rgb_600_pga = dev->init_red_rgb_600_pga; + dev->green_rgb_600_pga = dev->init_green_rgb_600_pga; + dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga; + dev->skips_per_row = dev->init_skips_per_row_600; + /* RIE(usb_high_scan_adjust_rgb_600_exposure (dev); fixme */ + /* RIE(usb_high_scan_adjust_rgb_600_offset (dev); fixme */ + /* RIE(usb_high_scan_adjust_rgb_600_pga (dev); fixme */ + /* m_isAdjustedRgb600Offset=FALSE; */ + /* RIE(usb_high_scan_adjust_rgb_600_offset (dev); fixme */ + /* RIE(usb_high_scan_adjust_rgb_600_skips_per_row (dev); fixme */ + break; + case GRAY8EXT: + dev->mono_600_pga = dev->init_mono_600_pga; + dev->skips_per_row = dev->init_skips_per_row_600; + RIE (usb_high_scan_adjust_mono_600_exposure (dev)); + /* RIE(usb_high_scan_adjust_mono_600_offset (dev); fixme */ + /* RIE(usb_high_scan_adjust_mono_600_pga (dev); fixme */ + dev->is_adjusted_mono_600_offset = SANE_FALSE; + /* RIE(usb_high_scan_adjust_mono_600_offset (dev); fixme */ + /* RIE(usb_high_scan_adjust_mono_600_skips_per_row (dev); fixme */ + break; + default: + break; + } + break; + default: + dev->expose_time = dev->init_expose_time; + dev->red_rgb_600_power_delay = dev->init_red_rgb_600_power_delay; + dev->green_rgb_600_power_delay = dev->init_green_rgb_600_power_delay; + dev->blue_rgb_600_power_delay = dev->init_blue_rgb_600_power_delay; + dev->red_mono_600_power_delay = dev->init_red_mono_600_power_delay; + dev->green_mono_600_power_delay = dev->init_green_mono_600_power_delay; + dev->blue_mono_600_power_delay = dev->init_blue_mono_600_power_delay; + dev->red_rgb_600_pga = dev->init_red_rgb_600_pga; + dev->green_rgb_600_pga = dev->init_green_rgb_600_pga; + dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga; + dev->mono_600_pga = dev->init_mono_600_pga; + dev->red_rgb_300_power_delay = dev->init_red_rgb_300_power_delay; + dev->green_rgb_300_power_delay = dev->init_green_rgb_300_power_delay; + dev->blue_rgb_300_power_delay = dev->init_blue_rgb_300_power_delay; + dev->red_mono_300_power_delay = dev->init_red_mono_300_power_delay; + dev->green_mono_300_power_delay = dev->init_green_mono_300_power_delay; + dev->blue_mono_300_power_delay = dev->init_blue_mono_300_power_delay; + dev->red_rgb_300_pga = dev->init_red_rgb_300_pga; + dev->green_rgb_300_pga = dev->init_green_rgb_300_pga; + dev->blue_rgb_300_pga = dev->init_blue_rgb_300_pga; + dev->mono_300_pga = dev->init_mono_300_pga; + break; + } + DBG (5, "usb_high_scan_hardware_calibration: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_line_calibration (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_line_calibration: start\n"); + switch (dev->scan_mode) + { + case RGB24EXT: + RIE (usb_high_scan_prepare_rgb_24 (dev)); + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + RIE (usb_high_scan_prepare_rgb_signal_600_dpi (dev)); + else + RIE (usb_high_scan_prepare_rgb_signal_300_dpi (dev)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, dev->x_dpi)); + RIE (usb_high_scan_calibration_rgb_24 (dev)); + break; + case GRAY8EXT: + RIE (usb_high_scan_prepare_mono_8 (dev)); + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + RIE (usb_high_scan_prepare_mono_signal_600_dpi (dev)); + else + RIE (usb_high_scan_prepare_mono_signal_300_dpi (dev)); + RIE (usb_mid_sensor_prepare_mono (dev->chip, dev->x_dpi)); + RIE (usb_high_scan_calibration_mono_8 (dev)); + break; + default: + DBG (3, "usb_high_scan_line_calibration: mode not matched\n"); + return SANE_STATUS_INVAL; + break; + } + DBG (5, "usb_high_scan_line_calibration: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare_scan (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_scan: start\n"); + switch (dev->scan_mode) + { + case RGB24EXT: + RIE (usb_high_scan_prepare_rgb_24 (dev)); + dev->get_line = &usb_high_scan_get_rgb_24_bit_line; + dev->backtrack = &usb_high_scan_backtrack_rgb_24; + + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + RIE (usb_high_scan_prepare_rgb_signal_600_dpi (dev)); + else + RIE (usb_high_scan_prepare_rgb_signal_300_dpi (dev)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, dev->x_dpi)); + RIE (usb_mid_motor_prepare_rgb (dev->chip, dev->y_dpi)); + break; + case GRAY8EXT: + RIE (usb_high_scan_prepare_mono_8 (dev)); + dev->get_line = &usb_high_scan_get_mono_8_bit_line; + dev->backtrack = &usb_high_scan_backtrack_mono_8; + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + RIE (usb_high_scan_prepare_mono_signal_600_dpi (dev)); + else + RIE (usb_high_scan_prepare_mono_signal_300_dpi (dev)); + RIE (usb_mid_sensor_prepare_mono (dev->chip, dev->x_dpi)); + RIE (usb_mid_motor_prepare_mono (dev->chip, dev->y_dpi)); + break; + default: + DBG (5, "usb_high_scan_prepare_scan: unmatched mode\n"); + return SANE_STATUS_INVAL; + break; + } + DBG (5, "usb_high_scan_prepare_scan: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_suggest_parameters (Mustek_Usb_Device * dev, SANE_Word dpi, + SANE_Word x, SANE_Word y, SANE_Word width, + SANE_Word height, Colormode color_mode) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_suggest_parameters: start\n"); + + RIE (usb_high_scan_detect_sensor (dev)); + /* Looking up Optical Y Resolution */ + RIE (usb_mid_motor_get_dpi (dev->chip, dpi, &dev->y_dpi)); + /* Looking up Optical X Resolution */ + RIE (usb_mid_sensor_get_dpi (dev->chip, dpi, &dev->x_dpi)); + + dev->x = x * dev->x_dpi / dpi; + dev->y = y * dev->y_dpi / dpi; + dev->width = width * dev->x_dpi / dpi; + dev->height = height * dev->y_dpi / dpi; + + switch (color_mode) + { + case RGB24: + dev->scan_mode = RGB24EXT; + dev->bytes_per_row = dev->width * 3; + dev->bpp = 24; + break; + case GRAY8: + dev->scan_mode = GRAY8EXT; + dev->bpp = 8; + dev->bytes_per_row = dev->width; + break; + default: + DBG (3, "usb_high_scan_suggest_parameters: unmatched mode\n"); + return SANE_STATUS_INVAL; + break; + } + DBG (5, "usb_high_scan_suggest_parameters: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_detect_sensor (Mustek_Usb_Device * dev) +{ + if (dev->is_sensor_detected) + { + DBG (5, "usb_high_scan_detect_sensor: sensor already detected\n"); + return SANE_STATUS_GOOD; + } + dev->is_sensor_detected = SANE_TRUE; + + switch (dev->chip->scanner_type) + { + case MT_600CU: + dev->chip->sensor = ST_CANON300; + dev->chip->motor = MT_600; + dev->is_cis_detected = SANE_TRUE; + DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 300 dpi, motor=" + "600 dpi\n"); + break; + case MT_1200USB: + dev->chip->sensor = ST_NEC600; + dev->chip->motor = MT_1200; + dev->init_min_expose_time = 2250; + dev->init_skips_per_row_600 = 0; + dev->init_home_lines = 32; + dev->init_dark_lines = 10; + dev->init_max_power_delay = 220; + dev->init_min_power_delay = 220; + dev->init_adjust_way = 3; + dev->init_red_rgb_600_pga = 30; + dev->init_green_rgb_600_pga = 30; + dev->init_blue_rgb_600_pga = 30; + dev->init_mono_600_pga = 30; + dev->init_expose_time = 16000; + + dev->init_top_ref = 6; + dev->init_front_end = 12; + dev->init_red_offset = 128; + dev->init_green_offset = 128; + dev->init_blue_offset = 128; + + dev->init_rgb_24_back_track = 0; + dev->init_mono_8_back_track = 40; + + dev->is_cis_detected = SANE_FALSE; + + DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 600 dpi, motor=" + "1200 dpi\n"); + break; + case MT_1200UB: + case MT_1200CU_PLUS: + case MT_1200CU: /* need to check if it's a 300600 or 600 dpi sensor */ + { + SANE_Byte *buffer; + static SANE_Word l_temp = 0, r_temp = 0; + SANE_Int i; + SANE_Status status; + SANE_Word lines_left; + + dev->chip->motor = MT_1200; + dev->is_cis_detected = SANE_TRUE; + + buffer = NULL; + l_temp = 0; + r_temp = 0; + + buffer = (SANE_Byte *) malloc (dev->init_bytes_per_strip); + + if (!buffer) + return SANE_STATUS_NO_MEM; + + for (i = 0; i < 5400; i++) + buffer[i] = 0xaa; + + dev->scan_mode = GRAY8EXT; + dev->x_dpi = 600; + dev->y_dpi = 1200; + dev->width = 5400; + + RIE (usb_high_scan_init_asic (dev, ST_CANON600)); + RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE)); + RIE (usb_low_enable_motor (dev->chip, SANE_TRUE)); /* Enable Motor */ + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + RIE (usb_low_invert_image (dev->chip, SANE_FALSE)); + RIE (usb_low_set_image_dpi (dev->chip, SANE_TRUE, SW_P6P6)); + dev->bytes_per_strip = dev->adjust_length_600; + dev->bytes_per_row = 5400; + dev->dummy = 0; + + RIE (usb_high_scan_wait_carriage_home (dev)); + RIE (usb_high_scan_hardware_calibration (dev)); + RIE (usb_high_scan_prepare_scan (dev)); + + /* Get Data */ + RIE (usb_low_start_rowing (dev->chip)); + RIE (usb_low_get_row (dev->chip, buffer, &lines_left)); + RIE (usb_low_stop_rowing (dev->chip)); + /* Calculate */ + for (i = 0; i < 256; i++) + l_temp = l_temp + buffer[512 + i]; + for (i = 0; i < 256; i++) + r_temp = r_temp + buffer[3500 + i]; + + l_temp = l_temp / 256; + r_temp = r_temp / 256; + + /* 300/600 switch CIS or 600 CIS */ + DBG (5, "usb_high_scan_detect_sensor: l_temp=%d, r_temp=%d\n", + l_temp, r_temp); + if (r_temp > 50) + { + dev->chip->sensor = ST_CANON600; + DBG (4, + "usb_high_scan_detect_sensor: sensor=Canon 600 dpi, motor=" + "1200 dpi\n"); + } + else + { + DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 300/600 dpi, " + "motor=1200 dpi\n"); + dev->chip->sensor = ST_CANON300600; + } + + /* Release Resource */ + free (buffer); + buffer = NULL; + + break; + } + default: + DBG (5, "usb_high_scan_detect_sensor: I don't know this scanner type " + "(%d)\n", dev->chip->scanner_type); + return SANE_STATUS_INVAL; + } + + return SANE_STATUS_GOOD; +} + + +SANE_Status +usb_high_scan_setup_scan (Mustek_Usb_Device * dev, Colormode color_mode, + SANE_Word x_dpi, SANE_Word y_dpi, + SANE_Bool is_invert, SANE_Word x, SANE_Word y, + SANE_Word width) +{ + SANE_Status status; + SANE_Word upper_bound; + SANE_Word left_bound; + + DBG (5, "usb_high_scan_setup_scan: start, is_invert=%d\n", is_invert); + if (!dev->is_open) + { + DBG (5, "usb_high_scan_setup_scan: not open\n"); + return SANE_STATUS_INVAL; + } + if (!dev->is_prepared) + { + DBG (5, "usb_high_scan_setup_scan: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + + RIE (usb_high_scan_init_asic (dev, dev->chip->sensor)); + RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE)); + RIE (usb_low_enable_motor (dev->chip, SANE_TRUE)); /* Enable Motor */ + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + RIE (usb_low_invert_image (dev->chip, SANE_FALSE)); + if (!dev->is_cis_detected) + { + usb_mid_front_set_front_end_mode (dev->chip, 16); + usb_mid_front_enable (dev->chip, SANE_TRUE); + usb_mid_front_set_top_reference (dev->chip, 244); + usb_mid_front_set_rgb_signal (dev->chip); + } + + /* Compute necessary variables */ + dev->scan_mode = color_mode; + dev->x_dpi = x_dpi; + dev->y_dpi = y_dpi; + dev->width = width; + + switch (dev->scan_mode) + { + case RGB24EXT: + dev->bytes_per_row = 3 * dev->width; + upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines; + break; + case GRAY8EXT: + dev->bytes_per_row = dev->width; + upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines + 4; + /* fixme */ + break; + default: + upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines + 4; + break; + } + + if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi)) + { + /* in 600dpi */ + left_bound = (x * 600 / dev->x_dpi) + dev->init_skips_per_row_600; + dev->skips_per_row = (((left_bound % 32) * dev->x_dpi + 300) / 600); + } + else + { + /* in 300dpi */ + left_bound = (x * 300 / dev->x_dpi) + dev->init_skips_per_row_300; + dev->skips_per_row = (((left_bound % 32) * dev->x_dpi + 150) / 300); + } + + dev->dummy = (left_bound / 32) * 32; + + switch (dev->scan_mode) + { + case RGB24EXT: + dev->bytes_per_strip = dev->skips_per_row + dev->width; + break; + case GRAY8EXT: + dev->bytes_per_strip = dev->skips_per_row + dev->width; + break; + default: + break; + } + + dev->bytes_per_strip = ((dev->bytes_per_strip + 1) / 2) * 2; + /* make bytes_per_strip is as 2n to advoid 64n+1 */ + + RIE (usb_high_scan_wait_carriage_home (dev)); + RIE (usb_high_scan_hardware_calibration (dev)); + RIE (usb_high_scan_line_calibration (dev)); + RIE (usb_high_scan_step_forward (dev, upper_bound)); + RIE (usb_high_scan_prepare_scan (dev)); + RIE (usb_low_start_rowing (dev->chip)); + /* pat_chromator fixme (init for calibration?) */ + DBG (5, "usb_high_scan_setup_scan: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_get_rows (Mustek_Usb_Device * dev, SANE_Byte * block, + SANE_Word rows, SANE_Bool is_order_invert) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_get_rows: start, %d rows\n", rows); + if (!dev->is_open) + { + DBG (3, "usb_high_scan_get_rows: not open\n"); + return SANE_STATUS_INVAL; + } + if (!dev->is_prepared) + { + DBG (3, "usb_high_scan_get_rows: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + while (rows > 0) + { + RIE ((*dev->get_line) (dev, block, is_order_invert)); + block += dev->bytes_per_row; + rows--; + } + DBG (5, "usb_high_scan_get_rows: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_stop_scan (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_stop_scan: start\n"); + if (!dev->is_open) + { + DBG (3, "usb_high_scan_stop_scan: not open\n"); + return SANE_STATUS_INVAL; + } + if (!dev->is_prepared) + { + DBG (3, "usb_high_scan_stop_scan: !is_prepared\n"); + return SANE_STATUS_INVAL; + } + switch (dev->scan_mode) + { + case RGB24EXT: + RIE (usb_high_cal_exit (dev->blue_calibrator)); + if (dev->blue_calibrator) + free (dev->blue_calibrator); + dev->blue_calibrator = NULL; + RIE (usb_high_cal_exit (dev->green_calibrator)); + if (dev->green_calibrator) + free (dev->green_calibrator); + dev->green_calibrator = NULL; + RIE (usb_high_cal_exit (dev->red_calibrator)); + if (dev->red_calibrator) + free (dev->red_calibrator); + dev->red_calibrator = NULL; + break; + case GRAY8EXT: + RIE (usb_high_cal_exit (dev->mono_calibrator)); + if (dev->mono_calibrator) + free (dev->mono_calibrator); + dev->mono_calibrator = NULL; + break; + default: + break; + } + + RIE (usb_low_stop_rowing (dev->chip)); + if (!dev->is_cis_detected) + RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE)); + + DBG (5, "usb_high_scan_stop_scan: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_init_asic (Mustek_Usb_Device * dev, Sensor_Type sensor) +{ + SANE_Byte ccd_dpi = 0; + SANE_Byte select = 0; + SANE_Byte adjust = 0; + SANE_Byte pin = 0; + SANE_Byte motor = 0; + SANE_Bool fix_pattern = SANE_FALSE; + SANE_Byte ad_timing = 0; + Banksize bank_size; + SANE_Status status; + + DBG (5, "usb_high_scan_init_asic: start\n"); + switch (sensor) + { + case ST_TOSHIBA600: + ccd_dpi = 32; + select = 240; + adjust = 0; + pin = 18; + motor = 0; + fix_pattern = SANE_FALSE; + ad_timing = 0; + bank_size = BS_16K; + DBG (5, "usb_high_scan_init_asic: sensor is set to TOSHIBA600\n"); + break; + case ST_CANON300: + ccd_dpi = 232; + select = 232; + adjust = 0; + pin = 18; + motor = 0; + fix_pattern = SANE_FALSE; + ad_timing = 1; + bank_size = BS_4K; + DBG (5, "usb_high_scan_init_asic: sensor is set to CANON300\n"); + break; + case ST_CANON300600: + ccd_dpi = 232; + select = 232; + adjust = 64; + pin = 18; + motor = 0; + fix_pattern = SANE_FALSE; + ad_timing = 1; + bank_size = BS_16K; + DBG (5, "usb_high_scan_init_asic: sensor is set to CANON300600\n"); + break; + case ST_CANON600: + ccd_dpi = 232; + select = 232; + adjust = 64; + pin = 18; + motor = 0; + fix_pattern = SANE_FALSE; + ad_timing = 1; + bank_size = BS_16K; + DBG (5, "usb_high_scan_init_asic: sensor is set to CANON600\n"); + break; + case ST_NEC600: /* fixme */ + ccd_dpi = 32; + select = 224; + adjust = 112; + pin = 18; + motor = 0; + fix_pattern = SANE_FALSE; + ad_timing = 0; + bank_size = BS_16K; + DBG (5, "usb_high_scan_init_asic: sensor is set to NEC600\n"); + break; + default: + DBG (5, "usb_high_scan_init_asic: unknown sensor\n"); + return SANE_STATUS_INVAL; + break; + } + RIE (usb_low_adjust_timing (dev->chip, adjust)); + RIE (usb_low_select_timing (dev->chip, select)); + RIE (usb_low_set_timing (dev->chip, ccd_dpi)); + RIE (usb_low_set_sram_bank (dev->chip, bank_size)); + RIE (usb_low_set_asic_io_pins (dev->chip, pin)); + RIE (usb_low_set_rgb_sel_pins (dev->chip, pin)); + RIE (usb_low_set_motor_signal (dev->chip, motor)); + RIE (usb_low_set_test_sram_mode (dev->chip, SANE_FALSE)); + RIE (usb_low_set_fix_pattern (dev->chip, fix_pattern)); + RIE (usb_low_set_ad_timing (dev->chip, ad_timing)); + + DBG (5, "usb_high_scan_init_asic: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_evaluate_max_level (Mustek_Usb_Device * dev, + SANE_Word sample_lines, + SANE_Int sample_length, + SANE_Byte * ret_max_level) +{ + SANE_Byte max_level = 0; + SANE_Word i; + SANE_Int j; + SANE_Status status; + SANE_Word lines_left; + + DBG (5, "usb_high_scan_evaluate_max_level: start\n"); + + sample_length -= 20; + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < sample_lines; i++) + { + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + for (j = 20; j < sample_length; j++) + { + if (max_level < dev->green[j]) + max_level = dev->green[j]; + } + } + RIE (usb_low_stop_rowing (dev->chip)); + if (ret_max_level) + *ret_max_level = max_level; + DBG (5, "usb_high_scan_evaluate_max_level: exit, max_level = %d\n", + max_level); + return SANE_STATUS_GOOD; +} + +/* Binary Search for Single Channel Power Delay */ +SANE_Status +usb_high_scan_bssc_power_delay (Mustek_Usb_Device * dev, + Powerdelay_Function set_power_delay, + Signal_State * signal_state, + SANE_Byte * target, SANE_Byte max, + SANE_Byte min, SANE_Byte threshold, + SANE_Int length) +{ + SANE_Byte max_level; + SANE_Byte max_max = max; + SANE_Byte min_min = min; + SANE_Status status; + + DBG (5, "usb_high_scan_bssc_power_delay: start\n"); + + *target = (max + min) / 2; + RIE ((*set_power_delay) (dev->chip, *target)); + while (*target != min) + { + RIE (usb_high_scan_evaluate_max_level (dev, dev->init_powerdelay_lines, + length, &max_level)); + if (max_level > threshold) + { + min = *target; + *target = (max + min) / 2; + *signal_state = SS_BRIGHTER; + } + else if (max_level < threshold) + { + max = *target; + *target = (max + min) / 2; + *signal_state = SS_DARKER; + } + else if (max_level == threshold) + { /* Found. */ + *signal_state = SS_EQUAL; + return SANE_STATUS_GOOD; + } + RIE ((*set_power_delay) (dev->chip, *target)); + } + /* Fail... */ + if (max == max_max || min == min_min) + { /* Boundary check */ + if (max == max_max) /*target on max side */ + *target = max_max; + else + *target = min_min; + RIE ((*set_power_delay) (dev->chip, *target)); + RIE (usb_high_scan_evaluate_max_level (dev, dev->init_powerdelay_lines, + length, &max_level)); + + if (max_level > threshold) + { + *signal_state = SS_BRIGHTER; + } + else if (max_level < threshold) + { + *signal_state = SS_DARKER; + } + else if (max_level == threshold) + { + *signal_state = SS_EQUAL; + } + } + else + { /* Fail... will always on mimnum side, make it darker */ + target++; + *signal_state = SS_DARKER; + } + DBG (5, "usb_high_scan_bssc_power_delay: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_adjust_rgb_600_power_delay (Mustek_Usb_Device * dev) +{ + SANE_Status status; + SANE_Byte max_power_delay; + Signal_State signal_state = SS_UNKNOWN; + + DBG (5, "usb_high_scan_adjust_rgb_600_power_delay: start\n"); + max_power_delay = (SANE_Byte) (dev->expose_time / 64); + + if (dev->is_adjusted_rgb_600_power_delay) + return SANE_STATUS_GOOD; + /* Setup Initial State */ + dev->red_rgb_600_power_delay = max_power_delay; + dev->green_rgb_600_power_delay = max_power_delay; + dev->blue_rgb_600_power_delay = max_power_delay; + + RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_600)); + RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_600)); + RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT)); + + /* adjust GreenPD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600)); + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_600_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_green_pd, &signal_state, + &dev->green_rgb_600_power_delay, + max_power_delay, 0, dev->init_max_power_delay, + dev->adjust_length_600)); + + /* adjust BluePD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_BLUE)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600)); + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_600_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_blue_pd, &signal_state, + &dev->blue_rgb_600_power_delay, + max_power_delay, 0, dev->init_max_power_delay, + dev->adjust_length_600)); + + /* adjust RedPD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_RED)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600)); + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_600_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_red_pd, &signal_state, + &dev->red_rgb_600_power_delay, max_power_delay, 0, + dev->init_max_power_delay, dev->adjust_length_600)); + + dev->is_adjusted_rgb_600_power_delay = SANE_TRUE; + DBG (5, "usb_high_scan_adjust_rgb_600_power_delay: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_adjust_mono_600_power_delay (Mustek_Usb_Device * dev) +{ + SANE_Byte max_power_delay; + Signal_State signal_state = SS_UNKNOWN; + SANE_Status status; + + DBG (5, "usb_high_scan_adjust_mono_600_power_delay: start\n"); + max_power_delay = (SANE_Byte) (dev->expose_time / 64); + if (dev->is_adjusted_mono_600_power_delay) + return SANE_STATUS_GOOD; + /* Setup Initial State */ + dev->red_mono_600_power_delay = max_power_delay; + dev->green_mono_600_power_delay = max_power_delay; + dev->blue_mono_600_power_delay = max_power_delay; + + /* Compute Gray PD */ + RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_600)); + RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_600)); + RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT)); + + /* adjust GreenGrayPD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600)); + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_600_pga)); + RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_600_pga)); + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_600_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_green_pd, &signal_state, + &dev->green_mono_600_power_delay, + max_power_delay, 0, dev->init_max_power_delay, + dev->adjust_length_600)); + + dev->is_adjusted_mono_600_power_delay = SANE_TRUE; + DBG (5, "usb_high_scan_adjust_mono_600_power_delay: exit\n"); + return SANE_STATUS_GOOD; +} + +/* CCD */ +SANE_Status +usb_high_scan_adjust_mono_600_exposure (Mustek_Usb_Device * dev) +{ + SANE_Word transfer_time; + SANE_Status status; + + DBG (5, "usb_high_scan_adjust_mono_600_exposure: start\n"); + if (dev->is_adjusted_mono_600_exposure) + return SANE_STATUS_GOOD; + + RIE (usb_high_scan_evaluate_pixel_rate (dev)); + transfer_time = dev->pixel_rate * dev->x_dpi / 600; + if (transfer_time > 16000) + transfer_time = 16000; + + dev->mono_600_exposure = + MAX (5504, MAX (transfer_time, + usb_mid_motor_mono_capability (dev->chip, dev->y_dpi))); + dev->mono_600_exposure = ((dev->mono_600_exposure + 63) / 64) * 64; + dev->is_adjusted_mono_600_exposure = SANE_TRUE; + DBG (5, "usb_high_scan_adjust_mono_600_exposure: exit\n"); + return SANE_STATUS_GOOD; +} + +#if 0 +/* CCD */ +SANE_Status +usb_high_scan_adjust_mono_600_offset (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_adjust_mono_600_offset: start\n"); + if (dev->is_adjusted_mono_600_offset) + return SANE_STATUS_GOOD; + + DBG (5, "usb_high_scan_adjust_mono_600_offset: exit\n"); + return SANE_STATUS_GOOD; +} + +/* CCD */ +SANE_Status +usb_high_scan_adjust_mono_600_pga (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_adjust_mono_600_pga: start (dev = %p)\n", dev); + DBG (5, "usb_high_scan_adjust_mono_600_pga: exit\n"); + return SANE_STATUS_GOOD; +} + +/* CCD */ +SANE_Status +usb_high_scan_adjust_mono_600_skips_per_row (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_adjust_mono_600_skips_per_row: start (dev = %p)\n", + dev); + DBG (5, "usb_high_scan_adjust_mono_600_skips_per_row: exit\n"); + return SANE_STATUS_GOOD; +} +#endif + +SANE_Status +usb_high_scan_adjust_rgb_300_power_delay (Mustek_Usb_Device * dev) +{ + /* Setup Initial State */ + SANE_Byte max_power_delay; + Signal_State signal_state = SS_UNKNOWN; + SANE_Status status; + + DBG (5, "usb_high_scan_adjust_rgb_300_power_delay: start\n"); + max_power_delay = (SANE_Byte) (dev->expose_time / 64); + if (dev->is_adjusted_rgb_300_power_delay) + return SANE_STATUS_GOOD; + + dev->red_rgb_300_power_delay = max_power_delay; + dev->green_rgb_300_power_delay = max_power_delay; + dev->blue_rgb_300_power_delay = max_power_delay; + + RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_300)); + RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_300)); + RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT)); + + /* adjust GreenPD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300)); + + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_300_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_green_pd, &signal_state, + &dev->green_rgb_300_power_delay, + max_power_delay, 0, dev->init_max_power_delay, + dev->adjust_length_300)); + + /* adjust BluePD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_BLUE)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300)); + + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_300_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_blue_pd, &signal_state, + &dev->blue_rgb_300_power_delay, max_power_delay, 0, + dev->init_max_power_delay, dev->adjust_length_300)); + + /* adjust RedPD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_RED)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300)); + + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_300_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_red_pd, &signal_state, + &dev->red_rgb_300_power_delay, max_power_delay, 0, + dev->init_max_power_delay, dev->adjust_length_300)); + dev->is_adjusted_rgb_300_power_delay = SANE_TRUE; + DBG (5, "usb_high_scan_adjust_rgb_300_power_delay: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_adjust_mono_300_power_delay (Mustek_Usb_Device * dev) +{ + SANE_Byte max_power_delay; + Signal_State signal_state = SS_UNKNOWN; + SANE_Status status; + + DBG (5, "usb_high_scan_adjust_mono_300_power_delay: start\n"); + max_power_delay = (SANE_Byte) (dev->expose_time / 64); + if (dev->is_adjusted_mono_300_power_delay) + return SANE_STATUS_GOOD; + /* Setup Initial State */ + dev->red_mono_300_power_delay = max_power_delay; + dev->green_mono_300_power_delay = max_power_delay; + dev->blue_mono_300_power_delay = max_power_delay; + + /* Compute Gray PD */ + RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_300)); + RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_300)); + RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT)); + + /* adjust GreenGrayPD */ + RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN)); + RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300)); + + signal_state = SS_UNKNOWN; + RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_300_pga)); + RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_300_pga)); + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_300_pga)); + RIE (usb_high_scan_bssc_power_delay + (dev, &usb_low_set_green_pd, &signal_state, + &dev->green_mono_300_power_delay, + max_power_delay, 0, dev->init_max_power_delay, + dev->adjust_length_300)); + + dev->is_adjusted_mono_300_power_delay = SANE_TRUE; + DBG (5, "usb_high_scan_adjust_mono_300_power_delay: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_evaluate_pixel_rate (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_evaluate_pixel_rate: start, dev=%p\n", (void *) dev); + + /* fixme: new for CCD */ + dev->pixel_rate = 2000; + dev->is_evaluate_pixel_rate = SANE_TRUE; + DBG (5, "usb_high_scan_evaluate_pixel_rate: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_calibration_rgb_24 (Mustek_Usb_Device * dev) +{ + SANE_Word white_need; + SANE_Word dark_need; + SANE_Word i; + SANE_Status status; + SANE_Word lines_left; + SANE_Word minor_average; + + DBG (5, "usb_high_scan_calibration_rgb_24: start, dev=%p\n", (void *) dev); + if (dev->is_cis_detected) + { + RIE (usb_mid_motor_prepare_calibrate_rgb (dev->chip, dev->y_dpi)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + minor_average = 2; + } + else + { + minor_average = 1; + } + + dev->red_calibrator = (Calibrator *) malloc (sizeof (Calibrator)); + if (!dev->red_calibrator) + return SANE_STATUS_NO_MEM; + + RIE (usb_high_cal_init (dev->red_calibrator, I8O8RGB, + dev->init_k_level << 8, 0)); + RIE (usb_high_cal_prepare (dev->red_calibrator, dev->width)); + RIE (usb_high_cal_embed_gamma (dev->red_calibrator, dev->gamma_table)); + RIE (usb_high_cal_setup + (dev->red_calibrator, 1, minor_average, 8, dev->width, &white_need, + &dark_need)); + + dev->green_calibrator = (Calibrator *) malloc (sizeof (Calibrator)); + if (!dev->green_calibrator) + return SANE_STATUS_NO_MEM; + RIE (usb_high_cal_init (dev->green_calibrator, I8O8RGB, + dev->init_k_level << 8, 0)); + RIE (usb_high_cal_prepare (dev->green_calibrator, dev->width)); + RIE (usb_high_cal_embed_gamma (dev->green_calibrator, dev->gamma_table)); + RIE (usb_high_cal_setup (dev->green_calibrator, 1, minor_average, 8, + dev->width, &white_need, &dark_need)); + + dev->blue_calibrator = (Calibrator *) malloc (sizeof (Calibrator)); + if (!dev->blue_calibrator) + return SANE_STATUS_NO_MEM; + + RIE (usb_high_cal_init (dev->blue_calibrator, I8O8RGB, + dev->init_k_level << 8, 0)); + RIE (usb_high_cal_prepare (dev->blue_calibrator, dev->width)); + RIE (usb_high_cal_embed_gamma (dev->blue_calibrator, dev->gamma_table)); + RIE (usb_high_cal_setup (dev->blue_calibrator, 1, minor_average, 8, + dev->width, &white_need, &dark_need)); + + /* K White */ + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < white_need; i++) + { + /* Read Green Channel */ + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->green_calibrator, i, 0, + (void *) (dev->green + + dev->skips_per_row))); + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->green_calibrator, i, 1, + (void *) (dev->green + + dev->skips_per_row))); + /* Read Blue Channel */ + RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->blue_calibrator, i, 0, + (void *) (dev->blue + + dev->skips_per_row))); + RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->blue_calibrator, i, 1, + (void *) (dev->blue + + dev->skips_per_row))); + /* Read Red Channel */ + RIE (usb_low_get_row (dev->chip, dev->red, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->red_calibrator, i, 0, + (void *) (dev->red + + dev->skips_per_row))); + RIE (usb_low_get_row (dev->chip, dev->red, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->red_calibrator, i, 1, + (void *) (dev->red + + dev->skips_per_row))); + } + RIE (usb_low_stop_rowing (dev->chip)); + /* Caculate average */ + RIE (usb_high_cal_evaluate_white (dev->green_calibrator, + dev->init_green_factor)); + RIE (usb_high_cal_evaluate_white (dev->blue_calibrator, + dev->init_blue_factor)); + RIE (usb_high_cal_evaluate_white (dev->red_calibrator, + dev->init_red_factor)); + + RIE (usb_mid_motor_prepare_calibrate_rgb (dev->chip, dev->y_dpi)); + RIE (usb_low_enable_motor (dev->chip, SANE_FALSE)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE)); + + /* K Black */ + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < dark_need; i++) + { + /* Read Green Channel */ + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->green_calibrator, i, 0, + (void *) (dev->green + + dev->skips_per_row))); + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->green_calibrator, i, 1, + (void *) (dev->green + + dev->skips_per_row))); + /* Read Blue Channel */ + RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->blue_calibrator, i, 0, + (void *) (dev->blue + + dev->skips_per_row))); + RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->blue_calibrator, i, 1, + (void *) (dev->blue + + dev->skips_per_row))); + /* Read Red Channel */ + RIE (usb_low_get_row (dev->chip, dev->red, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->red_calibrator, i, 0, + (void *) (dev->red + + dev->skips_per_row))); + RIE (usb_low_get_row (dev->chip, dev->red, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->red_calibrator, i, 1, + (void *) (dev->red + + dev->skips_per_row))); + } + RIE (usb_low_stop_rowing (dev->chip)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + /* Calculate average */ + RIE (usb_high_cal_evaluate_dark (dev->green_calibrator, + dev->init_green_black_factor)); + RIE (usb_high_cal_evaluate_dark (dev->blue_calibrator, + dev->init_blue_black_factor)); + RIE (usb_high_cal_evaluate_dark (dev->red_calibrator, + dev->init_red_black_factor)); + /* Calculate Mapping */ + RIE (usb_high_cal_evaluate_calibrator (dev->green_calibrator)); + RIE (usb_high_cal_evaluate_calibrator (dev->blue_calibrator)); + RIE (usb_high_cal_evaluate_calibrator (dev->red_calibrator)); + DBG (5, "usb_high_scan_calibration_rgb_24: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_calibration_mono_8 (Mustek_Usb_Device * dev) +{ + SANE_Word white_need; + SANE_Word dark_need; + SANE_Word i; + SANE_Status status; + SANE_Word lines_left; + + DBG (5, "usb_high_scan_calibration_mono_8: start\n"); + RIE (usb_mid_motor_prepare_calibrate_mono (dev->chip, dev->y_dpi)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + + dev->mono_calibrator = (Calibrator *) malloc (sizeof (Calibrator)); + if (!dev->mono_calibrator) + return SANE_STATUS_NO_MEM; + + RIE (usb_high_cal_init (dev->mono_calibrator, I8O8MONO, + dev->init_k_level << 8, 0)); + RIE (usb_high_cal_prepare (dev->mono_calibrator, dev->width)); + RIE (usb_high_cal_embed_gamma (dev->mono_calibrator, dev->gamma_table)); + RIE (usb_high_cal_setup (dev->mono_calibrator, 1, 1, 8, + dev->width, &white_need, &dark_need)); + + /* K White */ + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < white_need; i++) + { + /* Read Green Channel */ + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_fill_in_white (dev->mono_calibrator, i, 0, + (void *) (dev->green + + dev->skips_per_row))); + } + RIE (usb_low_stop_rowing (dev->chip)); + /* Caculate average */ + RIE (usb_high_cal_evaluate_white (dev->mono_calibrator, + dev->init_gray_factor)); + + RIE (usb_mid_motor_prepare_calibrate_mono (dev->chip, dev->y_dpi)); + RIE (usb_low_enable_motor (dev->chip, SANE_FALSE)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE)); + + /* K Black */ + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < dark_need; i++) + { + /* Read Green Channel */ + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_fill_in_dark (dev->mono_calibrator, i, 0, + (void *) (dev->green + + dev->skips_per_row))); + } + RIE (usb_low_stop_rowing (dev->chip)); + RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE)); + /* Caculate Green Black */ + RIE (usb_high_cal_evaluate_dark (dev->mono_calibrator, + dev->init_gray_black_factor)); + /* Caculate Mapping */ + RIE (usb_high_cal_evaluate_calibrator (dev->mono_calibrator)); + DBG (5, "usb_high_scan_calibration_mono_8: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_step_forward (Mustek_Usb_Device * dev, SANE_Int step_count) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_step_forward: start\n"); + + if (step_count <= 0) + return SANE_STATUS_INVAL; + /* Initialize */ + RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time)); + RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE)); + RIE (usb_mid_motor_prepare_step (dev->chip, (SANE_Word) step_count)); + /* Startup */ + RIE (usb_low_start_rowing (dev->chip)); + /* Wait for stop */ + /* Linux USB seems buggy on timeout... sleep before really try */ + /* to read the flag from scanner */ + usleep (step_count * 2 * 1000); + RIE (usb_low_wait_rowing_stop (dev->chip)); + if (!dev->is_cis_detected) + RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time)); + + DBG (5, "usb_high_scan_step_forward: start\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_safe_forward (Mustek_Usb_Device * dev, SANE_Int step_count) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_safe_forward: start\n"); + if (step_count <= 0) + return SANE_STATUS_INVAL; + /* Initialize */ + RIE (usb_low_set_ccd_width (dev->chip, 5400)); + RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE)); + RIE (usb_mid_motor_prepare_step (dev->chip, (SANE_Word) step_count)); + /* Startup */ + RIE (usb_low_start_rowing (dev->chip)); + /* Wait to Stop */ + RIE (usb_low_wait_rowing_stop (dev->chip)); + RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time)); + DBG (5, "usb_high_scan_safe_forward: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Word +usb_high_scan_calculate_max_rgb_600_expose (Mustek_Usb_Device * dev, + SANE_Byte * ideal_red_pd, + SANE_Byte * ideal_green_pd, + SANE_Byte * ideal_blue_pd) +{ + SANE_Word red_light_up; + SANE_Word green_light_up; + SANE_Word blue_light_up; + SANE_Word max_light_up; + SANE_Word ideal_expose_time; + + DBG (5, "usb_high_scan_calculate_max_rgb_600_expose: dev=%p\n", (void *) dev); + + red_light_up = dev->expose_time - dev->red_rgb_600_power_delay * 64; + green_light_up = dev->expose_time - dev->green_rgb_600_power_delay * 64; + blue_light_up = dev->expose_time - dev->blue_rgb_600_power_delay * 64; + max_light_up = MAX (red_light_up, MAX (green_light_up, blue_light_up)); + if (dev->chip->sensor == ST_NEC600) + { + ideal_expose_time + = MAX (MAX (5504, max_light_up), + usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi)); + } + else + { + ideal_expose_time + = MAX (MAX (5376, max_light_up), + usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi)); + } + ideal_expose_time = (ideal_expose_time + 63) / 64 * 64; + *ideal_red_pd = (SANE_Byte) ((ideal_expose_time - red_light_up) / 64); + *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - green_light_up) / 64); + *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time - blue_light_up) / 64); + DBG (5, "usb_high_scan_calculate_max_rgb_600_expose: exit\n"); + return ideal_expose_time; +} + +SANE_Word +usb_high_scan_calculate_max_mono_600_expose (Mustek_Usb_Device * dev, + SANE_Byte * ideal_red_pd, + SANE_Byte * ideal_green_pd, + SANE_Byte * ideal_blue_pd) +{ + SANE_Word max_light_up; + SANE_Word ideal_expose_time; + SANE_Word transfer_time; + + DBG (5, "usb_high_scan_calculate_max_mono_600_expose: dev=%p\n", (void *) dev); + + max_light_up = dev->expose_time - dev->green_mono_600_power_delay * 64; + transfer_time = (SANE_Word) ((SANE_Word) (dev->pixel_rate) + * (SANE_Word) (dev->x_dpi) / 600); + /* base on 600, but double it. */ + + if (transfer_time > 16000) + transfer_time = 16000; + if (dev->chip->sensor == ST_NEC600) + { + ideal_expose_time + = MAX (MAX (5504, max_light_up), + MAX (transfer_time, usb_mid_motor_mono_capability + (dev->chip, dev->y_dpi))); + } + else + { + ideal_expose_time + = MAX (MAX (5376, max_light_up), + MAX (transfer_time, usb_mid_motor_mono_capability + (dev->chip, dev->y_dpi))); + } + ideal_expose_time = (ideal_expose_time + 63) / 64 * 64; + *ideal_red_pd = (SANE_Byte) ((ideal_expose_time) / 64); + *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - max_light_up) / 64); + *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time) / 64); + DBG (5, "usb_high_scan_calculate_max_mono_600_expose: exit\n"); + return ideal_expose_time; +} + +SANE_Word +usb_high_scan_calculate_max_rgb_300_expose (Mustek_Usb_Device * dev, + SANE_Byte * ideal_red_pd, + SANE_Byte * ideal_green_pd, + SANE_Byte * ideal_blue_pd) +{ + SANE_Word red_light_up; + SANE_Word green_light_up; + SANE_Word blue_light_up; + SANE_Word max_light_up; + SANE_Word ideal_expose_time; + + DBG (5, "usb_high_scan_calculate_max_rgb_300_expose: start\n"); + red_light_up = dev->expose_time - dev->red_rgb_300_power_delay * 64; + green_light_up = dev->expose_time - dev->green_rgb_300_power_delay * 64; + blue_light_up = dev->expose_time - dev->blue_rgb_300_power_delay * 64; + max_light_up = MAX (red_light_up, MAX (green_light_up, blue_light_up)); + + if (dev->chip->sensor == ST_CANON300600) + { + ideal_expose_time = + MAX (MAX (2624, max_light_up), + usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi)); + } + else if (dev->chip->sensor == ST_CANON300) + { + ideal_expose_time = MAX (MAX (2624, max_light_up), /* fixme? */ + usb_mid_motor_rgb_capability (dev->chip, + dev->y_dpi)); + } + else + { + ideal_expose_time = + MAX (MAX (5376, max_light_up), + usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi)); + } + + ideal_expose_time = (ideal_expose_time + 63) / 64 * 64; + *ideal_red_pd = (SANE_Byte) ((ideal_expose_time - red_light_up) / 64); + *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - green_light_up) / 64); + *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time - blue_light_up) / 64); + DBG (5, "usb_high_scan_calculate_max_rgb_300_expose: exit\n"); + return ideal_expose_time; +} + +SANE_Word +usb_high_scan_calculate_max_mono_300_expose (Mustek_Usb_Device * dev, + SANE_Byte * ideal_red_pd, + SANE_Byte * ideal_green_pd, + SANE_Byte * ideal_blue_pd) +{ + SANE_Word max_light_up; + SANE_Word transfer_time; + SANE_Word ideal_expose_time; + + DBG (5, "usb_high_scan_calculate_max_mono_300_expose: start\n"); + max_light_up = dev->expose_time - dev->green_mono_300_power_delay * 64; + transfer_time = + (SANE_Word) ((SANE_Word) (dev->pixel_rate) * + (SANE_Word) (dev->x_dpi) / 600); + /* base on 600, but double it. */ + + if (transfer_time > 16000) + transfer_time = 16000; + if (dev->chip->sensor == ST_CANON300600) + { + ideal_expose_time = + MAX (MAX (2688, max_light_up), + MAX (transfer_time, + usb_mid_motor_mono_capability (dev->chip, dev->y_dpi))); + } + else if (dev->chip->sensor == ST_CANON300) + { + ideal_expose_time = MAX (MAX (2688, max_light_up), /* fixme? */ + MAX (transfer_time, + usb_mid_motor_mono_capability (dev->chip, + dev-> + y_dpi))); + } + else + { + ideal_expose_time = + MAX (MAX (5376, max_light_up), + MAX (transfer_time, + usb_mid_motor_mono_capability (dev->chip, dev->y_dpi))); + } + + ideal_expose_time = (ideal_expose_time + 63) / 64 * 64; + *ideal_red_pd = (SANE_Byte) ((ideal_expose_time) / 64); + *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - max_light_up) / 64); + *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time) / 64); + DBG (5, "usb_high_scan_calculate_max_mono_300_expose: exit\n"); + return ideal_expose_time; +} + +SANE_Status +usb_high_scan_prepare_rgb_signal_600_dpi (Mustek_Usb_Device * dev) +{ + SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd; + SANE_Word ideal_expose_time; + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_rgb_signal_600_dpi: start\n"); + ideal_expose_time = usb_high_scan_calculate_max_rgb_600_expose + (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd); + + RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_600_pga)); + RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_600_pga)); + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_600_pga)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd)); + RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd)); + RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd)); + DBG (5, "usb_high_scan_prepare_rgb_signal_600_dpi: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare_mono_signal_600_dpi (Mustek_Usb_Device * dev) +{ + SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd; + SANE_Word ideal_expose_time; + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_mono_signal_600_dpi: start\n"); + ideal_expose_time = usb_high_scan_calculate_max_mono_600_expose + (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd); + + RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_600_pga)); + RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_600_pga)); + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_600_pga)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd)); + RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd)); + RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd)); + DBG (5, "usb_high_scan_prepare_mono_signal_600_dpi: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare_rgb_signal_300_dpi (Mustek_Usb_Device * dev) +{ + SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd; + SANE_Word ideal_expose_time; + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_rgb_signal_300_dpi: start\n"); + + ideal_expose_time = usb_high_scan_calculate_max_rgb_300_expose + (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd); + + RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_300_pga)); + RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_300_pga)); + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_300_pga)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd)); + RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd)); + RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd)); + DBG (5, "usb_high_scan_prepare_rgb_signal_300_dpi: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare_mono_signal_300_dpi (Mustek_Usb_Device * dev) +{ + /* Setup Scan Here */ + SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd; + SANE_Word ideal_expose_time; + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_mono_signal_300_dpi: start\n"); + ideal_expose_time = usb_high_scan_calculate_max_mono_300_expose + (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd); + + RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time)); + RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end)); + RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref)); + RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset)); + RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset)); + RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset)); + RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_300_pga)); + RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_300_pga)); + RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_300_pga)); + RIE (usb_mid_front_set_rgb_signal (dev->chip)); + RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd)); + RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd)); + RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd)); + DBG (5, "usb_high_scan_prepare_mono_signal_300_dpi: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare_rgb_24 (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_rgb_24: start\n"); + RIE (usb_low_set_image_byte_width (dev->chip, dev->bytes_per_strip)); + RIE (usb_low_set_dummy (dev->chip, dev->dummy)); + RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT)); + DBG (5, "usb_high_scan_prepare_rgb_24: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_prepare_mono_8 (Mustek_Usb_Device * dev) +{ + SANE_Status status; + + DBG (5, "usb_high_scan_prepare_mono_8: start\n"); + RIE (usb_low_set_image_byte_width (dev->chip, dev->bytes_per_strip)); + RIE (usb_low_set_dummy (dev->chip, dev->dummy)); + RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT)); + DBG (5, "usb_high_scan_prepare_mono_8: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_get_rgb_24_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line, + SANE_Bool is_order_invert) +{ + SANE_Status status; + SANE_Word lines_left; + + DBG (5, "usb_high_scan_get_rgb_24_bit_line: start, dev=%p, line=%p, " + "is_order_invert=%d\n", (void *) dev, line, is_order_invert); + + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + + RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left)); + + RIE (usb_low_get_row (dev->chip, dev->red, &lines_left)); + RIE (usb_high_cal_calibrate (dev->green_calibrator, + dev->green + dev->skips_per_row, line + 1)); + RIE (usb_high_cal_calibrate (dev->blue_calibrator, + dev->blue + dev->skips_per_row, + line + ((is_order_invert) ? 0 : 2))); + RIE (usb_high_cal_calibrate (dev->red_calibrator, + dev->red + dev->skips_per_row, + line + ((is_order_invert) ? 2 : 0))); + + DBG (5, "usb_high_scan_get_rgb_24_bit_line: exit\n"); + return SANE_STATUS_GOOD; +} + + +SANE_Status +usb_high_scan_get_mono_8_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line, + SANE_Bool is_order_invert) +{ + SANE_Status status; + SANE_Word lines_left; + + DBG (5, "usb_high_scan_get_mono_8_bit_line: start, dev=%p, line=%p, " + "is_order_invert=%d\n", (void *) dev, line, is_order_invert); + + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + RIE (usb_high_cal_calibrate (dev->mono_calibrator, dev->green + + dev->skips_per_row, line)); + DBG (5, "usb_high_scan_get_mono_8_bit_line: exit\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_backtrack_rgb_24 (Mustek_Usb_Device * dev) +{ + DBG (5, "usb_high_scan_backtrack_rgb_24: noop, dev=%p\n", (void *) dev); + return SANE_STATUS_GOOD; +} + +SANE_Status +usb_high_scan_backtrack_mono_8 (Mustek_Usb_Device * dev) +{ + SANE_Int i; + SANE_Status status; + SANE_Word lines_left; + + DBG (5, "usb_high_scan_backtrack_mono_8: start, dev=%p\n", (void *) dev); + + if (dev->y_dpi >= 300) + { + RIE (usb_low_stop_rowing (dev->chip)); + RIE (usb_low_set_motor_direction (dev->chip, SANE_TRUE)); + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < dev->init_mono_8_back_track; i++) + { + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + } + usleep (100 * 1000); + RIE (usb_low_stop_rowing (dev->chip)); + RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE)); + RIE (usb_low_start_rowing (dev->chip)); + for (i = 0; i < dev->init_mono_8_back_track; i++) + { + RIE (usb_low_get_row (dev->chip, dev->green, &lines_left)); + } + } + DBG (5, "usb_high_scan_backtrack_mono_8: exit\n"); + return SANE_STATUS_GOOD; +} |