1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 2000 Mustek.
4 Originally maintained by Tom Wang <tom.wang@mustek.com.tw>
5
6 Copyright (C) 2001, 2002 by Henning Meier-Geinitz.
7
8 This file is part of the SANE package.
9
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2 of the
13 License, or (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <https://www.gnu.org/licenses/>.
22
23 As a special exception, the authors of SANE give permission for
24 additional uses of the libraries contained in this release of SANE.
25
26 The exception is that, if you link a SANE library with other files
27 to produce an executable, this does not by itself cause the
28 resulting executable to be covered by the GNU General Public
29 License. Your use of that executable is in no way restricted on
30 account of linking the SANE library code into it.
31
32 This exception does not, however, invalidate any other reasons why
33 the executable file might be covered by the GNU General Public
34 License.
35
36 If you submit changes to SANE to the maintainers to be included in
37 a subsequent release, you agree by submitting the changes that
38 those changes may be distributed with this exception intact.
39
40 If you write modifications of your own for SANE, it is your choice
41 whether to permit this exception to apply to your modifications.
42 If you do not wish that, delete this exception notice.
43
44 This file implements a SANE backend for Mustek 1200UB and similar
45 USB flatbed scanners. */
46
47 #include "mustek_usb_high.h"
48 #include "mustek_usb_mid.c"
49
50 /* ------------------------ calibration functions ------------------------- */
51
52 static SANE_Byte gray_map[8] = {
53 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
54 };
55
56 static inline double
filter_lower_end(SANE_Int * buffer,SANE_Word total_count,SANE_Word filter_count)57 filter_lower_end (SANE_Int * buffer, SANE_Word total_count,
58 SANE_Word filter_count)
59 {
60 SANE_Word bound = total_count - 1;
61 SANE_Word left_count = total_count - filter_count;
62 SANE_Int temp = 0;
63 SANE_Word i, j;
64 SANE_Int sum = 0;
65
66 for (i = 0; i < bound; i++)
67 {
68 for (j = 0; j < bound - i; j++)
69 {
70 if (buffer[j + 1] > buffer[j])
71 {
72 temp = buffer[j];
73 buffer[j] = buffer[j + 1];
74 buffer[j + 1] = temp;
75 }
76 }
77 }
78 for (i = 0; i < left_count; i++)
79 sum += buffer[i];
80 return (double) sum;
81 }
82
83 SANE_Status
usb_high_cal_init(Calibrator * cal,SANE_Byte type,SANE_Word target_white,SANE_Word target_dark)84 usb_high_cal_init (Calibrator * cal, SANE_Byte type, SANE_Word target_white,
85 SANE_Word target_dark)
86 {
87 DBG (5, "usb_high_cal_init: start, cal=%p, type=%d, target_white=%d "
88 "target_dark=%d\n", (void *) cal, type, target_white, target_dark);
89 cal->is_prepared = SANE_FALSE;
90 cal->k_white = NULL;
91 cal->k_dark = NULL;
92 /* Working Buffer */
93 cal->white_line = NULL;
94 cal->dark_line = NULL;
95 cal->white_buffer = NULL;
96 /* Necessary Parameters */
97 cal->k_white_level = 240 << 8;
98 cal->k_dark_level = 0;
99 cal->threshold = 2048;
100 cal->major_average = 0;
101 cal->minor_average = 0;
102 cal->filter = 0;
103 cal->white_needed = 0;
104 cal->dark_needed = 0;
105 cal->max_width = 0;
106 cal->width = 100;
107 cal->gamma_table = 0;
108 cal->calibrator_type = type;
109 cal->k_white_level = target_white / 16;
110 cal->k_dark_level = 0;
111 DBG (5, "usb_high_cal_init: exit\n");
112 return SANE_STATUS_GOOD;
113 }
114
115 SANE_Status
usb_high_cal_exit(Calibrator * cal)116 usb_high_cal_exit (Calibrator * cal)
117 {
118 DBG (5, "usb_high_cal_exit: start\n");
119
120 if (!cal)
121 {
122 DBG (3, "usb_high_cal_exit: cal == NULL\n");
123 return SANE_STATUS_INVAL;
124 }
125
126 if (!cal->is_prepared)
127 {
128 DBG (3, "usb_high_cal_exit: !is_prepared\n");
129 return SANE_STATUS_INVAL;
130 }
131 DBG (5, "usb_high_cal_exit: 1\n");
132
133 if (cal->k_dark)
134 {
135 free (cal->k_dark);
136 }
137 cal->k_dark = NULL;
138 DBG (5, "usb_high_cal_exit: 2\n");
139 if (cal->k_white)
140 {
141 free (cal->k_white);
142 }
143 cal->k_white = NULL;
144 DBG (5, "usb_high_cal_exit: 3\n");
145
146 cal->is_prepared = SANE_FALSE;
147 DBG (5, "usb_high_cal_exit: 4\n");
148 DBG (5, "usb_high_cal_exit: exit\n");
149 return SANE_STATUS_GOOD;
150 }
151
152 SANE_Status
usb_high_cal_embed_gamma(Calibrator * cal,SANE_Word * gamma_table)153 usb_high_cal_embed_gamma (Calibrator * cal, SANE_Word * gamma_table)
154 {
155 DBG (5, "usb_high_cal_embed_gamma: start\n");
156 cal->gamma_table = gamma_table;
157 DBG (5, "usb_high_cal_embed_gamma: exit\n");
158 return SANE_STATUS_GOOD;
159 }
160
161 SANE_Status
usb_high_cal_prepare(Calibrator * cal,SANE_Word max_width)162 usb_high_cal_prepare (Calibrator * cal, SANE_Word max_width)
163 {
164 DBG (5, "usb_high_cal_Parepare: start\n");
165
166 if (cal->is_prepared)
167 {
168 DBG (3, "usb_high_cal_Parepare: is_prepared\n");
169 return SANE_STATUS_INVAL;
170 }
171
172 if (cal->k_white)
173 {
174 free (cal->k_white);
175 }
176 cal->k_white = (SANE_Word *) malloc (max_width * sizeof (SANE_Word));
177 if (!cal->k_white)
178 return SANE_STATUS_NO_MEM;
179
180 if (cal->k_dark)
181 {
182 free (cal->k_dark);
183 }
184 cal->k_dark = (SANE_Word *) malloc (max_width * sizeof (SANE_Word));
185 if (!cal->k_dark)
186 return SANE_STATUS_NO_MEM;
187
188 cal->max_width = max_width;
189
190 cal->is_prepared = SANE_TRUE;
191
192 DBG (5, "usb_high_cal_Parepare: exit\n");
193 return SANE_STATUS_GOOD;
194 }
195
196
197 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)198 usb_high_cal_setup (Calibrator * cal, SANE_Word major_average,
199 SANE_Word minor_average, SANE_Word filter,
200 SANE_Word width, SANE_Word * white_needed,
201 SANE_Word * dark_needed)
202 {
203 SANE_Int i;
204
205 DBG (5, "usb_high_cal_setup: start\n");
206
207 if (!cal->is_prepared)
208 {
209 DBG (3, "usb_high_cal_setup: !is_prepared\n");
210 return SANE_STATUS_INVAL;
211 }
212 if (major_average == 0)
213 {
214 DBG (3, "usb_high_cal_setup: major_average==0\n");
215 return SANE_STATUS_INVAL;
216 }
217 if (minor_average == 0)
218 {
219 DBG (3, "usb_high_cal_setup: minor_average==0\n");
220 return SANE_STATUS_INVAL;
221 }
222 if (width > cal->max_width)
223 {
224 DBG (3, "usb_high_cal_setup: width>max_width\n");
225 return SANE_STATUS_INVAL;
226 }
227
228 cal->major_average = major_average;
229 cal->minor_average = minor_average;
230 cal->filter = filter;
231 cal->width = width;
232 cal->white_needed = major_average * 16 + filter;
233 cal->dark_needed = major_average * 16;
234 *white_needed = cal->white_needed;
235 *dark_needed = cal->dark_needed;
236
237 if (cal->white_line)
238 {
239 free (cal->white_line);
240 }
241 cal->white_line = (double *) malloc (cal->width * sizeof (double));
242 if (!cal->white_line)
243 return SANE_STATUS_NO_MEM;
244
245 if (cal->dark_line)
246 {
247 free (cal->dark_line);
248 }
249 cal->dark_line = (double *) malloc (cal->width * sizeof (double));
250 if (!cal->dark_line)
251 return SANE_STATUS_NO_MEM;
252
253 for (i = 0; i < cal->width; i++)
254 {
255 cal->white_line[i] = 0.0;
256 cal->dark_line[i] = 0.0;
257 }
258
259 if (cal->white_buffer)
260 {
261 free (cal->white_buffer);
262 }
263 cal->white_buffer =
264 (SANE_Int *) malloc (cal->white_needed * cal->width * sizeof (SANE_Int));
265 if (!cal->white_buffer)
266 return SANE_STATUS_NO_MEM;
267
268 for (i = 0; i < cal->white_needed * cal->width; i++)
269 {
270 *(cal->white_buffer + i) = 0;
271 }
272
273 return SANE_STATUS_GOOD;
274 DBG (5, "usb_high_cal_setup: start\n");
275 }
276
277 SANE_Status
usb_high_cal_evaluate_white(Calibrator * cal,double factor)278 usb_high_cal_evaluate_white (Calibrator * cal, double factor)
279 {
280 /* Calculate white_line */
281 double loop_division;
282 double average;
283 SANE_Int *buffer;
284 SANE_Word i, j;
285
286 DBG (5, "usb_high_cal_evaluate_white: start\n");
287 loop_division = (double) (cal->major_average * cal->minor_average);
288 buffer = (SANE_Int *) malloc (cal->white_needed * sizeof (SANE_Int));
289 if (!buffer)
290 return SANE_STATUS_NO_MEM;
291
292 if (cal->white_buffer == NULL)
293 {
294 DBG (3, "usb_high_cal_evaluate_white: white_buffer==NULL\n");
295 return SANE_STATUS_NO_MEM;
296 }
297
298 for (i = 0; i < cal->width; i++)
299 {
300 for (j = 0; j < cal->white_needed; j++)
301 {
302 *(buffer + j) = *(cal->white_buffer + j * cal->width + i);
303 }
304 average =
305 filter_lower_end (buffer, cal->white_needed,
306 cal->filter) * factor / loop_division;
307 if (average >= 4096.0)
308 cal->white_line[i] = 4095.9999;
309 else if (average < 0.0)
310 cal->white_line[i] = 0.0;
311 else
312 cal->white_line[i] = average;
313 }
314 free (buffer);
315 buffer = NULL;
316 free (cal->white_buffer);
317 cal->white_buffer = NULL;
318 DBG (5, "usb_high_cal_evaluate_white: exit\n");
319 return SANE_STATUS_GOOD;
320 }
321
322 SANE_Status
usb_high_cal_evaluate_dark(Calibrator * cal,double factor)323 usb_high_cal_evaluate_dark (Calibrator * cal, double factor)
324 {
325 SANE_Word i;
326 double loop_division;
327
328 DBG (5, "usb_high_cal_evaluate_dark: start\n");
329 /* Calculate dark_line */
330 factor *= 16.0;
331 loop_division = (double) (cal->major_average * cal->minor_average);
332 for (i = 0; i < cal->width; i++)
333 {
334 cal->dark_line[i] /= loop_division;
335 cal->dark_line[i] -= factor;
336 if (cal->dark_line[i] < 0.0)
337 cal->dark_line[i] = 0.0;
338 }
339 DBG (5, "usb_high_cal_evaluate_dark: exit\n");
340 return SANE_STATUS_GOOD;
341 }
342
343 SANE_Status
usb_high_cal_evaluate_calibrator(Calibrator * cal)344 usb_high_cal_evaluate_calibrator (Calibrator * cal)
345 {
346 SANE_Int average = 0;
347 SANE_Word i;
348
349 DBG (5, "usb_high_cal_evaluate_calibrator: start\n");
350 if (cal->white_line == NULL)
351 {
352 DBG (3, "usb_high_cal_evaluate_calibrator: white_line==NULL\n");
353 return SANE_FALSE;
354 }
355 if (cal->dark_line == NULL)
356 {
357 DBG (3, "usb_high_cal_evaluate_calibrator: dark_line==NULL\n");
358 return SANE_FALSE;
359 }
360
361 for (i = 0; i < cal->width; i++)
362 {
363 average = (SANE_Int) (cal->white_line[i])
364 - (SANE_Int) (cal->dark_line[i]);
365 if (average <= 0)
366 average = 1;
367 else if (average >= 4096)
368 average = 4095;
369 cal->k_white[i] = (SANE_Word) (average);
370 cal->k_dark[i] = (SANE_Word) (cal->dark_line[i]);
371 }
372 free (cal->dark_line);
373 cal->dark_line = NULL;
374 free (cal->white_line);
375 cal->white_line = NULL;
376
377 DBG (5, "usb_high_cal_evaluate_calibrator: start\n");
378 return SANE_STATUS_GOOD;
379 }
380
381 /* virtual function switcher */
382 SANE_Status
usb_high_cal_fill_in_white(Calibrator * cal,SANE_Word major,SANE_Word minor,void * white_pattern)383 usb_high_cal_fill_in_white (Calibrator * cal, SANE_Word major,
384 SANE_Word minor, void *white_pattern)
385 {
386 DBG (5, "usb_high_cal_fill_in_white: start\n");
387 switch (cal->calibrator_type)
388 {
389 case I8O8RGB:
390 case I8O8MONO:
391 return usb_high_cal_i8o8_fill_in_white (cal, major, minor,
392 white_pattern);
393 break;
394 case I4O1MONO:
395 return usb_high_cal_i4o1_fill_in_white (cal, major, minor,
396 white_pattern);
397 break;
398 }
399 DBG (5, "usb_high_cal_fill_in_white: exit\n");
400 return SANE_STATUS_GOOD;
401 }
402
403 SANE_Status
usb_high_cal_fill_in_dark(Calibrator * cal,SANE_Word major,SANE_Word minor,void * dark_pattern)404 usb_high_cal_fill_in_dark (Calibrator * cal, SANE_Word major, SANE_Word minor,
405 void *dark_pattern)
406 {
407 DBG (5, "usb_high_cal_fill_in_dark: start\n");
408 switch (cal->calibrator_type)
409 {
410 case I8O8RGB:
411 case I8O8MONO:
412 return usb_high_cal_i8o8_fill_in_dark (cal, major, minor, dark_pattern);
413 break;
414 case I4O1MONO:
415 return usb_high_cal_i4o1_fill_in_dark (cal, major, minor, dark_pattern);
416 break;
417 }
418 DBG (5, "usb_high_cal_fill_in_dark: exit\n");
419 return SANE_STATUS_GOOD;
420 }
421
422 SANE_Status
usb_high_cal_calibrate(Calibrator * cal,void * src,void * target)423 usb_high_cal_calibrate (Calibrator * cal, void *src, void *target)
424 {
425 DBG (5, "usb_high_cal_calibrate: start\n");
426 switch (cal->calibrator_type)
427 {
428 case I8O8RGB:
429 return usb_high_cal_i8o8_rgb_calibrate (cal, src, target);
430 break;
431 case I8O8MONO:
432 return usb_high_cal_i8o8_mono_calibrate (cal, src, target);
433 break;
434 case I4O1MONO:
435 return usb_high_cal_i4o1_calibrate (cal, src, target);
436 break;
437 }
438 DBG (5, "usb_high_cal_calibrate: exit\n");
439 return SANE_STATUS_GOOD;
440 }
441
442 SANE_Status
usb_high_cal_i8o8_fill_in_white(Calibrator * cal,SANE_Word major,SANE_Word minor,void * white_pattern)443 usb_high_cal_i8o8_fill_in_white (Calibrator * cal, SANE_Word major,
444 SANE_Word minor, void *white_pattern)
445 {
446 SANE_Byte *pattern;
447 SANE_Word j;
448
449 pattern = (SANE_Byte *) white_pattern;
450
451 DBG (5, "usb_high_cal_i8o8_fill_in_white: start, minor=%d\n", minor);
452 if (!cal->is_prepared)
453 {
454 DBG (3, "usb_high_cal_i8o8_fill_in_white: !is_prepared\n");
455 return SANE_STATUS_INVAL;
456 }
457 if (cal->white_needed == 0)
458 {
459 DBG (3, "usb_high_cal_i8o8_fill_in_white: white_needed==0\n");
460 return SANE_STATUS_INVAL;
461 }
462
463 for (j = 0; j < cal->width; j++)
464 {
465 *(cal->white_buffer + major * cal->width + j) +=
466 (SANE_Int) (pattern[j]);
467 }
468 DBG (5, "usb_high_cal_i8o8_fill_in_white: exit\n");
469 return SANE_STATUS_GOOD;
470 }
471
472 SANE_Status
usb_high_cal_i8o8_fill_in_dark(Calibrator * cal,SANE_Word major,SANE_Word minor,void * dark_pattern)473 usb_high_cal_i8o8_fill_in_dark (Calibrator * cal, SANE_Word major,
474 SANE_Word minor, void *dark_pattern)
475 {
476 SANE_Byte *pattern = (SANE_Byte *) dark_pattern;
477 SANE_Word j;
478
479 DBG (5, "usb_high_cal_i8o8_fill_in_dark: start, major=%d, minor=%d\n",
480 major, minor);
481 if (!cal->is_prepared)
482 {
483 DBG (3, "usb_high_cal_i8o8_fill_in_dark: !is_prepared\n");
484 return SANE_FALSE;
485 }
486 if (cal->dark_needed == 0)
487 {
488 DBG (3, "usb_high_cal_i8o8_fill_in_dark: dark_needed==0\n");
489 return SANE_FALSE;
490 }
491
492 for (j = 0; j < cal->width; j++)
493 {
494 cal->dark_line[j] += (double) (pattern[j]);
495 }
496 DBG (5, "usb_high_cal_i8o8_fill_in_dark: exit\n");
497 return SANE_STATUS_GOOD;
498 }
499
500 SANE_Status
usb_high_cal_i4o1_fill_in_white(Calibrator * cal,SANE_Word major,SANE_Word minor,void * white_pattern)501 usb_high_cal_i4o1_fill_in_white (Calibrator * cal, SANE_Word major,
502 SANE_Word minor, void *white_pattern)
503 {
504 SANE_Byte *pattern;
505 SANE_Word j = 0;
506
507 pattern = (SANE_Byte *) white_pattern;
508
509 DBG (5, "usb_high_cal_i4o1_fill_in_white: minor=%d\n", minor);
510 if (!cal->is_prepared)
511 {
512 DBG (3, "usb_high_cal_i4o1_fill_in_white: !is_prepared\n");
513 return SANE_STATUS_INVAL;
514 }
515 if (cal->white_needed == 0)
516 {
517 DBG (3, "usb_high_cal_i4o1_fill_in_white: white_needed==0\n");
518 return SANE_STATUS_INVAL;
519 }
520
521 while (j < cal->width)
522 {
523 *(cal->white_buffer + major * cal->width + j) +=
524 (SANE_Int) (*(pattern) & 0xf0);
525 j++;
526 if (j >= cal->width)
527 break;
528 *(cal->white_buffer + major * cal->width + j) +=
529 (SANE_Int) ((SANE_Byte) (*(pattern++) << 4));
530 j++;
531 }
532 DBG (5, "usb_high_cal_i8o8_fill_in_white: exit\n");
533 return SANE_STATUS_GOOD;
534 }
535
536 SANE_Status
usb_high_cal_i4o1_fill_in_dark(Calibrator * cal,SANE_Word major,SANE_Word minor,void * dark_pattern)537 usb_high_cal_i4o1_fill_in_dark (Calibrator * cal, SANE_Word major,
538 SANE_Word minor, void *dark_pattern)
539 {
540 SANE_Byte *pattern;
541 SANE_Word j = 0;
542
543 pattern = (SANE_Byte *) dark_pattern;
544
545 DBG (5, "usb_high_cal_i4o1_fill_in_dark: start, major=%d, minor=%d\n",
546 major, minor);
547 if (!cal->is_prepared)
548 {
549 DBG (3, "usb_high_cal_i4o1_fill_in_dark: !is_prepared\n");
550 return SANE_STATUS_INVAL;
551 }
552 if (cal->dark_needed == 0)
553 {
554 DBG (5, "usb_high_cal_i4o1_fill_in_dark: dark_needed==0\n");
555 return SANE_STATUS_INVAL;
556 }
557
558 while (j < cal->width)
559 {
560 cal->dark_line[j++] += (double) (*(pattern) & 0xf0);
561 if (j >= cal->width)
562 break;
563 cal->dark_line[j++] += (double) ((SANE_Byte) (*(pattern++) << 4));
564 }
565 DBG (5, "usb_high_cal_i4o1_fill_in_dark: exit\n");
566 return SANE_STATUS_GOOD;
567 }
568
569 SANE_Status
usb_high_cal_i8o8_mono_calibrate(Calibrator * cal,void * src,void * target)570 usb_high_cal_i8o8_mono_calibrate (Calibrator * cal, void *src, void *target)
571 {
572 SANE_Byte *gray_src;
573 SANE_Byte *gray_target;
574 SANE_Int base = 0;
575 SANE_Word value = 0;
576 SANE_Word i;
577
578 DBG (5, "usb_high_cal_i8o8_mono_calibrate: start\n");
579
580 gray_src = (SANE_Byte *) src;
581 gray_target = (SANE_Byte *) target;
582
583 if (cal->gamma_table == NULL)
584 {
585 SANE_Word k_white_level = cal->k_white_level >> 4;
586 for (i = 0; i < cal->width; i++)
587 {
588 base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
589 - (SANE_Int) (cal->k_dark[i]);
590 if (base < 0)
591 base = 0;
592 value = ((SANE_Word) (base) * k_white_level) / cal->k_white[i];
593 if (value > 0x00ff)
594 value = 0x00ff;
595 gray_target[i] = (SANE_Byte) (value);
596 }
597 }
598 else
599 {
600 for (i = 0; i < cal->width; i++)
601 {
602 base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
603 - (SANE_Int) (cal->k_dark[i]);
604 if (base < 0)
605 base = 0;
606 value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[i];
607 if (value > 0x0fff)
608 value = 0x0fff;
609 gray_target[i] = (SANE_Byte) (cal->gamma_table[value]);
610 }
611 }
612 DBG (5, "usb_high_cal_i8o8_mono_calibrate: exit\n");
613 return SANE_STATUS_GOOD;
614 }
615
616 SANE_Status
usb_high_cal_i8o8_rgb_calibrate(Calibrator * cal,void * src,void * target)617 usb_high_cal_i8o8_rgb_calibrate (Calibrator * cal, void *src, void *target)
618 {
619 SANE_Byte *gray_src;
620 SANE_Byte *rgb_target;
621 SANE_Int base = 0;
622 SANE_Word value = 0;
623 SANE_Word i;
624
625 DBG (5, "usb_high_cal_i8o8_rgb_calibrate: start\n");
626 gray_src = (SANE_Byte *) src;
627 rgb_target = (SANE_Byte *) target;
628
629 if (cal->gamma_table == NULL)
630 {
631 SANE_Word k_white_level = cal->k_white_level >> 4;
632 for (i = 0; i < cal->width; i++)
633 {
634 base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
635 - (SANE_Int) (cal->k_dark[i]);
636 if (base < 0)
637 base = 0;
638 value = ((SANE_Word) (base) * k_white_level) / cal->k_white[i];
639 if (value > 0x00ff)
640 value = 0x00ff;
641 *rgb_target = (SANE_Byte) (value);
642 rgb_target += 3;
643 }
644 }
645 else
646 {
647 for (i = 0; i < cal->width; i++)
648 {
649 base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
650 - (SANE_Int) (cal->k_dark[i]);
651 if (base < 0)
652 base = 0;
653 value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[i];
654 if (value > 0x0fff)
655 value = 0x0fff;
656 *(rgb_target) = (SANE_Byte) (cal->gamma_table[value]);
657 rgb_target += 3;
658 }
659 }
660 DBG (5, "usb_high_cal_i8o8_rgb_calibrate: start\n");
661 return SANE_STATUS_GOOD;
662 }
663
664 SANE_Status
usb_high_cal_i4o1_calibrate(Calibrator * cal,void * src,void * target)665 usb_high_cal_i4o1_calibrate (Calibrator * cal, void *src, void *target)
666 {
667 SANE_Byte *local_src;
668 SANE_Byte *local_target;
669 SANE_Int base = 0;
670 SANE_Word value = 0;
671 SANE_Word j = 0;
672 SANE_Int count = 0;
673
674 DBG (5, "usb_high_cal_i4o1_calibrate: start\n");
675 local_src = (SANE_Byte *) src;
676 local_target = (SANE_Byte *) target;
677
678 *local_target = 0;
679 while (j < cal->width)
680 {
681 base =
682 (SANE_Int) ((SANE_Word) (*local_src & 0xf0) << 4)
683 - (SANE_Int) (cal->k_dark[j]);
684 if (base < 0)
685 base = 0;
686 value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[j];
687 if (value > 0x0fff)
688 value = 0x0fff;
689 if (value >= cal->threshold)
690 *(local_target) |= gray_map[count];
691 count++;
692 j++;
693 if (j >= cal->width)
694 break;
695 base = (SANE_Int) ((SANE_Word) (*(local_src++) & 0x0f) << 8) -
696 (SANE_Int) (cal->k_dark[j]);
697 if (base < 0)
698 base = 0;
699 value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[j];
700 if (value > 0x0fff)
701 value = 0x0fff;
702 if (value >= cal->threshold)
703 *(local_target) |= gray_map[count];
704 count++;
705 if (count >= 8)
706 {
707 local_target++;
708 *local_target = 0;
709 count = 0;
710 }
711 j++;
712 }
713 DBG (5, "usb_high_cal_i4o1_calibrate: exit\n");
714 return SANE_STATUS_GOOD;
715 }
716
717
718 /* --------------------------- scan functions ----------------------------- */
719
720
721 SANE_Status
usb_high_scan_init(Mustek_Usb_Device * dev)722 usb_high_scan_init (Mustek_Usb_Device * dev)
723 {
724 SANE_Status status;
725
726 DBG (5, "usb_high_scan_init: start\n");
727
728 dev->init_bytes_per_strip = 8 * 1024;
729 dev->adjust_length_300 = 2560;
730 dev->adjust_length_600 = 5120;
731 dev->init_min_expose_time = 4992;
732 dev->init_skips_per_row_300 = 56; /* this value must be times of 6 */
733 dev->init_skips_per_row_600 = 72; /* this value must be times of 6 */
734 dev->init_j_lines = 154;
735 dev->init_k_lines = 16;
736 dev->init_k_filter = 8;
737 dev->init_k_loops = 2;
738 dev->init_pixel_rate_lines = 50;
739 dev->init_pixel_rate_filts = 37;
740 dev->init_powerdelay_lines = 2;
741 dev->init_home_lines = 160;
742 dev->init_dark_lines = 50;
743 dev->init_k_level = 245;
744 dev->init_max_power_delay = 240;
745 dev->init_min_power_delay = 136;
746 dev->init_adjust_way = 1;
747 dev->init_green_black_factor = 0.0;
748 dev->init_blue_black_factor = 0.0;
749 dev->init_red_black_factor = 0.0;
750 dev->init_gray_black_factor = 0.0;
751 dev->init_green_factor = 0.82004;
752 dev->init_blue_factor = 0.84954;
753 dev->init_red_factor = 0.826375;
754 dev->init_gray_factor = 0.833375;
755
756 dev->init_red_rgb_600_pga = 8;
757 dev->init_green_rgb_600_pga = 8;
758 dev->init_blue_rgb_600_pga = 8;
759 dev->init_mono_600_pga = 8;
760 dev->init_red_rgb_300_pga = 8;
761 dev->init_green_rgb_300_pga = 8;
762 dev->init_blue_rgb_300_pga = 8;
763 dev->init_mono_300_pga = 8;
764 dev->init_expose_time = 9024;
765 dev->init_red_rgb_600_power_delay = 80;
766 dev->init_green_rgb_600_power_delay = 80;
767 dev->init_blue_rgb_600_power_delay = 80;
768 dev->init_red_mono_600_power_delay = 80;
769 dev->init_green_mono_600_power_delay = 80;
770 dev->init_blue_mono_600_power_delay = 80;
771 dev->init_red_rgb_300_power_delay = 80;
772 dev->init_green_rgb_300_power_delay = 80;
773 dev->init_blue_rgb_300_power_delay = 80;
774 dev->init_red_mono_300_power_delay = 80;
775 dev->init_green_mono_300_power_delay = 80;
776 dev->init_blue_mono_300_power_delay = 80;
777 dev->init_threshold = 128;
778
779 dev->init_top_ref = 128;
780 dev->init_front_end = 16;
781 dev->init_red_offset = 0;
782 dev->init_green_offset = 0;
783 dev->init_blue_offset = 0;
784
785 dev->init_rgb_24_back_track = 80;
786 dev->init_mono_8_back_track = 80;
787
788 dev->is_open = SANE_FALSE;
789 dev->is_prepared = SANE_FALSE;
790 dev->expose_time = 4000;
791 dev->width = 2550;
792 dev->x_dpi = 300;
793 dev->y_dpi = 300;
794 dev->scan_mode = RGB24EXT;
795 dev->bytes_per_row = 2550 * 3;
796 dev->dummy = 0;
797 dev->bytes_per_strip = 2550;
798 dev->image_buffer = NULL;
799 dev->red = NULL;
800 dev->green = NULL;
801 dev->blue = NULL;
802 dev->get_line = NULL;
803 dev->backtrack = NULL;
804 dev->is_adjusted_rgb_600_power_delay = SANE_FALSE;
805 dev->is_adjusted_mono_600_power_delay = SANE_FALSE;
806 dev->is_adjusted_rgb_300_power_delay = SANE_FALSE;
807 dev->is_adjusted_mono_300_power_delay = SANE_FALSE;
808 dev->is_evaluate_pixel_rate = SANE_FALSE;
809 dev->red_rgb_600_pga = 0;
810 dev->green_rgb_600_pga = 0;
811 dev->blue_rgb_600_pga = 0;
812 dev->mono_600_pga = 0;
813 dev->red_rgb_600_power_delay = 0;
814 dev->green_rgb_600_power_delay = 0;
815 dev->blue_rgb_600_power_delay = 0;
816 dev->red_mono_600_power_delay = 0;
817 dev->green_mono_600_power_delay = 0;
818 dev->blue_mono_600_power_delay = 0;
819 dev->red_rgb_300_pga = 0;
820 dev->green_rgb_300_pga = 0;
821 dev->blue_rgb_300_pga = 0;
822 dev->mono_300_pga = 0;
823 dev->red_rgb_300_power_delay = 0;
824 dev->green_rgb_300_power_delay = 0;
825 dev->blue_rgb_300_power_delay = 0;
826 dev->red_mono_300_power_delay = 0;
827 dev->green_mono_300_power_delay = 0;
828 dev->blue_mono_300_power_delay = 0;
829 dev->pixel_rate = 2000;
830 dev->threshold = 128;
831 dev->gamma_table = 0;
832 dev->skips_per_row = 0;
833
834
835 dev->red_calibrator = NULL;
836 dev->green_calibrator = NULL;
837 dev->blue_calibrator = NULL;
838 dev->mono_calibrator = NULL;
839
840 dev->is_cis_detected = SANE_FALSE;
841 dev->is_sensor_detected = SANE_FALSE;
842
843 RIE (usb_low_init (&dev->chip));
844
845 DBG (5, "usb_high_scan_init: exit\n");
846 return SANE_STATUS_GOOD;
847 }
848
849 SANE_Status
usb_high_scan_exit(Mustek_Usb_Device * dev)850 usb_high_scan_exit (Mustek_Usb_Device * dev)
851 {
852 SANE_Status status;
853
854 DBG (5, "usb_high_scan_exit: start\n");
855 if (!dev->chip)
856 {
857 DBG (5, "usb_high_scan_exit: already exited (`%s')\n", dev->name);
858 return SANE_STATUS_INVAL;
859 }
860
861 RIE (usb_low_exit (dev->chip));
862 dev->chip = 0;
863 DBG (5, "usb_high_scan_exit: exit\n");
864 return SANE_STATUS_GOOD;
865 }
866
867 SANE_Status
usb_high_scan_prepare(Mustek_Usb_Device * dev)868 usb_high_scan_prepare (Mustek_Usb_Device * dev)
869 {
870 DBG (5, "usb_high_scan_prepare: start dev=%p\n", (void *) dev);
871 if (dev->is_prepared)
872 {
873 DBG (5, "usb_high_scan_prepare: is already prepared\n");
874 return SANE_STATUS_GOOD;
875 }
876 if (dev->image_buffer)
877 {
878 free (dev->image_buffer);
879 }
880 dev->image_buffer = (SANE_Byte *) malloc (dev->init_bytes_per_strip * 3);
881 if (!dev->image_buffer)
882 return SANE_STATUS_NO_MEM;
883
884 dev->red = dev->image_buffer;
885 dev->green = dev->image_buffer + dev->init_bytes_per_strip;
886 dev->blue = dev->image_buffer + dev->init_bytes_per_strip * 2;
887
888 dev->is_prepared = SANE_TRUE;
889 DBG (5, "usb_high_scan_prepare: exit\n");
890 return SANE_STATUS_GOOD;
891 }
892
893 SANE_Status
usb_high_scan_clearup(Mustek_Usb_Device * dev)894 usb_high_scan_clearup (Mustek_Usb_Device * dev)
895 {
896 DBG (5, "usb_high_scan_clearup: start, dev=%p\n", (void *) dev);
897 if (!dev->is_prepared)
898 {
899 DBG (3, "usb_high_scan_clearup: is not prepared\n");
900 return SANE_STATUS_INVAL;
901 }
902 if (dev->image_buffer)
903 {
904 free (dev->image_buffer);
905 }
906 dev->image_buffer = NULL;
907 dev->red = NULL;
908 dev->green = NULL;
909 dev->blue = NULL;
910
911 dev->is_prepared = SANE_FALSE;
912 DBG (5, "usb_high_scan_clearup: exit\n");
913 return SANE_STATUS_GOOD;
914 }
915
916 SANE_Status
usb_high_scan_turn_power(Mustek_Usb_Device * dev,SANE_Bool is_on)917 usb_high_scan_turn_power (Mustek_Usb_Device * dev, SANE_Bool is_on)
918 {
919 SANE_Status status;
920
921 DBG (5, "usb_high_scan_turn_power: start, turn %s power\n",
922 is_on ? "on" : "off");
923
924 if (is_on)
925 {
926 if (dev->is_open)
927 {
928 DBG (3, "usb_high_scan_turn_power: wanted to turn on power, "
929 "but scanner already open\n");
930 return SANE_STATUS_INVAL;
931 }
932 RIE (usb_low_open (dev->chip, dev->device_name));
933 dev->is_open = SANE_TRUE;
934 RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE));
935 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
936 }
937 else
938 {
939 if (!dev->is_open)
940 {
941 DBG (3, "usb_high_scan_turn_power: wanted to turn off power, "
942 "but scanner already closed\n");
943 return SANE_STATUS_INVAL;
944 }
945 RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
946 RIE (usb_low_close (dev->chip));
947 dev->is_open = SANE_FALSE;
948 }
949
950 DBG (5, "usb_high_scan_turn_power: exit\n");
951 return SANE_STATUS_GOOD;
952 }
953
954 SANE_Status
usb_high_scan_back_home(Mustek_Usb_Device * dev)955 usb_high_scan_back_home (Mustek_Usb_Device * dev)
956 {
957 SANE_Status status;
958
959 DBG (5, "usb_high_scan_back_home: start\n");
960
961 if (!dev->is_open)
962 {
963 DBG (3, "usb_high_scan_back_home: not open\n");
964 return SANE_STATUS_INVAL;
965 }
966
967 RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
968 RIE (usb_mid_motor_prepare_home (dev->chip));
969
970 DBG (5, "usb_high_scan_back_home: exit\n");
971 return SANE_STATUS_GOOD;
972 }
973
974 SANE_Status
usb_high_scan_set_threshold(Mustek_Usb_Device * dev,SANE_Byte threshold)975 usb_high_scan_set_threshold (Mustek_Usb_Device * dev, SANE_Byte threshold)
976 {
977 DBG (5, "usb_high_scan_set_threshold: start, dev=%p, threshold=%d\n",
978 (void *) dev, threshold);
979
980 dev->threshold = threshold;
981 DBG (5, "usb_high_scan_set_threshold: exit\n");
982 return SANE_STATUS_GOOD;
983 }
984
985 SANE_Status
usb_high_scan_embed_gamma(Mustek_Usb_Device * dev,SANE_Word * gamma_table)986 usb_high_scan_embed_gamma (Mustek_Usb_Device * dev, SANE_Word * gamma_table)
987 {
988 DBG (5, "usb_high_scan_embed_gamma: start, dev=%p, gamma_table=%p\n",
989 (void *) dev, (void *) gamma_table);
990 if (!dev->is_prepared)
991 {
992 DBG (5, "usb_high_scan_embed_gamma !is_prepared\n");
993 return SANE_STATUS_INVAL;
994 }
995
996 dev->gamma_table = gamma_table;
997 DBG (5, "usb_high_scan_embed_gamma: exit\n");
998 return SANE_STATUS_GOOD;
999 }
1000
1001 SANE_Status
usb_high_scan_reset(Mustek_Usb_Device * dev)1002 usb_high_scan_reset (Mustek_Usb_Device * dev)
1003 {
1004 SANE_Status status;
1005
1006 DBG (5, "usb_high_scan_reset: start\n");
1007
1008 if (!dev->is_open)
1009 {
1010 DBG (3, "usb_high_scan_reset: not open\n");
1011 return SANE_STATUS_INVAL;
1012 }
1013 if (!dev->is_prepared)
1014 {
1015 DBG (3, "usb_high_scan_reset: !is_prepared\n");
1016 return SANE_STATUS_INVAL;
1017 }
1018 RIE (usb_high_scan_init_asic (dev, dev->chip->sensor));
1019 RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
1020 RIE (usb_mid_motor_prepare_home (dev->chip));
1021 RIE (usb_high_scan_set_threshold (dev, dev->init_threshold));
1022 RIE (usb_high_scan_embed_gamma (dev, NULL));
1023 dev->is_adjusted_rgb_600_power_delay = SANE_FALSE;
1024 dev->is_adjusted_mono_600_power_delay = SANE_FALSE;
1025 dev->is_adjusted_rgb_300_power_delay = SANE_FALSE;
1026 dev->is_adjusted_mono_300_power_delay = SANE_FALSE;
1027 dev->is_evaluate_pixel_rate = SANE_FALSE;
1028 DBG (5, "usb_high_scan_reset: exit\n");
1029 return SANE_STATUS_GOOD;
1030 }
1031
1032 SANE_Status
usb_high_scan_wait_carriage_home(Mustek_Usb_Device * dev)1033 usb_high_scan_wait_carriage_home (Mustek_Usb_Device * dev)
1034 {
1035 SANE_Status status;
1036
1037 DBG (5, "usb_high_scan_wait_carriage_home: start\n");
1038
1039 status = usb_low_get_home_sensor (dev->chip);
1040
1041 if (status != SANE_STATUS_GOOD)
1042 {
1043 RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
1044 RIE (usb_mid_motor_prepare_home (dev->chip));
1045 do
1046 {
1047 status = usb_low_get_home_sensor (dev->chip);
1048 if (status != SANE_STATUS_GOOD)
1049 usleep (18 * 1000);
1050 }
1051 while (status != SANE_STATUS_GOOD);
1052 }
1053
1054 /* No Motor & Forward */
1055 RIE (usb_low_move_motor_home (dev->chip, SANE_FALSE, SANE_FALSE));
1056 DBG (5, "usb_high_scan_wait_carriage_home: exit\n");
1057 return SANE_STATUS_GOOD;
1058 }
1059
1060 SANE_Status
usb_high_scan_hardware_calibration(Mustek_Usb_Device * dev)1061 usb_high_scan_hardware_calibration (Mustek_Usb_Device * dev)
1062 {
1063 SANE_Status status;
1064
1065 DBG (5, "usb_high_scan_hardware_calibration: start\n");
1066
1067 if (dev->is_cis_detected)
1068 RIE (usb_high_scan_safe_forward (dev, dev->init_home_lines));
1069
1070 switch (dev->init_adjust_way)
1071 {
1072 case 1: /* CIS */
1073 switch (dev->scan_mode)
1074 {
1075 case RGB24EXT:
1076 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1077 {
1078 dev->expose_time = dev->init_expose_time;
1079 dev->red_rgb_600_pga = dev->init_red_rgb_600_pga;
1080 dev->green_rgb_600_pga = dev->init_green_rgb_600_pga;
1081 dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga;
1082 RIE (usb_high_scan_adjust_rgb_600_power_delay (dev));
1083 }
1084 else
1085 {
1086 dev->expose_time = dev->init_expose_time;
1087 dev->red_rgb_300_pga = dev->init_red_rgb_300_pga;
1088 dev->green_rgb_300_pga = dev->init_green_rgb_300_pga;
1089 dev->blue_rgb_300_pga = dev->init_blue_rgb_300_pga;
1090 RIE (usb_high_scan_adjust_rgb_300_power_delay (dev));
1091 }
1092 break;
1093 case GRAY8EXT:
1094 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1095 {
1096 dev->expose_time = dev->init_expose_time;
1097 dev->mono_600_pga = dev->init_mono_600_pga;
1098 RIE (usb_high_scan_evaluate_pixel_rate (dev));
1099 RIE (usb_high_scan_adjust_mono_600_power_delay (dev));
1100 }
1101 else
1102 {
1103 dev->expose_time = dev->init_expose_time;
1104 dev->mono_300_pga = dev->init_mono_300_pga;
1105 RIE (usb_high_scan_evaluate_pixel_rate (dev));
1106 RIE (usb_high_scan_adjust_mono_300_power_delay (dev));
1107 }
1108 break;
1109 default:
1110 break;
1111 }
1112 break;
1113 case 3: /* CCD */
1114 switch (dev->scan_mode)
1115 {
1116 case RGB24EXT:
1117 dev->red_rgb_600_pga = dev->init_red_rgb_600_pga;
1118 dev->green_rgb_600_pga = dev->init_green_rgb_600_pga;
1119 dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga;
1120 dev->skips_per_row = dev->init_skips_per_row_600;
1121 /* RIE(usb_high_scan_adjust_rgb_600_exposure (dev); fixme */
1122 /* RIE(usb_high_scan_adjust_rgb_600_offset (dev); fixme */
1123 /* RIE(usb_high_scan_adjust_rgb_600_pga (dev); fixme */
1124 /* m_isAdjustedRgb600Offset=FALSE; */
1125 /* RIE(usb_high_scan_adjust_rgb_600_offset (dev); fixme */
1126 /* RIE(usb_high_scan_adjust_rgb_600_skips_per_row (dev); fixme */
1127 break;
1128 case GRAY8EXT:
1129 dev->mono_600_pga = dev->init_mono_600_pga;
1130 dev->skips_per_row = dev->init_skips_per_row_600;
1131 RIE (usb_high_scan_adjust_mono_600_exposure (dev));
1132 /* RIE(usb_high_scan_adjust_mono_600_offset (dev); fixme */
1133 /* RIE(usb_high_scan_adjust_mono_600_pga (dev); fixme */
1134 dev->is_adjusted_mono_600_offset = SANE_FALSE;
1135 /* RIE(usb_high_scan_adjust_mono_600_offset (dev); fixme */
1136 /* RIE(usb_high_scan_adjust_mono_600_skips_per_row (dev); fixme */
1137 break;
1138 default:
1139 break;
1140 }
1141 break;
1142 default:
1143 dev->expose_time = dev->init_expose_time;
1144 dev->red_rgb_600_power_delay = dev->init_red_rgb_600_power_delay;
1145 dev->green_rgb_600_power_delay = dev->init_green_rgb_600_power_delay;
1146 dev->blue_rgb_600_power_delay = dev->init_blue_rgb_600_power_delay;
1147 dev->red_mono_600_power_delay = dev->init_red_mono_600_power_delay;
1148 dev->green_mono_600_power_delay = dev->init_green_mono_600_power_delay;
1149 dev->blue_mono_600_power_delay = dev->init_blue_mono_600_power_delay;
1150 dev->red_rgb_600_pga = dev->init_red_rgb_600_pga;
1151 dev->green_rgb_600_pga = dev->init_green_rgb_600_pga;
1152 dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga;
1153 dev->mono_600_pga = dev->init_mono_600_pga;
1154 dev->red_rgb_300_power_delay = dev->init_red_rgb_300_power_delay;
1155 dev->green_rgb_300_power_delay = dev->init_green_rgb_300_power_delay;
1156 dev->blue_rgb_300_power_delay = dev->init_blue_rgb_300_power_delay;
1157 dev->red_mono_300_power_delay = dev->init_red_mono_300_power_delay;
1158 dev->green_mono_300_power_delay = dev->init_green_mono_300_power_delay;
1159 dev->blue_mono_300_power_delay = dev->init_blue_mono_300_power_delay;
1160 dev->red_rgb_300_pga = dev->init_red_rgb_300_pga;
1161 dev->green_rgb_300_pga = dev->init_green_rgb_300_pga;
1162 dev->blue_rgb_300_pga = dev->init_blue_rgb_300_pga;
1163 dev->mono_300_pga = dev->init_mono_300_pga;
1164 break;
1165 }
1166 DBG (5, "usb_high_scan_hardware_calibration: exit\n");
1167 return SANE_STATUS_GOOD;
1168 }
1169
1170 SANE_Status
usb_high_scan_line_calibration(Mustek_Usb_Device * dev)1171 usb_high_scan_line_calibration (Mustek_Usb_Device * dev)
1172 {
1173 SANE_Status status;
1174
1175 DBG (5, "usb_high_scan_line_calibration: start\n");
1176 switch (dev->scan_mode)
1177 {
1178 case RGB24EXT:
1179 RIE (usb_high_scan_prepare_rgb_24 (dev));
1180 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1181 RIE (usb_high_scan_prepare_rgb_signal_600_dpi (dev));
1182 else
1183 RIE (usb_high_scan_prepare_rgb_signal_300_dpi (dev));
1184 RIE (usb_mid_sensor_prepare_rgb (dev->chip, dev->x_dpi));
1185 RIE (usb_high_scan_calibration_rgb_24 (dev));
1186 break;
1187 case GRAY8EXT:
1188 RIE (usb_high_scan_prepare_mono_8 (dev));
1189 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1190 RIE (usb_high_scan_prepare_mono_signal_600_dpi (dev));
1191 else
1192 RIE (usb_high_scan_prepare_mono_signal_300_dpi (dev));
1193 RIE (usb_mid_sensor_prepare_mono (dev->chip, dev->x_dpi));
1194 RIE (usb_high_scan_calibration_mono_8 (dev));
1195 break;
1196 default:
1197 DBG (3, "usb_high_scan_line_calibration: mode not matched\n");
1198 return SANE_STATUS_INVAL;
1199 break;
1200 }
1201 DBG (5, "usb_high_scan_line_calibration: exit\n");
1202 return SANE_STATUS_GOOD;
1203 }
1204
1205 SANE_Status
usb_high_scan_prepare_scan(Mustek_Usb_Device * dev)1206 usb_high_scan_prepare_scan (Mustek_Usb_Device * dev)
1207 {
1208 SANE_Status status;
1209
1210 DBG (5, "usb_high_scan_prepare_scan: start\n");
1211 switch (dev->scan_mode)
1212 {
1213 case RGB24EXT:
1214 RIE (usb_high_scan_prepare_rgb_24 (dev));
1215 dev->get_line = &usb_high_scan_get_rgb_24_bit_line;
1216 dev->backtrack = &usb_high_scan_backtrack_rgb_24;
1217
1218 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1219 RIE (usb_high_scan_prepare_rgb_signal_600_dpi (dev));
1220 else
1221 RIE (usb_high_scan_prepare_rgb_signal_300_dpi (dev));
1222 RIE (usb_mid_sensor_prepare_rgb (dev->chip, dev->x_dpi));
1223 RIE (usb_mid_motor_prepare_rgb (dev->chip, dev->y_dpi));
1224 break;
1225 case GRAY8EXT:
1226 RIE (usb_high_scan_prepare_mono_8 (dev));
1227 dev->get_line = &usb_high_scan_get_mono_8_bit_line;
1228 dev->backtrack = &usb_high_scan_backtrack_mono_8;
1229 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1230 RIE (usb_high_scan_prepare_mono_signal_600_dpi (dev));
1231 else
1232 RIE (usb_high_scan_prepare_mono_signal_300_dpi (dev));
1233 RIE (usb_mid_sensor_prepare_mono (dev->chip, dev->x_dpi));
1234 RIE (usb_mid_motor_prepare_mono (dev->chip, dev->y_dpi));
1235 break;
1236 default:
1237 DBG (5, "usb_high_scan_prepare_scan: unmatched mode\n");
1238 return SANE_STATUS_INVAL;
1239 break;
1240 }
1241 DBG (5, "usb_high_scan_prepare_scan: exit\n");
1242 return SANE_STATUS_GOOD;
1243 }
1244
1245 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)1246 usb_high_scan_suggest_parameters (Mustek_Usb_Device * dev, SANE_Word dpi,
1247 SANE_Word x, SANE_Word y, SANE_Word width,
1248 SANE_Word height, Colormode color_mode)
1249 {
1250 SANE_Status status;
1251
1252 DBG (5, "usb_high_scan_suggest_parameters: start\n");
1253
1254 RIE (usb_high_scan_detect_sensor (dev));
1255 /* Looking up Optical Y Resolution */
1256 RIE (usb_mid_motor_get_dpi (dev->chip, dpi, &dev->y_dpi));
1257 /* Looking up Optical X Resolution */
1258 RIE (usb_mid_sensor_get_dpi (dev->chip, dpi, &dev->x_dpi));
1259
1260 dev->x = x * dev->x_dpi / dpi;
1261 dev->y = y * dev->y_dpi / dpi;
1262 dev->width = width * dev->x_dpi / dpi;
1263 dev->height = height * dev->y_dpi / dpi;
1264
1265 switch (color_mode)
1266 {
1267 case RGB24:
1268 dev->scan_mode = RGB24EXT;
1269 dev->bytes_per_row = dev->width * 3;
1270 dev->bpp = 24;
1271 break;
1272 case GRAY8:
1273 dev->scan_mode = GRAY8EXT;
1274 dev->bpp = 8;
1275 dev->bytes_per_row = dev->width;
1276 break;
1277 default:
1278 DBG (3, "usb_high_scan_suggest_parameters: unmatched mode\n");
1279 return SANE_STATUS_INVAL;
1280 break;
1281 }
1282 DBG (5, "usb_high_scan_suggest_parameters: exit\n");
1283 return SANE_STATUS_GOOD;
1284 }
1285
1286 SANE_Status
usb_high_scan_detect_sensor(Mustek_Usb_Device * dev)1287 usb_high_scan_detect_sensor (Mustek_Usb_Device * dev)
1288 {
1289 if (dev->is_sensor_detected)
1290 {
1291 DBG (5, "usb_high_scan_detect_sensor: sensor already detected\n");
1292 return SANE_STATUS_GOOD;
1293 }
1294 dev->is_sensor_detected = SANE_TRUE;
1295
1296 switch (dev->chip->scanner_type)
1297 {
1298 case MT_600CU:
1299 dev->chip->sensor = ST_CANON300;
1300 dev->chip->motor = MT_600;
1301 dev->is_cis_detected = SANE_TRUE;
1302 DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 300 dpi, motor="
1303 "600 dpi\n");
1304 break;
1305 case MT_1200USB:
1306 dev->chip->sensor = ST_NEC600;
1307 dev->chip->motor = MT_1200;
1308 dev->init_min_expose_time = 2250;
1309 dev->init_skips_per_row_600 = 0;
1310 dev->init_home_lines = 32;
1311 dev->init_dark_lines = 10;
1312 dev->init_max_power_delay = 220;
1313 dev->init_min_power_delay = 220;
1314 dev->init_adjust_way = 3;
1315 dev->init_red_rgb_600_pga = 30;
1316 dev->init_green_rgb_600_pga = 30;
1317 dev->init_blue_rgb_600_pga = 30;
1318 dev->init_mono_600_pga = 30;
1319 dev->init_expose_time = 16000;
1320
1321 dev->init_top_ref = 6;
1322 dev->init_front_end = 12;
1323 dev->init_red_offset = 128;
1324 dev->init_green_offset = 128;
1325 dev->init_blue_offset = 128;
1326
1327 dev->init_rgb_24_back_track = 0;
1328 dev->init_mono_8_back_track = 40;
1329
1330 dev->is_cis_detected = SANE_FALSE;
1331
1332 DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 600 dpi, motor="
1333 "1200 dpi\n");
1334 break;
1335 case MT_1200UB:
1336 case MT_1200CU_PLUS:
1337 case MT_1200CU: /* need to check if it's a 300600 or 600 dpi sensor */
1338 {
1339 SANE_Byte *buffer;
1340 static SANE_Word l_temp = 0, r_temp = 0;
1341 SANE_Int i;
1342 SANE_Status status;
1343 SANE_Word lines_left;
1344
1345 dev->chip->motor = MT_1200;
1346 dev->is_cis_detected = SANE_TRUE;
1347
1348 buffer = NULL;
1349 l_temp = 0;
1350 r_temp = 0;
1351
1352 buffer = (SANE_Byte *) malloc (dev->init_bytes_per_strip);
1353
1354 if (!buffer)
1355 return SANE_STATUS_NO_MEM;
1356
1357 for (i = 0; i < 5400; i++)
1358 buffer[i] = 0xaa;
1359
1360 dev->scan_mode = GRAY8EXT;
1361 dev->x_dpi = 600;
1362 dev->y_dpi = 1200;
1363 dev->width = 5400;
1364
1365 RIE (usb_high_scan_init_asic (dev, ST_CANON600));
1366 RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE));
1367 RIE (usb_low_enable_motor (dev->chip, SANE_TRUE)); /* Enable Motor */
1368 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
1369 RIE (usb_low_invert_image (dev->chip, SANE_FALSE));
1370 RIE (usb_low_set_image_dpi (dev->chip, SANE_TRUE, SW_P6P6));
1371 dev->bytes_per_strip = dev->adjust_length_600;
1372 dev->bytes_per_row = 5400;
1373 dev->dummy = 0;
1374
1375 RIE (usb_high_scan_wait_carriage_home (dev));
1376 RIE (usb_high_scan_hardware_calibration (dev));
1377 RIE (usb_high_scan_prepare_scan (dev));
1378
1379 /* Get Data */
1380 RIE (usb_low_start_rowing (dev->chip));
1381 RIE (usb_low_get_row (dev->chip, buffer, &lines_left));
1382 RIE (usb_low_stop_rowing (dev->chip));
1383 /* Calculate */
1384 for (i = 0; i < 256; i++)
1385 l_temp = l_temp + buffer[512 + i];
1386 for (i = 0; i < 256; i++)
1387 r_temp = r_temp + buffer[3500 + i];
1388
1389 l_temp = l_temp / 256;
1390 r_temp = r_temp / 256;
1391
1392 /* 300/600 switch CIS or 600 CIS */
1393 DBG (5, "usb_high_scan_detect_sensor: l_temp=%d, r_temp=%d\n",
1394 l_temp, r_temp);
1395 if (r_temp > 50)
1396 {
1397 dev->chip->sensor = ST_CANON600;
1398 DBG (4,
1399 "usb_high_scan_detect_sensor: sensor=Canon 600 dpi, motor="
1400 "1200 dpi\n");
1401 }
1402 else
1403 {
1404 DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 300/600 dpi, "
1405 "motor=1200 dpi\n");
1406 dev->chip->sensor = ST_CANON300600;
1407 }
1408
1409 /* Release Resource */
1410 free (buffer);
1411 buffer = NULL;
1412
1413 break;
1414 }
1415 default:
1416 DBG (5, "usb_high_scan_detect_sensor: I don't know this scanner type "
1417 "(%d)\n", dev->chip->scanner_type);
1418 return SANE_STATUS_INVAL;
1419 }
1420
1421 return SANE_STATUS_GOOD;
1422 }
1423
1424
1425 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)1426 usb_high_scan_setup_scan (Mustek_Usb_Device * dev, Colormode color_mode,
1427 SANE_Word x_dpi, SANE_Word y_dpi,
1428 SANE_Bool is_invert, SANE_Word x, SANE_Word y,
1429 SANE_Word width)
1430 {
1431 SANE_Status status;
1432 SANE_Word upper_bound;
1433 SANE_Word left_bound;
1434
1435 DBG (5, "usb_high_scan_setup_scan: start, is_invert=%d\n", is_invert);
1436 if (!dev->is_open)
1437 {
1438 DBG (5, "usb_high_scan_setup_scan: not open\n");
1439 return SANE_STATUS_INVAL;
1440 }
1441 if (!dev->is_prepared)
1442 {
1443 DBG (5, "usb_high_scan_setup_scan: !is_prepared\n");
1444 return SANE_STATUS_INVAL;
1445 }
1446
1447 RIE (usb_high_scan_init_asic (dev, dev->chip->sensor));
1448 RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE));
1449 RIE (usb_low_enable_motor (dev->chip, SANE_TRUE)); /* Enable Motor */
1450 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
1451 RIE (usb_low_invert_image (dev->chip, SANE_FALSE));
1452 if (!dev->is_cis_detected)
1453 {
1454 usb_mid_front_set_front_end_mode (dev->chip, 16);
1455 usb_mid_front_enable (dev->chip, SANE_TRUE);
1456 usb_mid_front_set_top_reference (dev->chip, 244);
1457 usb_mid_front_set_rgb_signal (dev->chip);
1458 }
1459
1460 /* Compute necessary variables */
1461 dev->scan_mode = color_mode;
1462 dev->x_dpi = x_dpi;
1463 dev->y_dpi = y_dpi;
1464 dev->width = width;
1465
1466 switch (dev->scan_mode)
1467 {
1468 case RGB24EXT:
1469 dev->bytes_per_row = 3 * dev->width;
1470 upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines;
1471 break;
1472 case GRAY8EXT:
1473 dev->bytes_per_row = dev->width;
1474 upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines + 4;
1475 /* fixme */
1476 break;
1477 default:
1478 upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines + 4;
1479 break;
1480 }
1481
1482 if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
1483 {
1484 /* in 600dpi */
1485 left_bound = (x * 600 / dev->x_dpi) + dev->init_skips_per_row_600;
1486 dev->skips_per_row = (((left_bound % 32) * dev->x_dpi + 300) / 600);
1487 }
1488 else
1489 {
1490 /* in 300dpi */
1491 left_bound = (x * 300 / dev->x_dpi) + dev->init_skips_per_row_300;
1492 dev->skips_per_row = (((left_bound % 32) * dev->x_dpi + 150) / 300);
1493 }
1494
1495 dev->dummy = (left_bound / 32) * 32;
1496
1497 switch (dev->scan_mode)
1498 {
1499 case RGB24EXT:
1500 dev->bytes_per_strip = dev->skips_per_row + dev->width;
1501 break;
1502 case GRAY8EXT:
1503 dev->bytes_per_strip = dev->skips_per_row + dev->width;
1504 break;
1505 default:
1506 break;
1507 }
1508
1509 dev->bytes_per_strip = ((dev->bytes_per_strip + 1) / 2) * 2;
1510 /* make bytes_per_strip is as 2n to advoid 64n+1 */
1511
1512 RIE (usb_high_scan_wait_carriage_home (dev));
1513 RIE (usb_high_scan_hardware_calibration (dev));
1514 RIE (usb_high_scan_line_calibration (dev));
1515 RIE (usb_high_scan_step_forward (dev, upper_bound));
1516 RIE (usb_high_scan_prepare_scan (dev));
1517 RIE (usb_low_start_rowing (dev->chip));
1518 /* pat_chromator fixme (init for calibration?) */
1519 DBG (5, "usb_high_scan_setup_scan: exit\n");
1520 return SANE_STATUS_GOOD;
1521 }
1522
1523 SANE_Status
usb_high_scan_get_rows(Mustek_Usb_Device * dev,SANE_Byte * block,SANE_Word rows,SANE_Bool is_order_invert)1524 usb_high_scan_get_rows (Mustek_Usb_Device * dev, SANE_Byte * block,
1525 SANE_Word rows, SANE_Bool is_order_invert)
1526 {
1527 SANE_Status status;
1528
1529 DBG (5, "usb_high_scan_get_rows: start, %d rows\n", rows);
1530 if (!dev->is_open)
1531 {
1532 DBG (3, "usb_high_scan_get_rows: not open\n");
1533 return SANE_STATUS_INVAL;
1534 }
1535 if (!dev->is_prepared)
1536 {
1537 DBG (3, "usb_high_scan_get_rows: !is_prepared\n");
1538 return SANE_STATUS_INVAL;
1539 }
1540 while (rows > 0)
1541 {
1542 RIE ((*dev->get_line) (dev, block, is_order_invert));
1543 block += dev->bytes_per_row;
1544 rows--;
1545 }
1546 DBG (5, "usb_high_scan_get_rows: exit\n");
1547 return SANE_STATUS_GOOD;
1548 }
1549
1550 SANE_Status
usb_high_scan_stop_scan(Mustek_Usb_Device * dev)1551 usb_high_scan_stop_scan (Mustek_Usb_Device * dev)
1552 {
1553 SANE_Status status;
1554
1555 DBG (5, "usb_high_scan_stop_scan: start\n");
1556 if (!dev->is_open)
1557 {
1558 DBG (3, "usb_high_scan_stop_scan: not open\n");
1559 return SANE_STATUS_INVAL;
1560 }
1561 if (!dev->is_prepared)
1562 {
1563 DBG (3, "usb_high_scan_stop_scan: !is_prepared\n");
1564 return SANE_STATUS_INVAL;
1565 }
1566 switch (dev->scan_mode)
1567 {
1568 case RGB24EXT:
1569 RIE (usb_high_cal_exit (dev->blue_calibrator));
1570 if (dev->blue_calibrator)
1571 free (dev->blue_calibrator);
1572 dev->blue_calibrator = NULL;
1573 RIE (usb_high_cal_exit (dev->green_calibrator));
1574 if (dev->green_calibrator)
1575 free (dev->green_calibrator);
1576 dev->green_calibrator = NULL;
1577 RIE (usb_high_cal_exit (dev->red_calibrator));
1578 if (dev->red_calibrator)
1579 free (dev->red_calibrator);
1580 dev->red_calibrator = NULL;
1581 break;
1582 case GRAY8EXT:
1583 RIE (usb_high_cal_exit (dev->mono_calibrator));
1584 if (dev->mono_calibrator)
1585 free (dev->mono_calibrator);
1586 dev->mono_calibrator = NULL;
1587 break;
1588 default:
1589 break;
1590 }
1591
1592 RIE (usb_low_stop_rowing (dev->chip));
1593 if (!dev->is_cis_detected)
1594 RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
1595
1596 DBG (5, "usb_high_scan_stop_scan: exit\n");
1597 return SANE_STATUS_GOOD;
1598 }
1599
1600 SANE_Status
usb_high_scan_init_asic(Mustek_Usb_Device * dev,Sensor_Type sensor)1601 usb_high_scan_init_asic (Mustek_Usb_Device * dev, Sensor_Type sensor)
1602 {
1603 SANE_Byte ccd_dpi = 0;
1604 SANE_Byte select = 0;
1605 SANE_Byte adjust = 0;
1606 SANE_Byte pin = 0;
1607 SANE_Byte motor = 0;
1608 SANE_Bool fix_pattern = SANE_FALSE;
1609 SANE_Byte ad_timing = 0;
1610 Banksize bank_size;
1611 SANE_Status status;
1612
1613 DBG (5, "usb_high_scan_init_asic: start\n");
1614 switch (sensor)
1615 {
1616 case ST_TOSHIBA600:
1617 ccd_dpi = 32;
1618 select = 240;
1619 adjust = 0;
1620 pin = 18;
1621 motor = 0;
1622 fix_pattern = SANE_FALSE;
1623 ad_timing = 0;
1624 bank_size = BS_16K;
1625 DBG (5, "usb_high_scan_init_asic: sensor is set to TOSHIBA600\n");
1626 break;
1627 case ST_CANON300:
1628 ccd_dpi = 232;
1629 select = 232;
1630 adjust = 0;
1631 pin = 18;
1632 motor = 0;
1633 fix_pattern = SANE_FALSE;
1634 ad_timing = 1;
1635 bank_size = BS_4K;
1636 DBG (5, "usb_high_scan_init_asic: sensor is set to CANON300\n");
1637 break;
1638 case ST_CANON300600:
1639 ccd_dpi = 232;
1640 select = 232;
1641 adjust = 64;
1642 pin = 18;
1643 motor = 0;
1644 fix_pattern = SANE_FALSE;
1645 ad_timing = 1;
1646 bank_size = BS_16K;
1647 DBG (5, "usb_high_scan_init_asic: sensor is set to CANON300600\n");
1648 break;
1649 case ST_CANON600:
1650 ccd_dpi = 232;
1651 select = 232;
1652 adjust = 64;
1653 pin = 18;
1654 motor = 0;
1655 fix_pattern = SANE_FALSE;
1656 ad_timing = 1;
1657 bank_size = BS_16K;
1658 DBG (5, "usb_high_scan_init_asic: sensor is set to CANON600\n");
1659 break;
1660 case ST_NEC600: /* fixme */
1661 ccd_dpi = 32;
1662 select = 224;
1663 adjust = 112;
1664 pin = 18;
1665 motor = 0;
1666 fix_pattern = SANE_FALSE;
1667 ad_timing = 0;
1668 bank_size = BS_16K;
1669 DBG (5, "usb_high_scan_init_asic: sensor is set to NEC600\n");
1670 break;
1671 default:
1672 DBG (5, "usb_high_scan_init_asic: unknown sensor\n");
1673 return SANE_STATUS_INVAL;
1674 break;
1675 }
1676 RIE (usb_low_adjust_timing (dev->chip, adjust));
1677 RIE (usb_low_select_timing (dev->chip, select));
1678 RIE (usb_low_set_timing (dev->chip, ccd_dpi));
1679 RIE (usb_low_set_sram_bank (dev->chip, bank_size));
1680 RIE (usb_low_set_asic_io_pins (dev->chip, pin));
1681 RIE (usb_low_set_rgb_sel_pins (dev->chip, pin));
1682 RIE (usb_low_set_motor_signal (dev->chip, motor));
1683 RIE (usb_low_set_test_sram_mode (dev->chip, SANE_FALSE));
1684 RIE (usb_low_set_fix_pattern (dev->chip, fix_pattern));
1685 RIE (usb_low_set_ad_timing (dev->chip, ad_timing));
1686
1687 DBG (5, "usb_high_scan_init_asic: exit\n");
1688 return SANE_STATUS_GOOD;
1689 }
1690
1691 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)1692 usb_high_scan_evaluate_max_level (Mustek_Usb_Device * dev,
1693 SANE_Word sample_lines,
1694 SANE_Int sample_length,
1695 SANE_Byte * ret_max_level)
1696 {
1697 SANE_Byte max_level = 0;
1698 SANE_Word i;
1699 SANE_Int j;
1700 SANE_Status status;
1701 SANE_Word lines_left;
1702
1703 DBG (5, "usb_high_scan_evaluate_max_level: start\n");
1704
1705 sample_length -= 20;
1706 RIE (usb_low_start_rowing (dev->chip));
1707 for (i = 0; i < sample_lines; i++)
1708 {
1709 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
1710 for (j = 20; j < sample_length; j++)
1711 {
1712 if (max_level < dev->green[j])
1713 max_level = dev->green[j];
1714 }
1715 }
1716 RIE (usb_low_stop_rowing (dev->chip));
1717 if (ret_max_level)
1718 *ret_max_level = max_level;
1719 DBG (5, "usb_high_scan_evaluate_max_level: exit, max_level = %d\n",
1720 max_level);
1721 return SANE_STATUS_GOOD;
1722 }
1723
1724 /* Binary Search for Single Channel Power Delay */
1725 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)1726 usb_high_scan_bssc_power_delay (Mustek_Usb_Device * dev,
1727 Powerdelay_Function set_power_delay,
1728 Signal_State * signal_state,
1729 SANE_Byte * target, SANE_Byte max,
1730 SANE_Byte min, SANE_Byte threshold,
1731 SANE_Int length)
1732 {
1733 SANE_Byte max_level;
1734 SANE_Byte max_max = max;
1735 SANE_Byte min_min = min;
1736 SANE_Status status;
1737
1738 DBG (5, "usb_high_scan_bssc_power_delay: start\n");
1739
1740 *target = (max + min) / 2;
1741 RIE ((*set_power_delay) (dev->chip, *target));
1742 while (*target != min)
1743 {
1744 RIE (usb_high_scan_evaluate_max_level (dev, dev->init_powerdelay_lines,
1745 length, &max_level));
1746 if (max_level > threshold)
1747 {
1748 min = *target;
1749 *target = (max + min) / 2;
1750 *signal_state = SS_BRIGHTER;
1751 }
1752 else if (max_level < threshold)
1753 {
1754 max = *target;
1755 *target = (max + min) / 2;
1756 *signal_state = SS_DARKER;
1757 }
1758 else if (max_level == threshold)
1759 { /* Found. */
1760 *signal_state = SS_EQUAL;
1761 return SANE_STATUS_GOOD;
1762 }
1763 RIE ((*set_power_delay) (dev->chip, *target));
1764 }
1765 /* Fail... */
1766 if (max == max_max || min == min_min)
1767 { /* Boundary check */
1768 if (max == max_max) /*target on max side */
1769 *target = max_max;
1770 else
1771 *target = min_min;
1772 RIE ((*set_power_delay) (dev->chip, *target));
1773 RIE (usb_high_scan_evaluate_max_level (dev, dev->init_powerdelay_lines,
1774 length, &max_level));
1775
1776 if (max_level > threshold)
1777 {
1778 *signal_state = SS_BRIGHTER;
1779 }
1780 else if (max_level < threshold)
1781 {
1782 *signal_state = SS_DARKER;
1783 }
1784 else if (max_level == threshold)
1785 {
1786 *signal_state = SS_EQUAL;
1787 }
1788 }
1789 else
1790 { /* Fail... will always on mimnum side, make it darker */
1791 target++;
1792 *signal_state = SS_DARKER;
1793 }
1794 DBG (5, "usb_high_scan_bssc_power_delay: exit\n");
1795 return SANE_STATUS_GOOD;
1796 }
1797
1798 SANE_Status
usb_high_scan_adjust_rgb_600_power_delay(Mustek_Usb_Device * dev)1799 usb_high_scan_adjust_rgb_600_power_delay (Mustek_Usb_Device * dev)
1800 {
1801 SANE_Status status;
1802 SANE_Byte max_power_delay;
1803 Signal_State signal_state = SS_UNKNOWN;
1804
1805 DBG (5, "usb_high_scan_adjust_rgb_600_power_delay: start\n");
1806 max_power_delay = (SANE_Byte) (dev->expose_time / 64);
1807
1808 if (dev->is_adjusted_rgb_600_power_delay)
1809 return SANE_STATUS_GOOD;
1810 /* Setup Initial State */
1811 dev->red_rgb_600_power_delay = max_power_delay;
1812 dev->green_rgb_600_power_delay = max_power_delay;
1813 dev->blue_rgb_600_power_delay = max_power_delay;
1814
1815 RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
1816 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
1817 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
1818 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
1819 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
1820 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
1821 RIE (usb_mid_front_set_rgb_signal (dev->chip));
1822 RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_600));
1823 RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_600));
1824 RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
1825
1826 /* adjust GreenPD */
1827 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
1828 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
1829 signal_state = SS_UNKNOWN;
1830 RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_600_pga));
1831 RIE (usb_high_scan_bssc_power_delay
1832 (dev, &usb_low_set_green_pd, &signal_state,
1833 &dev->green_rgb_600_power_delay,
1834 max_power_delay, 0, dev->init_max_power_delay,
1835 dev->adjust_length_600));
1836
1837 /* adjust BluePD */
1838 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_BLUE));
1839 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
1840 signal_state = SS_UNKNOWN;
1841 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_600_pga));
1842 RIE (usb_high_scan_bssc_power_delay
1843 (dev, &usb_low_set_blue_pd, &signal_state,
1844 &dev->blue_rgb_600_power_delay,
1845 max_power_delay, 0, dev->init_max_power_delay,
1846 dev->adjust_length_600));
1847
1848 /* adjust RedPD */
1849 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_RED));
1850 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
1851 signal_state = SS_UNKNOWN;
1852 RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_600_pga));
1853 RIE (usb_high_scan_bssc_power_delay
1854 (dev, &usb_low_set_red_pd, &signal_state,
1855 &dev->red_rgb_600_power_delay, max_power_delay, 0,
1856 dev->init_max_power_delay, dev->adjust_length_600));
1857
1858 dev->is_adjusted_rgb_600_power_delay = SANE_TRUE;
1859 DBG (5, "usb_high_scan_adjust_rgb_600_power_delay: exit\n");
1860 return SANE_STATUS_GOOD;
1861 }
1862
1863 SANE_Status
usb_high_scan_adjust_mono_600_power_delay(Mustek_Usb_Device * dev)1864 usb_high_scan_adjust_mono_600_power_delay (Mustek_Usb_Device * dev)
1865 {
1866 SANE_Byte max_power_delay;
1867 Signal_State signal_state = SS_UNKNOWN;
1868 SANE_Status status;
1869
1870 DBG (5, "usb_high_scan_adjust_mono_600_power_delay: start\n");
1871 max_power_delay = (SANE_Byte) (dev->expose_time / 64);
1872 if (dev->is_adjusted_mono_600_power_delay)
1873 return SANE_STATUS_GOOD;
1874 /* Setup Initial State */
1875 dev->red_mono_600_power_delay = max_power_delay;
1876 dev->green_mono_600_power_delay = max_power_delay;
1877 dev->blue_mono_600_power_delay = max_power_delay;
1878
1879 /* Compute Gray PD */
1880 RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
1881 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
1882 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
1883 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
1884 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
1885 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
1886 RIE (usb_mid_front_set_rgb_signal (dev->chip));
1887 RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_600));
1888 RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_600));
1889 RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
1890
1891 /* adjust GreenGrayPD */
1892 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
1893 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
1894 signal_state = SS_UNKNOWN;
1895 RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_600_pga));
1896 RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_600_pga));
1897 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_600_pga));
1898 RIE (usb_high_scan_bssc_power_delay
1899 (dev, &usb_low_set_green_pd, &signal_state,
1900 &dev->green_mono_600_power_delay,
1901 max_power_delay, 0, dev->init_max_power_delay,
1902 dev->adjust_length_600));
1903
1904 dev->is_adjusted_mono_600_power_delay = SANE_TRUE;
1905 DBG (5, "usb_high_scan_adjust_mono_600_power_delay: exit\n");
1906 return SANE_STATUS_GOOD;
1907 }
1908
1909 /* CCD */
1910 SANE_Status
usb_high_scan_adjust_mono_600_exposure(Mustek_Usb_Device * dev)1911 usb_high_scan_adjust_mono_600_exposure (Mustek_Usb_Device * dev)
1912 {
1913 SANE_Word transfer_time;
1914 SANE_Status status;
1915
1916 DBG (5, "usb_high_scan_adjust_mono_600_exposure: start\n");
1917 if (dev->is_adjusted_mono_600_exposure)
1918 return SANE_STATUS_GOOD;
1919
1920 RIE (usb_high_scan_evaluate_pixel_rate (dev));
1921 transfer_time = dev->pixel_rate * dev->x_dpi / 600;
1922 if (transfer_time > 16000)
1923 transfer_time = 16000;
1924
1925 dev->mono_600_exposure =
1926 MAX (5504, MAX (transfer_time,
1927 usb_mid_motor_mono_capability (dev->chip, dev->y_dpi)));
1928 dev->mono_600_exposure = ((dev->mono_600_exposure + 63) / 64) * 64;
1929 dev->is_adjusted_mono_600_exposure = SANE_TRUE;
1930 DBG (5, "usb_high_scan_adjust_mono_600_exposure: exit\n");
1931 return SANE_STATUS_GOOD;
1932 }
1933
1934 #if 0
1935 /* CCD */
1936 SANE_Status
1937 usb_high_scan_adjust_mono_600_offset (Mustek_Usb_Device * dev)
1938 {
1939 DBG (5, "usb_high_scan_adjust_mono_600_offset: start\n");
1940 if (dev->is_adjusted_mono_600_offset)
1941 return SANE_STATUS_GOOD;
1942
1943 DBG (5, "usb_high_scan_adjust_mono_600_offset: exit\n");
1944 return SANE_STATUS_GOOD;
1945 }
1946
1947 /* CCD */
1948 SANE_Status
1949 usb_high_scan_adjust_mono_600_pga (Mustek_Usb_Device * dev)
1950 {
1951 DBG (5, "usb_high_scan_adjust_mono_600_pga: start (dev = %p)\n", dev);
1952 DBG (5, "usb_high_scan_adjust_mono_600_pga: exit\n");
1953 return SANE_STATUS_GOOD;
1954 }
1955
1956 /* CCD */
1957 SANE_Status
1958 usb_high_scan_adjust_mono_600_skips_per_row (Mustek_Usb_Device * dev)
1959 {
1960 DBG (5, "usb_high_scan_adjust_mono_600_skips_per_row: start (dev = %p)\n",
1961 dev);
1962 DBG (5, "usb_high_scan_adjust_mono_600_skips_per_row: exit\n");
1963 return SANE_STATUS_GOOD;
1964 }
1965 #endif
1966
1967 SANE_Status
usb_high_scan_adjust_rgb_300_power_delay(Mustek_Usb_Device * dev)1968 usb_high_scan_adjust_rgb_300_power_delay (Mustek_Usb_Device * dev)
1969 {
1970 /* Setup Initial State */
1971 SANE_Byte max_power_delay;
1972 Signal_State signal_state = SS_UNKNOWN;
1973 SANE_Status status;
1974
1975 DBG (5, "usb_high_scan_adjust_rgb_300_power_delay: start\n");
1976 max_power_delay = (SANE_Byte) (dev->expose_time / 64);
1977 if (dev->is_adjusted_rgb_300_power_delay)
1978 return SANE_STATUS_GOOD;
1979
1980 dev->red_rgb_300_power_delay = max_power_delay;
1981 dev->green_rgb_300_power_delay = max_power_delay;
1982 dev->blue_rgb_300_power_delay = max_power_delay;
1983
1984 RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
1985 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
1986 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
1987 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
1988 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
1989 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
1990 RIE (usb_mid_front_set_rgb_signal (dev->chip));
1991 RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_300));
1992 RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_300));
1993 RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
1994
1995 /* adjust GreenPD */
1996 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
1997 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
1998
1999 signal_state = SS_UNKNOWN;
2000 RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_300_pga));
2001 RIE (usb_high_scan_bssc_power_delay
2002 (dev, &usb_low_set_green_pd, &signal_state,
2003 &dev->green_rgb_300_power_delay,
2004 max_power_delay, 0, dev->init_max_power_delay,
2005 dev->adjust_length_300));
2006
2007 /* adjust BluePD */
2008 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_BLUE));
2009 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
2010
2011 signal_state = SS_UNKNOWN;
2012 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_300_pga));
2013 RIE (usb_high_scan_bssc_power_delay
2014 (dev, &usb_low_set_blue_pd, &signal_state,
2015 &dev->blue_rgb_300_power_delay, max_power_delay, 0,
2016 dev->init_max_power_delay, dev->adjust_length_300));
2017
2018 /* adjust RedPD */
2019 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_RED));
2020 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
2021
2022 signal_state = SS_UNKNOWN;
2023 RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_300_pga));
2024 RIE (usb_high_scan_bssc_power_delay
2025 (dev, &usb_low_set_red_pd, &signal_state,
2026 &dev->red_rgb_300_power_delay, max_power_delay, 0,
2027 dev->init_max_power_delay, dev->adjust_length_300));
2028 dev->is_adjusted_rgb_300_power_delay = SANE_TRUE;
2029 DBG (5, "usb_high_scan_adjust_rgb_300_power_delay: exit\n");
2030 return SANE_STATUS_GOOD;
2031 }
2032
2033 SANE_Status
usb_high_scan_adjust_mono_300_power_delay(Mustek_Usb_Device * dev)2034 usb_high_scan_adjust_mono_300_power_delay (Mustek_Usb_Device * dev)
2035 {
2036 SANE_Byte max_power_delay;
2037 Signal_State signal_state = SS_UNKNOWN;
2038 SANE_Status status;
2039
2040 DBG (5, "usb_high_scan_adjust_mono_300_power_delay: start\n");
2041 max_power_delay = (SANE_Byte) (dev->expose_time / 64);
2042 if (dev->is_adjusted_mono_300_power_delay)
2043 return SANE_STATUS_GOOD;
2044 /* Setup Initial State */
2045 dev->red_mono_300_power_delay = max_power_delay;
2046 dev->green_mono_300_power_delay = max_power_delay;
2047 dev->blue_mono_300_power_delay = max_power_delay;
2048
2049 /* Compute Gray PD */
2050 RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
2051 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
2052 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
2053 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
2054 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
2055 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
2056 RIE (usb_mid_front_set_rgb_signal (dev->chip));
2057 RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_300));
2058 RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_300));
2059 RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
2060
2061 /* adjust GreenGrayPD */
2062 RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
2063 RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
2064
2065 signal_state = SS_UNKNOWN;
2066 RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_300_pga));
2067 RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_300_pga));
2068 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_300_pga));
2069 RIE (usb_high_scan_bssc_power_delay
2070 (dev, &usb_low_set_green_pd, &signal_state,
2071 &dev->green_mono_300_power_delay,
2072 max_power_delay, 0, dev->init_max_power_delay,
2073 dev->adjust_length_300));
2074
2075 dev->is_adjusted_mono_300_power_delay = SANE_TRUE;
2076 DBG (5, "usb_high_scan_adjust_mono_300_power_delay: exit\n");
2077 return SANE_STATUS_GOOD;
2078 }
2079
2080 SANE_Status
usb_high_scan_evaluate_pixel_rate(Mustek_Usb_Device * dev)2081 usb_high_scan_evaluate_pixel_rate (Mustek_Usb_Device * dev)
2082 {
2083 DBG (5, "usb_high_scan_evaluate_pixel_rate: start, dev=%p\n", (void *) dev);
2084
2085 /* fixme: new for CCD */
2086 dev->pixel_rate = 2000;
2087 dev->is_evaluate_pixel_rate = SANE_TRUE;
2088 DBG (5, "usb_high_scan_evaluate_pixel_rate: exit\n");
2089 return SANE_STATUS_GOOD;
2090 }
2091
2092 SANE_Status
usb_high_scan_calibration_rgb_24(Mustek_Usb_Device * dev)2093 usb_high_scan_calibration_rgb_24 (Mustek_Usb_Device * dev)
2094 {
2095 SANE_Word white_need;
2096 SANE_Word dark_need;
2097 SANE_Word i;
2098 SANE_Status status;
2099 SANE_Word lines_left;
2100 SANE_Word minor_average;
2101
2102 DBG (5, "usb_high_scan_calibration_rgb_24: start, dev=%p\n", (void *) dev);
2103 if (dev->is_cis_detected)
2104 {
2105 RIE (usb_mid_motor_prepare_calibrate_rgb (dev->chip, dev->y_dpi));
2106 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
2107 minor_average = 2;
2108 }
2109 else
2110 {
2111 minor_average = 1;
2112 }
2113
2114 dev->red_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
2115 if (!dev->red_calibrator)
2116 return SANE_STATUS_NO_MEM;
2117
2118 RIE (usb_high_cal_init (dev->red_calibrator, I8O8RGB,
2119 dev->init_k_level << 8, 0));
2120 RIE (usb_high_cal_prepare (dev->red_calibrator, dev->width));
2121 RIE (usb_high_cal_embed_gamma (dev->red_calibrator, dev->gamma_table));
2122 RIE (usb_high_cal_setup
2123 (dev->red_calibrator, 1, minor_average, 8, dev->width, &white_need,
2124 &dark_need));
2125
2126 dev->green_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
2127 if (!dev->green_calibrator)
2128 return SANE_STATUS_NO_MEM;
2129 RIE (usb_high_cal_init (dev->green_calibrator, I8O8RGB,
2130 dev->init_k_level << 8, 0));
2131 RIE (usb_high_cal_prepare (dev->green_calibrator, dev->width));
2132 RIE (usb_high_cal_embed_gamma (dev->green_calibrator, dev->gamma_table));
2133 RIE (usb_high_cal_setup (dev->green_calibrator, 1, minor_average, 8,
2134 dev->width, &white_need, &dark_need));
2135
2136 dev->blue_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
2137 if (!dev->blue_calibrator)
2138 return SANE_STATUS_NO_MEM;
2139
2140 RIE (usb_high_cal_init (dev->blue_calibrator, I8O8RGB,
2141 dev->init_k_level << 8, 0));
2142 RIE (usb_high_cal_prepare (dev->blue_calibrator, dev->width));
2143 RIE (usb_high_cal_embed_gamma (dev->blue_calibrator, dev->gamma_table));
2144 RIE (usb_high_cal_setup (dev->blue_calibrator, 1, minor_average, 8,
2145 dev->width, &white_need, &dark_need));
2146
2147 /* K White */
2148 RIE (usb_low_start_rowing (dev->chip));
2149 for (i = 0; i < white_need; i++)
2150 {
2151 /* Read Green Channel */
2152 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2153 RIE (usb_high_cal_fill_in_white (dev->green_calibrator, i, 0,
2154 (void *) (dev->green +
2155 dev->skips_per_row)));
2156 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2157 RIE (usb_high_cal_fill_in_white (dev->green_calibrator, i, 1,
2158 (void *) (dev->green +
2159 dev->skips_per_row)));
2160 /* Read Blue Channel */
2161 RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
2162 RIE (usb_high_cal_fill_in_white (dev->blue_calibrator, i, 0,
2163 (void *) (dev->blue +
2164 dev->skips_per_row)));
2165 RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
2166 RIE (usb_high_cal_fill_in_white (dev->blue_calibrator, i, 1,
2167 (void *) (dev->blue +
2168 dev->skips_per_row)));
2169 /* Read Red Channel */
2170 RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
2171 RIE (usb_high_cal_fill_in_white (dev->red_calibrator, i, 0,
2172 (void *) (dev->red +
2173 dev->skips_per_row)));
2174 RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
2175 RIE (usb_high_cal_fill_in_white (dev->red_calibrator, i, 1,
2176 (void *) (dev->red +
2177 dev->skips_per_row)));
2178 }
2179 RIE (usb_low_stop_rowing (dev->chip));
2180 /* Calculate average */
2181 RIE (usb_high_cal_evaluate_white (dev->green_calibrator,
2182 dev->init_green_factor));
2183 RIE (usb_high_cal_evaluate_white (dev->blue_calibrator,
2184 dev->init_blue_factor));
2185 RIE (usb_high_cal_evaluate_white (dev->red_calibrator,
2186 dev->init_red_factor));
2187
2188 RIE (usb_mid_motor_prepare_calibrate_rgb (dev->chip, dev->y_dpi));
2189 RIE (usb_low_enable_motor (dev->chip, SANE_FALSE));
2190 RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
2191
2192 /* K Black */
2193 RIE (usb_low_start_rowing (dev->chip));
2194 for (i = 0; i < dark_need; i++)
2195 {
2196 /* Read Green Channel */
2197 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2198 RIE (usb_high_cal_fill_in_dark (dev->green_calibrator, i, 0,
2199 (void *) (dev->green +
2200 dev->skips_per_row)));
2201 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2202 RIE (usb_high_cal_fill_in_dark (dev->green_calibrator, i, 1,
2203 (void *) (dev->green +
2204 dev->skips_per_row)));
2205 /* Read Blue Channel */
2206 RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
2207 RIE (usb_high_cal_fill_in_dark (dev->blue_calibrator, i, 0,
2208 (void *) (dev->blue +
2209 dev->skips_per_row)));
2210 RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
2211 RIE (usb_high_cal_fill_in_dark (dev->blue_calibrator, i, 1,
2212 (void *) (dev->blue +
2213 dev->skips_per_row)));
2214 /* Read Red Channel */
2215 RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
2216 RIE (usb_high_cal_fill_in_dark (dev->red_calibrator, i, 0,
2217 (void *) (dev->red +
2218 dev->skips_per_row)));
2219 RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
2220 RIE (usb_high_cal_fill_in_dark (dev->red_calibrator, i, 1,
2221 (void *) (dev->red +
2222 dev->skips_per_row)));
2223 }
2224 RIE (usb_low_stop_rowing (dev->chip));
2225 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
2226 /* Calculate average */
2227 RIE (usb_high_cal_evaluate_dark (dev->green_calibrator,
2228 dev->init_green_black_factor));
2229 RIE (usb_high_cal_evaluate_dark (dev->blue_calibrator,
2230 dev->init_blue_black_factor));
2231 RIE (usb_high_cal_evaluate_dark (dev->red_calibrator,
2232 dev->init_red_black_factor));
2233 /* Calculate Mapping */
2234 RIE (usb_high_cal_evaluate_calibrator (dev->green_calibrator));
2235 RIE (usb_high_cal_evaluate_calibrator (dev->blue_calibrator));
2236 RIE (usb_high_cal_evaluate_calibrator (dev->red_calibrator));
2237 DBG (5, "usb_high_scan_calibration_rgb_24: exit\n");
2238 return SANE_STATUS_GOOD;
2239 }
2240
2241 SANE_Status
usb_high_scan_calibration_mono_8(Mustek_Usb_Device * dev)2242 usb_high_scan_calibration_mono_8 (Mustek_Usb_Device * dev)
2243 {
2244 SANE_Word white_need;
2245 SANE_Word dark_need;
2246 SANE_Word i;
2247 SANE_Status status;
2248 SANE_Word lines_left;
2249
2250 DBG (5, "usb_high_scan_calibration_mono_8: start\n");
2251 RIE (usb_mid_motor_prepare_calibrate_mono (dev->chip, dev->y_dpi));
2252 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
2253
2254 dev->mono_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
2255 if (!dev->mono_calibrator)
2256 return SANE_STATUS_NO_MEM;
2257
2258 RIE (usb_high_cal_init (dev->mono_calibrator, I8O8MONO,
2259 dev->init_k_level << 8, 0));
2260 RIE (usb_high_cal_prepare (dev->mono_calibrator, dev->width));
2261 RIE (usb_high_cal_embed_gamma (dev->mono_calibrator, dev->gamma_table));
2262 RIE (usb_high_cal_setup (dev->mono_calibrator, 1, 1, 8,
2263 dev->width, &white_need, &dark_need));
2264
2265 /* K White */
2266 RIE (usb_low_start_rowing (dev->chip));
2267 for (i = 0; i < white_need; i++)
2268 {
2269 /* Read Green Channel */
2270 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2271 RIE (usb_high_cal_fill_in_white (dev->mono_calibrator, i, 0,
2272 (void *) (dev->green +
2273 dev->skips_per_row)));
2274 }
2275 RIE (usb_low_stop_rowing (dev->chip));
2276 /* Calculate average */
2277 RIE (usb_high_cal_evaluate_white (dev->mono_calibrator,
2278 dev->init_gray_factor));
2279
2280 RIE (usb_mid_motor_prepare_calibrate_mono (dev->chip, dev->y_dpi));
2281 RIE (usb_low_enable_motor (dev->chip, SANE_FALSE));
2282 RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
2283
2284 /* K Black */
2285 RIE (usb_low_start_rowing (dev->chip));
2286 for (i = 0; i < dark_need; i++)
2287 {
2288 /* Read Green Channel */
2289 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2290 RIE (usb_high_cal_fill_in_dark (dev->mono_calibrator, i, 0,
2291 (void *) (dev->green +
2292 dev->skips_per_row)));
2293 }
2294 RIE (usb_low_stop_rowing (dev->chip));
2295 RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
2296 /* Calculate Green Black */
2297 RIE (usb_high_cal_evaluate_dark (dev->mono_calibrator,
2298 dev->init_gray_black_factor));
2299 /* Calculate Mapping */
2300 RIE (usb_high_cal_evaluate_calibrator (dev->mono_calibrator));
2301 DBG (5, "usb_high_scan_calibration_mono_8: exit\n");
2302 return SANE_STATUS_GOOD;
2303 }
2304
2305 SANE_Status
usb_high_scan_step_forward(Mustek_Usb_Device * dev,SANE_Int step_count)2306 usb_high_scan_step_forward (Mustek_Usb_Device * dev, SANE_Int step_count)
2307 {
2308 SANE_Status status;
2309
2310 DBG (5, "usb_high_scan_step_forward: start\n");
2311
2312 if (step_count <= 0)
2313 return SANE_STATUS_INVAL;
2314 /* Initialize */
2315 RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
2316 RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE));
2317 RIE (usb_mid_motor_prepare_step (dev->chip, (SANE_Word) step_count));
2318 /* Startup */
2319 RIE (usb_low_start_rowing (dev->chip));
2320 /* Wait for stop */
2321 /* Linux USB seems buggy on timeout... sleep before really try */
2322 /* to read the flag from scanner */
2323 usleep (step_count * 2 * 1000);
2324 RIE (usb_low_wait_rowing_stop (dev->chip));
2325 if (!dev->is_cis_detected)
2326 RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
2327
2328 DBG (5, "usb_high_scan_step_forward: start\n");
2329 return SANE_STATUS_GOOD;
2330 }
2331
2332 SANE_Status
usb_high_scan_safe_forward(Mustek_Usb_Device * dev,SANE_Int step_count)2333 usb_high_scan_safe_forward (Mustek_Usb_Device * dev, SANE_Int step_count)
2334 {
2335 SANE_Status status;
2336
2337 DBG (5, "usb_high_scan_safe_forward: start\n");
2338 if (step_count <= 0)
2339 return SANE_STATUS_INVAL;
2340 /* Initialize */
2341 RIE (usb_low_set_ccd_width (dev->chip, 5400));
2342 RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE));
2343 RIE (usb_mid_motor_prepare_step (dev->chip, (SANE_Word) step_count));
2344 /* Startup */
2345 RIE (usb_low_start_rowing (dev->chip));
2346 /* Wait to Stop */
2347 RIE (usb_low_wait_rowing_stop (dev->chip));
2348 RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
2349 DBG (5, "usb_high_scan_safe_forward: exit\n");
2350 return SANE_STATUS_GOOD;
2351 }
2352
2353 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)2354 usb_high_scan_calculate_max_rgb_600_expose (Mustek_Usb_Device * dev,
2355 SANE_Byte * ideal_red_pd,
2356 SANE_Byte * ideal_green_pd,
2357 SANE_Byte * ideal_blue_pd)
2358 {
2359 SANE_Word red_light_up;
2360 SANE_Word green_light_up;
2361 SANE_Word blue_light_up;
2362 SANE_Word max_light_up;
2363 SANE_Word ideal_expose_time;
2364
2365 DBG (5, "usb_high_scan_calculate_max_rgb_600_expose: dev=%p\n", (void *) dev);
2366
2367 red_light_up = dev->expose_time - dev->red_rgb_600_power_delay * 64;
2368 green_light_up = dev->expose_time - dev->green_rgb_600_power_delay * 64;
2369 blue_light_up = dev->expose_time - dev->blue_rgb_600_power_delay * 64;
2370 max_light_up = MAX (red_light_up, MAX (green_light_up, blue_light_up));
2371 if (dev->chip->sensor == ST_NEC600)
2372 {
2373 ideal_expose_time
2374 = MAX (MAX (5504, max_light_up),
2375 usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
2376 }
2377 else
2378 {
2379 ideal_expose_time
2380 = MAX (MAX (5376, max_light_up),
2381 usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
2382 }
2383 ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
2384 *ideal_red_pd = (SANE_Byte) ((ideal_expose_time - red_light_up) / 64);
2385 *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - green_light_up) / 64);
2386 *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time - blue_light_up) / 64);
2387 DBG (5, "usb_high_scan_calculate_max_rgb_600_expose: exit\n");
2388 return ideal_expose_time;
2389 }
2390
2391 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)2392 usb_high_scan_calculate_max_mono_600_expose (Mustek_Usb_Device * dev,
2393 SANE_Byte * ideal_red_pd,
2394 SANE_Byte * ideal_green_pd,
2395 SANE_Byte * ideal_blue_pd)
2396 {
2397 SANE_Word max_light_up;
2398 SANE_Word ideal_expose_time;
2399 SANE_Word transfer_time;
2400
2401 DBG (5, "usb_high_scan_calculate_max_mono_600_expose: dev=%p\n", (void *) dev);
2402
2403 max_light_up = dev->expose_time - dev->green_mono_600_power_delay * 64;
2404 transfer_time = (SANE_Word) ((SANE_Word) (dev->pixel_rate)
2405 * (SANE_Word) (dev->x_dpi) / 600);
2406 /* base on 600, but double it. */
2407
2408 if (transfer_time > 16000)
2409 transfer_time = 16000;
2410 if (dev->chip->sensor == ST_NEC600)
2411 {
2412 ideal_expose_time
2413 = MAX (MAX (5504, max_light_up),
2414 MAX (transfer_time, usb_mid_motor_mono_capability
2415 (dev->chip, dev->y_dpi)));
2416 }
2417 else
2418 {
2419 ideal_expose_time
2420 = MAX (MAX (5376, max_light_up),
2421 MAX (transfer_time, usb_mid_motor_mono_capability
2422 (dev->chip, dev->y_dpi)));
2423 }
2424 ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
2425 *ideal_red_pd = (SANE_Byte) ((ideal_expose_time) / 64);
2426 *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - max_light_up) / 64);
2427 *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time) / 64);
2428 DBG (5, "usb_high_scan_calculate_max_mono_600_expose: exit\n");
2429 return ideal_expose_time;
2430 }
2431
2432 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)2433 usb_high_scan_calculate_max_rgb_300_expose (Mustek_Usb_Device * dev,
2434 SANE_Byte * ideal_red_pd,
2435 SANE_Byte * ideal_green_pd,
2436 SANE_Byte * ideal_blue_pd)
2437 {
2438 SANE_Word red_light_up;
2439 SANE_Word green_light_up;
2440 SANE_Word blue_light_up;
2441 SANE_Word max_light_up;
2442 SANE_Word ideal_expose_time;
2443
2444 DBG (5, "usb_high_scan_calculate_max_rgb_300_expose: start\n");
2445 red_light_up = dev->expose_time - dev->red_rgb_300_power_delay * 64;
2446 green_light_up = dev->expose_time - dev->green_rgb_300_power_delay * 64;
2447 blue_light_up = dev->expose_time - dev->blue_rgb_300_power_delay * 64;
2448 max_light_up = MAX (red_light_up, MAX (green_light_up, blue_light_up));
2449
2450 if (dev->chip->sensor == ST_CANON300600)
2451 {
2452 ideal_expose_time =
2453 MAX (MAX (2624, max_light_up),
2454 usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
2455 }
2456 else if (dev->chip->sensor == ST_CANON300)
2457 {
2458 ideal_expose_time = MAX (MAX (2624, max_light_up), /* fixme? */
2459 usb_mid_motor_rgb_capability (dev->chip,
2460 dev->y_dpi));
2461 }
2462 else
2463 {
2464 ideal_expose_time =
2465 MAX (MAX (5376, max_light_up),
2466 usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
2467 }
2468
2469 ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
2470 *ideal_red_pd = (SANE_Byte) ((ideal_expose_time - red_light_up) / 64);
2471 *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - green_light_up) / 64);
2472 *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time - blue_light_up) / 64);
2473 DBG (5, "usb_high_scan_calculate_max_rgb_300_expose: exit\n");
2474 return ideal_expose_time;
2475 }
2476
2477 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)2478 usb_high_scan_calculate_max_mono_300_expose (Mustek_Usb_Device * dev,
2479 SANE_Byte * ideal_red_pd,
2480 SANE_Byte * ideal_green_pd,
2481 SANE_Byte * ideal_blue_pd)
2482 {
2483 SANE_Word max_light_up;
2484 SANE_Word transfer_time;
2485 SANE_Word ideal_expose_time;
2486
2487 DBG (5, "usb_high_scan_calculate_max_mono_300_expose: start\n");
2488 max_light_up = dev->expose_time - dev->green_mono_300_power_delay * 64;
2489 transfer_time =
2490 (SANE_Word) ((SANE_Word) (dev->pixel_rate) *
2491 (SANE_Word) (dev->x_dpi) / 600);
2492 /* base on 600, but double it. */
2493
2494 if (transfer_time > 16000)
2495 transfer_time = 16000;
2496 if (dev->chip->sensor == ST_CANON300600)
2497 {
2498 ideal_expose_time =
2499 MAX (MAX (2688, max_light_up),
2500 MAX (transfer_time,
2501 usb_mid_motor_mono_capability (dev->chip, dev->y_dpi)));
2502 }
2503 else if (dev->chip->sensor == ST_CANON300)
2504 {
2505 ideal_expose_time = MAX (MAX (2688, max_light_up), /* fixme? */
2506 MAX (transfer_time,
2507 usb_mid_motor_mono_capability (dev->chip,
2508 dev->
2509 y_dpi)));
2510 }
2511 else
2512 {
2513 ideal_expose_time =
2514 MAX (MAX (5376, max_light_up),
2515 MAX (transfer_time,
2516 usb_mid_motor_mono_capability (dev->chip, dev->y_dpi)));
2517 }
2518
2519 ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
2520 *ideal_red_pd = (SANE_Byte) ((ideal_expose_time) / 64);
2521 *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - max_light_up) / 64);
2522 *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time) / 64);
2523 DBG (5, "usb_high_scan_calculate_max_mono_300_expose: exit\n");
2524 return ideal_expose_time;
2525 }
2526
2527 SANE_Status
usb_high_scan_prepare_rgb_signal_600_dpi(Mustek_Usb_Device * dev)2528 usb_high_scan_prepare_rgb_signal_600_dpi (Mustek_Usb_Device * dev)
2529 {
2530 SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
2531 SANE_Word ideal_expose_time;
2532 SANE_Status status;
2533
2534 DBG (5, "usb_high_scan_prepare_rgb_signal_600_dpi: start\n");
2535 ideal_expose_time = usb_high_scan_calculate_max_rgb_600_expose
2536 (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
2537
2538 RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
2539 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
2540 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
2541 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
2542 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
2543 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
2544 RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_600_pga));
2545 RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_600_pga));
2546 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_600_pga));
2547 RIE (usb_mid_front_set_rgb_signal (dev->chip));
2548 RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
2549 RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
2550 RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
2551 DBG (5, "usb_high_scan_prepare_rgb_signal_600_dpi: exit\n");
2552 return SANE_STATUS_GOOD;
2553 }
2554
2555 SANE_Status
usb_high_scan_prepare_mono_signal_600_dpi(Mustek_Usb_Device * dev)2556 usb_high_scan_prepare_mono_signal_600_dpi (Mustek_Usb_Device * dev)
2557 {
2558 SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
2559 SANE_Word ideal_expose_time;
2560 SANE_Status status;
2561
2562 DBG (5, "usb_high_scan_prepare_mono_signal_600_dpi: start\n");
2563 ideal_expose_time = usb_high_scan_calculate_max_mono_600_expose
2564 (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
2565
2566 RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
2567 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
2568 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
2569 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
2570 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
2571 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
2572 RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_600_pga));
2573 RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_600_pga));
2574 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_600_pga));
2575 RIE (usb_mid_front_set_rgb_signal (dev->chip));
2576 RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
2577 RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
2578 RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
2579 DBG (5, "usb_high_scan_prepare_mono_signal_600_dpi: exit\n");
2580 return SANE_STATUS_GOOD;
2581 }
2582
2583 SANE_Status
usb_high_scan_prepare_rgb_signal_300_dpi(Mustek_Usb_Device * dev)2584 usb_high_scan_prepare_rgb_signal_300_dpi (Mustek_Usb_Device * dev)
2585 {
2586 SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
2587 SANE_Word ideal_expose_time;
2588 SANE_Status status;
2589
2590 DBG (5, "usb_high_scan_prepare_rgb_signal_300_dpi: start\n");
2591
2592 ideal_expose_time = usb_high_scan_calculate_max_rgb_300_expose
2593 (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
2594
2595 RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
2596 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
2597 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
2598 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
2599 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
2600 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
2601 RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_300_pga));
2602 RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_300_pga));
2603 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_300_pga));
2604 RIE (usb_mid_front_set_rgb_signal (dev->chip));
2605 RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
2606 RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
2607 RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
2608 DBG (5, "usb_high_scan_prepare_rgb_signal_300_dpi: exit\n");
2609 return SANE_STATUS_GOOD;
2610 }
2611
2612 SANE_Status
usb_high_scan_prepare_mono_signal_300_dpi(Mustek_Usb_Device * dev)2613 usb_high_scan_prepare_mono_signal_300_dpi (Mustek_Usb_Device * dev)
2614 {
2615 /* Setup Scan Here */
2616 SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
2617 SANE_Word ideal_expose_time;
2618 SANE_Status status;
2619
2620 DBG (5, "usb_high_scan_prepare_mono_signal_300_dpi: start\n");
2621 ideal_expose_time = usb_high_scan_calculate_max_mono_300_expose
2622 (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
2623
2624 RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
2625 RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
2626 RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
2627 RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
2628 RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
2629 RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
2630 RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_300_pga));
2631 RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_300_pga));
2632 RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_300_pga));
2633 RIE (usb_mid_front_set_rgb_signal (dev->chip));
2634 RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
2635 RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
2636 RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
2637 DBG (5, "usb_high_scan_prepare_mono_signal_300_dpi: exit\n");
2638 return SANE_STATUS_GOOD;
2639 }
2640
2641 SANE_Status
usb_high_scan_prepare_rgb_24(Mustek_Usb_Device * dev)2642 usb_high_scan_prepare_rgb_24 (Mustek_Usb_Device * dev)
2643 {
2644 SANE_Status status;
2645
2646 DBG (5, "usb_high_scan_prepare_rgb_24: start\n");
2647 RIE (usb_low_set_image_byte_width (dev->chip, dev->bytes_per_strip));
2648 RIE (usb_low_set_dummy (dev->chip, dev->dummy));
2649 RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
2650 DBG (5, "usb_high_scan_prepare_rgb_24: exit\n");
2651 return SANE_STATUS_GOOD;
2652 }
2653
2654 SANE_Status
usb_high_scan_prepare_mono_8(Mustek_Usb_Device * dev)2655 usb_high_scan_prepare_mono_8 (Mustek_Usb_Device * dev)
2656 {
2657 SANE_Status status;
2658
2659 DBG (5, "usb_high_scan_prepare_mono_8: start\n");
2660 RIE (usb_low_set_image_byte_width (dev->chip, dev->bytes_per_strip));
2661 RIE (usb_low_set_dummy (dev->chip, dev->dummy));
2662 RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
2663 DBG (5, "usb_high_scan_prepare_mono_8: exit\n");
2664 return SANE_STATUS_GOOD;
2665 }
2666
2667 SANE_Status
usb_high_scan_get_rgb_24_bit_line(Mustek_Usb_Device * dev,SANE_Byte * line,SANE_Bool is_order_invert)2668 usb_high_scan_get_rgb_24_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line,
2669 SANE_Bool is_order_invert)
2670 {
2671 SANE_Status status;
2672 SANE_Word lines_left;
2673
2674 DBG (5, "usb_high_scan_get_rgb_24_bit_line: start, dev=%p, line=%p, "
2675 "is_order_invert=%d\n", (void *) dev, (void *) line, is_order_invert);
2676
2677 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2678
2679 RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
2680
2681 RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
2682 RIE (usb_high_cal_calibrate (dev->green_calibrator,
2683 dev->green + dev->skips_per_row, line + 1));
2684 RIE (usb_high_cal_calibrate (dev->blue_calibrator,
2685 dev->blue + dev->skips_per_row,
2686 line + ((is_order_invert) ? 0 : 2)));
2687 RIE (usb_high_cal_calibrate (dev->red_calibrator,
2688 dev->red + dev->skips_per_row,
2689 line + ((is_order_invert) ? 2 : 0)));
2690
2691 DBG (5, "usb_high_scan_get_rgb_24_bit_line: exit\n");
2692 return SANE_STATUS_GOOD;
2693 }
2694
2695
2696 SANE_Status
usb_high_scan_get_mono_8_bit_line(Mustek_Usb_Device * dev,SANE_Byte * line,SANE_Bool is_order_invert)2697 usb_high_scan_get_mono_8_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line,
2698 SANE_Bool is_order_invert)
2699 {
2700 SANE_Status status;
2701 SANE_Word lines_left;
2702
2703 DBG (5, "usb_high_scan_get_mono_8_bit_line: start, dev=%p, line=%p, "
2704 "is_order_invert=%d\n", (void *) dev, (void *) line, is_order_invert);
2705
2706 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2707 RIE (usb_high_cal_calibrate (dev->mono_calibrator, dev->green +
2708 dev->skips_per_row, line));
2709 DBG (5, "usb_high_scan_get_mono_8_bit_line: exit\n");
2710 return SANE_STATUS_GOOD;
2711 }
2712
2713 SANE_Status
usb_high_scan_backtrack_rgb_24(Mustek_Usb_Device * dev)2714 usb_high_scan_backtrack_rgb_24 (Mustek_Usb_Device * dev)
2715 {
2716 DBG (5, "usb_high_scan_backtrack_rgb_24: noop, dev=%p\n", (void *) dev);
2717 return SANE_STATUS_GOOD;
2718 }
2719
2720 SANE_Status
usb_high_scan_backtrack_mono_8(Mustek_Usb_Device * dev)2721 usb_high_scan_backtrack_mono_8 (Mustek_Usb_Device * dev)
2722 {
2723 SANE_Int i;
2724 SANE_Status status;
2725 SANE_Word lines_left;
2726
2727 DBG (5, "usb_high_scan_backtrack_mono_8: start, dev=%p\n", (void *) dev);
2728
2729 if (dev->y_dpi >= 300)
2730 {
2731 RIE (usb_low_stop_rowing (dev->chip));
2732 RIE (usb_low_set_motor_direction (dev->chip, SANE_TRUE));
2733 RIE (usb_low_start_rowing (dev->chip));
2734 for (i = 0; i < dev->init_mono_8_back_track; i++)
2735 {
2736 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2737 }
2738 usleep (100 * 1000);
2739 RIE (usb_low_stop_rowing (dev->chip));
2740 RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE));
2741 RIE (usb_low_start_rowing (dev->chip));
2742 for (i = 0; i < dev->init_mono_8_back_track; i++)
2743 {
2744 RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
2745 }
2746 }
2747 DBG (5, "usb_high_scan_backtrack_mono_8: exit\n");
2748 return SANE_STATUS_GOOD;
2749 }
2750