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 52static SANE_Byte gray_map[8] = { 53 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 54}; 55 56static inline double 57filter_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 83SANE_Status 84usb_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 115SANE_Status 116usb_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 152SANE_Status 153usb_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 161SANE_Status 162usb_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 197SANE_Status 198usb_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 277SANE_Status 278usb_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 322SANE_Status 323usb_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 343SANE_Status 344usb_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 */ 382SANE_Status 383usb_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 403SANE_Status 404usb_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 422SANE_Status 423usb_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 442SANE_Status 443usb_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 472SANE_Status 473usb_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 500SANE_Status 501usb_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 536SANE_Status 537usb_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 569SANE_Status 570usb_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 616SANE_Status 617usb_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 664SANE_Status 665usb_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 721SANE_Status 722usb_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 849SANE_Status 850usb_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 867SANE_Status 868usb_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 893SANE_Status 894usb_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 916SANE_Status 917usb_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 954SANE_Status 955usb_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 974SANE_Status 975usb_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 985SANE_Status 986usb_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 1001SANE_Status 1002usb_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 1032SANE_Status 1033usb_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 1060SANE_Status 1061usb_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 1170SANE_Status 1171usb_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 1205SANE_Status 1206usb_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 1245SANE_Status 1246usb_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 1286SANE_Status 1287usb_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 1425SANE_Status 1426usb_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 1523SANE_Status 1524usb_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 1550SANE_Status 1551usb_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 1600SANE_Status 1601usb_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 1691SANE_Status 1692usb_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 */ 1725SANE_Status 1726usb_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 1798SANE_Status 1799usb_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 1863SANE_Status 1864usb_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 */ 1910SANE_Status 1911usb_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 */ 1936SANE_Status 1937usb_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 */ 1948SANE_Status 1949usb_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 */ 1957SANE_Status 1958usb_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 1967SANE_Status 1968usb_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 2033SANE_Status 2034usb_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 2080SANE_Status 2081usb_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 2092SANE_Status 2093usb_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 2241SANE_Status 2242usb_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 2305SANE_Status 2306usb_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 2332SANE_Status 2333usb_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 2353SANE_Word 2354usb_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 2391SANE_Word 2392usb_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 2432SANE_Word 2433usb_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 2477SANE_Word 2478usb_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 2527SANE_Status 2528usb_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 2555SANE_Status 2556usb_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 2583SANE_Status 2584usb_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 2612SANE_Status 2613usb_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 2641SANE_Status 2642usb_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 2654SANE_Status 2655usb_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 2667SANE_Status 2668usb_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 2696SANE_Status 2697usb_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 2713SANE_Status 2714usb_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 2720SANE_Status 2721usb_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