1/* sane - Scanner Access Now Easy. 2 Copyright (C) 2002 Michael Herder <crapsite@gmx.net> 3 4++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 6This backend is based on the "gt68xxtest" program written by the following 7persons: 8 Sergey Vlasov <vsu@mivlgu.murom.ru> 9 - Main backend code. 10 11 Andreas Nowack <nowack.andreas@gmx.de> 12 - Support for GT6801 (Mustek ScanExpress 1200 UB Plus). 13 14 David Stevenson <david.stevenson@zoom.co.uk> 15 - Automatic AFE gain and offset setting. 16++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 17Please note: 18The calibration code from the gt68xxtest program isn't used here, since I 19couldn't get it working. I'm using my own calibration code, which is based 20on wild assumptions based on the USB logs from the windoze driver. 21++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 22It also contains code from the plustek backend 23 24Copyright (C) 2000-2002 Gerhard Jaeger <g.jaeger@earthling.net> 25 26and from the mustek_usb backend 27 28Copyright (C) 2000 Mustek. 29Maintained by Tom Wang <tom.wang@mustek.com.tw> 30Updates (C) 2001 by Henning Meier-Geinitz. 31++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 32++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 33 34 This program is free software; you can redistribute it and/or 35 modify it under the terms of the GNU General Public License as 36 published by the Free Software Foundation; either version 2 of the 37 License, or (at your option) any later version. 38 39 This program is distributed in the hope that it will be useful, but 40 WITHOUT ANY WARRANTY; without even the implied warranty of 41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 42 General Public License for more details. 43 44 You should have received a copy of the GNU General Public License 45 along with this program. If not, see <https://www.gnu.org/licenses/>. 46 47 As a special exception, the authors of SANE give permission for 48 additional uses of the libraries contained in this release of SANE. 49 50 The exception is that, if you link a SANE library with other files 51 to produce an executable, this does not by itself cause the 52 resulting executable to be covered by the GNU General Public 53 License. Your use of that executable is in no way restricted on 54 account of linking the SANE library code into it. 55 56 This exception does not, however, invalidate any other reasons why 57 the executable file might be covered by the GNU General Public 58 License. 59 60 If you submit changes to SANE to the maintainers to be included in 61 a subsequent release, you agree by submitting the changes that 62 those changes may be distributed with this exception intact. 63 64 If you write modifications of your own for SANE, it is your choice 65 whether to permit this exception to apply to your modifications. 66 If you do not wish that, delete this exception notice. */ 67 68#define BUILD 12 69 70#include "../include/sane/config.h" 71 72#include <errno.h> 73#include <fcntl.h> 74#include <limits.h> 75#include <signal.h> 76#include <stdlib.h> 77#include <string.h> 78#include <ctype.h> 79#include <unistd.h> 80#include <time.h> 81#include <math.h> 82 83#include <sys/time.h> 84#include <sys/stat.h> 85#include <sys/types.h> 86#include <sys/ioctl.h> 87 88 89#include "../include/sane/sane.h" 90#include "../include/sane/sanei.h" 91#include "../include/sane/saneopts.h" 92 93#define BACKEND_NAME artec_eplus48u 94#include "../include/sane/sanei_backend.h" 95#include "../include/sane/sanei_config.h" 96 97#include "artec_eplus48u.h" 98 99#ifndef PATH_MAX 100# define PATH_MAX 1024 101#endif 102 103#define _DEFAULT_DEVICE "/dev/usbscanner" 104#define ARTEC48U_CONFIG_FILE "artec_eplus48u.conf" 105 106#define _SHADING_FILE_BLACK "artec48ushading_black" 107#define _SHADING_FILE_WHITE "artec48ushading_white" 108#define _EXPOSURE_FILE "artec48uexposure" 109#define _OFFSET_FILE "artec48uoffset" 110 111#define _BYTE 3 112#define _STRING 2 113#define _FLOAT 1 114#define _INT 0 115 116/*for calibration*/ 117#define WHITE_MIN 243*257 118#define WHITE_MAX 253*257 119#define BLACK_MIN 8*257 120#define BLACK_MAX 18*257 121#define EXPOSURE_STEP 280 122 123static Artec48U_Device *first_dev = 0; 124static Artec48U_Scanner *first_handle = 0; 125static SANE_Int num_devices = 0; 126static char devName[PATH_MAX]; 127static char firmwarePath[PATH_MAX]; 128static char vendor_string[PATH_MAX]; 129static char model_string[PATH_MAX]; 130 131static SANE_Bool cancelRead; 132static int isEPro; 133static int eProMult; 134static SANE_Auth_Callback auth = NULL; 135static double gamma_master_default = 1.7; 136static double gamma_r_default = 1.0; 137static double gamma_g_default = 1.0; 138static double gamma_b_default = 1.0; 139 140static SANE_Word memory_read_value = 0x200c; /**< Memory read - wValue */ 141static SANE_Word memory_write_value = 0x200b; /**< Memory write - wValue */ 142static SANE_Word send_cmd_value = 0x2010; /**< Send normal command - wValue */ 143static SANE_Word send_cmd_index = 0x3f40; /**< Send normal command - wIndex */ 144static SANE_Word recv_res_value = 0x2011; /**< Receive normal result - wValue */ 145static SANE_Word recv_res_index = 0x3f00; /**< Receive normal result - wIndex */ 146static SANE_Word send_small_cmd_value = 0x2012; /**< Send small command - wValue */ 147static SANE_Word send_small_cmd_index = 0x3f40; /**< Send small command - wIndex */ 148static SANE_Word recv_small_res_value = 0x2013; /**< Receive small result - wValue */ 149static SANE_Word recv_small_res_index = 0x3f00; /**< Receive small result - wIndex */ 150 151static SANE_String_Const mode_list[] = { 152 SANE_VALUE_SCAN_MODE_LINEART, 153 SANE_VALUE_SCAN_MODE_GRAY, 154 SANE_VALUE_SCAN_MODE_COLOR, 155 NULL 156}; 157 158static SANE_Word resbit_list[] = { 159 6, 160 50, 100, 200, 300, 600, 1200 161}; 162 163static SANE_Range brightness_contrast_range = { 164 -127, 165 127, 166 0 167}; 168 169static SANE_Range blacklevel_range = { 170 20, 171 240, 172 1 173}; 174 175static SANE_Range gamma_range = { 176 0, /* minimum */ 177 SANE_FIX (4.0), /* maximum */ 178 0 /* quantization */ 179}; 180 181static SANE_Range scan_range_x = { 182 0, /* minimum */ 183 SANE_FIX (216.0), /* maximum */ 184 0 /* quantization */ 185}; 186 187static SANE_Range scan_range_y = { 188 0, /* minimum */ 189 SANE_FIX (297.0), /* maximum */ 190 0 /* quantization */ 191}; 192 193 194static SANE_Word bitdepth_list[] = { 195 2, 8, 16 196}; 197 198static SANE_Word bitdepth_list2[] = { 199 1, 8 200}; 201 202static Artec48U_Exposure_Parameters exp_params; 203static Artec48U_Exposure_Parameters default_exp_params = 204 { 0x009f, 0x0109, 0x00cb }; 205static Artec48U_AFE_Parameters afe_params; 206static Artec48U_AFE_Parameters default_afe_params = 207 { 0x28, 0x0a, 0x2e, 0x03, 0x2e, 0x03 }; 208 209static SANE_Status 210download_firmware_file (Artec48U_Device * chip) 211{ 212 SANE_Status status = SANE_STATUS_GOOD; 213 SANE_Byte *buf = NULL; 214 int size = -1; 215 FILE *f; 216 217 XDBG ((2, "Try to open firmware file: \"%s\"\n", chip->firmware_path)); 218 f = fopen (chip->firmware_path, "rb"); 219 if (!f) 220 { 221 XDBG ((2, "Cannot open firmware file \"%s\"\n", firmwarePath)); 222 status = SANE_STATUS_INVAL; 223 } 224 225 if (status == SANE_STATUS_GOOD) 226 { 227 fseek (f, 0, SEEK_END); 228 size = ftell (f); 229 fseek (f, 0, SEEK_SET); 230 if (size == -1) 231 { 232 XDBG ((2, "Error getting size of firmware file \"%s\"\n", 233 chip->firmware_path)); 234 status = SANE_STATUS_INVAL; 235 } 236 } 237 238 if (status == SANE_STATUS_GOOD) 239 { 240 XDBG ((3, "firmware size: %d\n", size)); 241 buf = (SANE_Byte *) malloc (size); 242 if (!buf) 243 { 244 XDBG ((2, "Cannot allocate %d bytes for firmware\n", size)); 245 status = SANE_STATUS_NO_MEM; 246 } 247 } 248 249 if (status == SANE_STATUS_GOOD) 250 { 251 int bytes_read = fread (buf, 1, size, f); 252 if (bytes_read != size) 253 { 254 XDBG ((2, "Problem reading firmware file \"%s\"\n", 255 chip->firmware_path)); 256 status = SANE_STATUS_INVAL; 257 } 258 } 259 260 if (f) 261 fclose (f); 262 263 if (status == SANE_STATUS_GOOD) 264 { 265 status = artec48u_download_firmware (chip, buf, size); 266 if (status != SANE_STATUS_GOOD) 267 { 268 XDBG ((2, "Firmware download failed\n")); 269 } 270 } 271 272 if (buf) 273 free (buf); 274 return status; 275} 276 277static SANE_Status 278init_calibrator (Artec48U_Scanner * s) 279{ 280 XDBG ((2, "Init calibrator size %d\n",30720 * s->dev->epro_mult)); 281 s->shading_buffer_w = (unsigned char *) malloc (30720 * s->dev->epro_mult); /*epro*/ 282 s->shading_buffer_b = (unsigned char *) malloc (30720 * s->dev->epro_mult); /*epro*/ 283 s->shading_buffer_white[0] = 284 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof(unsigned int));/*epro*/ 285 s->shading_buffer_black[0] = 286 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/ 287 s->shading_buffer_white[1] = 288 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/ 289 s->shading_buffer_black[1] = 290 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/ 291 s->shading_buffer_white[2] = 292 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/ 293 s->shading_buffer_black[2] = 294 (unsigned int *) malloc (5120 * s->dev->epro_mult * sizeof (unsigned int));/*epro*/ 295 296 if (!s->shading_buffer_w || !s->shading_buffer_b 297 || !s->shading_buffer_white[0] || !s->shading_buffer_black[0] 298 || !s->shading_buffer_white[1] || !s->shading_buffer_black[1] 299 || !s->shading_buffer_white[2] || !s->shading_buffer_black[2]) 300 { 301 if (s->shading_buffer_w) 302 free (s->shading_buffer_w); 303 if (s->shading_buffer_b) 304 free (s->shading_buffer_b); 305 if (s->shading_buffer_white[0]) 306 free (s->shading_buffer_white[0]); 307 if (s->shading_buffer_black[0]) 308 free (s->shading_buffer_black[0]); 309 if (s->shading_buffer_white[1]) 310 free (s->shading_buffer_white[1]); 311 if (s->shading_buffer_black[1]) 312 free (s->shading_buffer_black[1]); 313 if (s->shading_buffer_white[2]) 314 free (s->shading_buffer_white[2]); 315 if (s->shading_buffer_black[2]) 316 free (s->shading_buffer_black[2]); 317 return SANE_STATUS_NO_MEM; 318 } 319 return SANE_STATUS_GOOD; 320} 321 322static void 323init_shading_buffer (Artec48U_Scanner * s) 324{ 325 unsigned int i, j; 326 327 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/ 328 { 329 for (j = 0; j < 3; j++) 330 { 331 s->temp_shading_buffer[j][i] = 0; 332 } 333 } 334} 335 336static void 337add_to_shading_buffer (Artec48U_Scanner * s, unsigned int **buffer_pointers) 338{ 339 unsigned int i, j; 340 341 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/ 342 { 343 for (j = 0; j < 3; j++) 344 { 345 s->temp_shading_buffer[j][i] += buffer_pointers[j][i]; 346 } 347 } 348} 349 350static void 351finish_shading_buffer (Artec48U_Scanner * s, SANE_Bool white) 352{ 353 unsigned int i, j, cnt, c, div; 354 unsigned char *shading_buffer; 355 cnt = 0; 356 357 if (white) 358 { 359 shading_buffer = s->shading_buffer_w; 360 div = s->dev->shading_lines_w; 361 } 362 else 363 { 364 shading_buffer = s->shading_buffer_b; 365 div = s->dev->shading_lines_b; 366 } 367 368 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/ 369 { 370 for (j = 0; j < 3; j++) 371 { 372 int value = s->temp_shading_buffer[j][i] / (div); 373 shading_buffer[cnt] = (SANE_Byte) (value & 0xff); 374 ++cnt; 375 shading_buffer[cnt] = (SANE_Byte) ((value >> 8) & 0xff); 376 ++cnt; 377 } 378 } 379 380 for (c = 0; c < (30720 * s->dev->epro_mult) - 5; c += 6) /*epro*/ 381 { 382 i = (int) shading_buffer[c] + ((int) shading_buffer[c + 1] << 8); 383 i = (int) shading_buffer[c + 2] + ((int) shading_buffer[c + 3] << 8); 384 i = (int) shading_buffer[c + 4] + ((int) shading_buffer[c + 5] << 8); 385 } 386} 387 388static void 389finish_exposure_buffer (Artec48U_Scanner * s, int *avg_r, int *avg_g, 390 int *avg_b) 391{ 392 unsigned int i, j, cnt, c, div; 393 unsigned int max_r; 394 unsigned int max_g; 395 unsigned int max_b; 396 unsigned char *shading_buffer; 397 cnt = 0; 398 399 shading_buffer = s->shading_buffer_w; 400 div = s->dev->shading_lines_w; 401 402 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/ 403 { 404 for (j = 0; j < 3; j++) 405 { 406 int value = s->temp_shading_buffer[j][i] / (div); 407 shading_buffer[cnt] = (SANE_Byte) (value & 0xff); 408 ++cnt; 409 shading_buffer[cnt] = (SANE_Byte) ((value >> 8) & 0xff); 410 ++cnt; 411 } 412 } 413 max_r = 0; 414 max_g = 0; 415 max_b = 0; 416 for (c = 0; c < (30720 * s->dev->epro_mult) - 5; c += 6) /*epro*/ 417 { 418 i = (int) shading_buffer[c] + ((int) shading_buffer[c + 1] << 8); 419 if (i > max_r) 420 max_r = i; 421 i = (int) shading_buffer[c + 2] + ((int) shading_buffer[c + 3] << 8); 422 if (i > max_g) 423 max_g = i; 424 i = (int) shading_buffer[c + 4] + ((int) shading_buffer[c + 5] << 8); 425 if (i > max_b) 426 max_b = i; 427 } 428 *avg_r = max_r; 429 *avg_g = max_g; 430 *avg_b = max_b; 431} 432 433static void 434finish_offset_buffer (Artec48U_Scanner * s, int *avg_r, int *avg_g, 435 int *avg_b) 436{ 437 unsigned int i, j, cnt, c, div; 438 unsigned int min_r; 439 unsigned int min_g; 440 unsigned int min_b; 441 unsigned char *shading_buffer; 442 cnt = 0; 443 444 shading_buffer = s->shading_buffer_b; 445 div = s->dev->shading_lines_b; 446 447 for (i = 0; i < 5120 * s->dev->epro_mult; i++) /*epro*/ 448 { 449 for (j = 0; j < 3; j++) 450 { 451 int value = s->temp_shading_buffer[j][i] / (div); 452 shading_buffer[cnt] = (SANE_Byte) (value & 0xff); 453 ++cnt; 454 shading_buffer[cnt] = (SANE_Byte) ((value >> 8) & 0xff); 455 ++cnt; 456 } 457 } 458 min_r = 65535; 459 min_g = 65535; 460 min_b = 65535; 461 for (c = 0; c < (30720 * s->dev->epro_mult) - 5; c += 6) /*epro*/ 462 { 463 i = (int) shading_buffer[c] + ((int) shading_buffer[c + 1] << 8); 464 if (i < min_r) 465 min_r = i; 466 i = (int) shading_buffer[c + 2] + ((int) shading_buffer[c + 3] << 8); 467 if (i < min_g) 468 min_g = i; 469 i = (int) shading_buffer[c + 4] + ((int) shading_buffer[c + 5] << 8); 470 if (i < min_b) 471 min_b = i; 472 } 473 *avg_r = min_r; 474 *avg_g = min_g; 475 *avg_b = min_b; 476} 477 478static SANE_Status 479artec48u_wait_for_positioning (Artec48U_Device * chip) 480{ 481 SANE_Status status; 482 SANE_Bool moving; 483 484 while (SANE_TRUE) 485 { 486 status = artec48u_is_moving (chip, &moving); 487 if (status != SANE_STATUS_GOOD) 488 return status; 489 if (!moving) 490 break; 491 usleep (100000); 492 } 493 494 return SANE_STATUS_GOOD; 495} 496 497static void 498copy_scan_line (Artec48U_Scanner * s) 499{ 500 /*For resolution of 1200 dpi we have to interpolate 501 horizontally, because the optical horizontal resolution is 502 limited to 600 dpi. We simply use the average value of two pixels. */ 503 int cnt, i, j; 504 int xs = s->params.pixel_xs; 505 int interpolate = 0; 506 int value; 507 int value1; 508 int value2; 509 if ((s->reader->params.ydpi == 1200) && (s->dev->is_epro == 0)) /*epro*/ 510 interpolate = 1; 511 cnt = 0; 512 if (s->params.color) 513 { 514 if (s->params.depth > 8) 515 { 516 for (i = xs - 1; i >= 0; i--) 517 { 518 for (j = 0; j < 3; j++) 519 { 520 value = s->buffer_pointers[j][i]; 521 s->line_buffer[cnt] = LOBYTE (value); 522 ++cnt; 523 s->line_buffer[cnt] = HIBYTE (value); 524 ++cnt; 525 } 526 if (interpolate == 1) /*1200 dpi */ 527 cnt += 6; 528 } 529 if (interpolate == 1) 530 { 531 for (i = 0; i < (xs * 12) - 12; i += 12) 532 { 533 value1 = (int) s->line_buffer[i]; 534 value1 += (int) (s->line_buffer[i + 1] << 8); 535 value2 = (int) s->line_buffer[i + 12]; 536 value2 += (int) (s->line_buffer[i + 13] << 8); 537 value = (value1 + value2) / 2; 538 if (value < 0) 539 value = 0; 540 if (value > 65535) 541 value = 65535; 542 s->line_buffer[i + 6] = LOBYTE (value); 543 s->line_buffer[i + 7] = HIBYTE (value); 544 545 value1 = (int) s->line_buffer[i + 2]; 546 value1 += (int) (s->line_buffer[i + 3] << 8); 547 value2 = (int) s->line_buffer[i + 14]; 548 value2 += (int) (s->line_buffer[i + 15] << 8); 549 value = (value1 + value2) / 2; 550 if (value < 0) 551 value = 0; 552 if (value > 65535) 553 value = 65535; 554 s->line_buffer[i + 8] = LOBYTE (value); 555 s->line_buffer[i + 9] = HIBYTE (value); 556 557 value1 = (int) s->line_buffer[i + 4]; 558 value1 += (int) (s->line_buffer[i + 5] << 8); 559 value2 = (int) s->line_buffer[i + 16]; 560 value2 += (int) (s->line_buffer[i + 17] << 8); 561 value = (value1 + value2) / 2; 562 if (value < 0) 563 value = 0; 564 if (value > 65535) 565 value = 65535; 566 s->line_buffer[i + 10] = LOBYTE (value); 567 s->line_buffer[i + 11] = HIBYTE (value); 568 } 569 } 570 } 571 else 572 { 573 for (i = xs - 1; i >= 0; i--) 574 { 575 for (j = 0; j < 3; j++) 576 { 577 value = s->buffer_pointers[j][i]; 578 s->line_buffer[cnt] = (SANE_Byte) (value / 257); 579 cnt += 1; 580 } 581 if (interpolate == 1) /*1200 dpi */ 582 cnt += 3; 583 } 584 if (interpolate == 1) 585 { 586 for (i = 0; i < (xs * 6) - 6; i += 6) 587 { 588 value1 = (int) s->line_buffer[i]; 589 value2 = (int) s->line_buffer[i + 6]; 590 value = (value1 + value2) / 2; 591 if (value < 0) 592 value = 0; 593 if (value > 255) 594 value = 255; 595 s->line_buffer[i + 3] = (SANE_Byte) (value); 596 597 value1 = (int) s->line_buffer[i + 1]; 598 value2 = (int) s->line_buffer[i + 7]; 599 value = (value1 + value2) / 2; 600 if (value < 0) 601 value = 0; 602 if (value > 255) 603 value = 255; 604 s->line_buffer[i + 4] = (SANE_Byte) (value); 605 606 value1 = (int) s->line_buffer[i + 2]; 607 value2 = (int) s->line_buffer[i + 8]; 608 value = (value1 + value2) / 2; 609 if (value < 0) 610 value = 0; 611 if (value > 255) 612 value = 255; 613 s->line_buffer[i + 5] = (SANE_Byte) (value); 614 } 615 } 616 } 617 } 618 else 619 { 620 if (s->params.depth > 8) 621 { 622 for (i = xs - 1; i >= 0; --i) 623 { 624 value = s->buffer_pointers[0][i]; 625 s->line_buffer[cnt] = LOBYTE (value); 626 ++cnt; 627 s->line_buffer[cnt] = HIBYTE (value); 628 ++cnt; 629 if (interpolate == 1) /*1200 dpi */ 630 cnt += 2; 631 } 632 if (interpolate == 1) 633 { 634 for (i = 0; i < (xs * 4) - 4; i += 4) 635 { 636 value1 = (int) s->line_buffer[i]; 637 value1 += (int) (s->line_buffer[i + 1] << 8); 638 value2 = (int) s->line_buffer[i + 4]; 639 value2 += (int) (s->line_buffer[i + 5] << 8); 640 value = (value1 + value2) / 2; 641 if (value < 0) 642 value = 0; 643 if (value > 65535) 644 value = 65535; 645 s->line_buffer[i + 2] = LOBYTE (value); 646 s->line_buffer[i + 3] = HIBYTE (value); 647 } 648 } 649 } 650 else 651 { 652 if (s->params.lineart == SANE_FALSE) 653 { 654 for (i = xs - 1; i >= 0; --i) 655 { 656 value = s->buffer_pointers[0][i]; 657 s->line_buffer[cnt] = (SANE_Byte) (value / 257); 658 ++cnt; 659 if (interpolate == 1) /*1200 dpi */ 660 ++cnt; 661 } 662 if (interpolate == 1) 663 { 664 for (i = 0; i < (xs * 2) - 2; i += 2) 665 { 666 value1 = (int) s->line_buffer[i]; 667 value2 = (int) s->line_buffer[i + 2]; 668 value = (value1 + value2) / 2; 669 if (value < 0) 670 value = 0; 671 if (value > 255) 672 value = 255; 673 s->line_buffer[i + 1] = (SANE_Byte) (value); 674 } 675 } 676 } 677 else 678 { 679 int cnt2; 680 int bit_cnt = 0; 681 int black_level = s->val[OPT_BLACK_LEVEL].w; 682 /*copy to lineart_buffer */ 683 for (i = xs - 1; i >= 0; --i) 684 { 685 s->lineart_buffer[cnt] = 686 (SANE_Byte) (s->buffer_pointers[0][i] / 257); 687 ++cnt; 688 if (interpolate == 1) /*1200 dpi */ 689 ++cnt; 690 } 691 cnt2 = cnt - 1; 692 cnt = 0; 693 if (interpolate == 1) 694 { 695 for (i = 0; i < cnt2 - 2; i += 2) 696 { 697 value1 = (int) s->lineart_buffer[i]; 698 value2 = (int) s->lineart_buffer[i + 2]; 699 value = (value1 + value2) / 2; 700 if (value < 0) 701 value = 0; 702 if (value > 255) 703 value = 255; 704 s->lineart_buffer[i + 1] = (SANE_Byte) (value); 705 } 706 } 707 /* in this case, every value in buffer_pointers represents a bit */ 708 for (i = 0; i < cnt2; i++) 709 { 710 SANE_Byte temp; 711 if (bit_cnt == 0) 712 s->line_buffer[cnt] = 0; /*clear */ 713 temp = s->lineart_buffer[i]; 714 if (temp <= black_level) 715 s->line_buffer[cnt] |= 1 << (7 - bit_cnt); 716 ++bit_cnt; 717 if (bit_cnt > 7) 718 { 719 bit_cnt = 0; 720 ++cnt; 721 } 722 } 723 724 } 725 } 726 } 727} 728 729/*............................................................................. 730 * attach a device to the backend 731 */ 732static SANE_Status 733attach (const char *dev_name, Artec48U_Device ** devp) 734{ 735 SANE_Status status; 736 Artec48U_Device *dev; 737 738 XDBG ((1, "attach (%s, %p)\n", dev_name, (void *) devp)); 739 740 if (!dev_name) 741 { 742 XDBG ((1, "attach: devname == NULL\n")); 743 return SANE_STATUS_INVAL; 744 } 745 /* already attached ? */ 746 for (dev = first_dev; dev; dev = dev->next) 747 { 748 if (0 == strcmp (dev->name, dev_name)) 749 { 750 if (devp) 751 *devp = dev; 752 XDBG ((3, "attach: device %s already attached\n", dev_name)); 753 return SANE_STATUS_GOOD; 754 } 755 } 756 XDBG ((3, "attach: device %s NOT attached\n", dev_name)); 757 /* allocate some memory for the device */ 758 artec48u_device_new (&dev); 759 if (NULL == dev) 760 return SANE_STATUS_NO_MEM; 761 762 dev->fd = -1; 763 dev->name = strdup (dev_name); 764 dev->sane.name = strdup (dev_name); 765/* 766 * go ahead and open the scanner device 767 */ 768 status = artec48u_device_open (dev); 769 if (status != SANE_STATUS_GOOD) 770 { 771 XDBG ((3, "Could not open device!!\n")); 772 artec48u_device_free (dev); 773 return status; 774 } 775 /*limit the size of vendor and model string to 40 */ 776 vendor_string[40] = 0; 777 model_string[40] = 0; 778 779 /* assign all the stuff we need for this device... */ 780 dev->sane.vendor = strdup (vendor_string); 781 XDBG ((3, "attach: setting vendor string: %s\n", vendor_string)); 782 dev->sane.model = strdup (model_string); 783 XDBG ((3, "attach: setting model string: %s\n", model_string)); 784 dev->sane.type = "flatbed scanner"; 785 dev->firmware_path = strdup (firmwarePath); 786 787 dev->epro_mult = eProMult; 788 dev->is_epro = isEPro; 789 XDBG ((1, "attach eProMult %d\n", eProMult)); 790 XDBG ((1, "attach isEPro %d\n", isEPro)); 791 dev->optical_xdpi = 600 * dev->epro_mult; /*epro*/ 792 dev->optical_ydpi = 1200 * dev->epro_mult; /*epro*/ 793 dev->base_ydpi = 600 * dev->epro_mult; /*epro*/ 794 dev->xdpi_offset = 0; /* in optical_xdpi units */ 795 dev->ydpi_offset = 280 * dev->epro_mult; /* in optical_ydpi units */ 796 dev->x_size = 5120 * dev->epro_mult; /*epro*/ /* in optical_xdpi units */ 797 dev->y_size = 14100 * dev->epro_mult; /*epro*/ /* in optical_ydpi units */ 798 dev->shading_offset = 10 * dev->epro_mult; 799 dev->shading_lines_b = 70 * dev->epro_mult; 800 dev->shading_lines_w = 70 * dev->epro_mult; 801 802 dev->gamma_master = gamma_master_default; 803 dev->gamma_r = gamma_r_default; 804 dev->gamma_g = gamma_g_default; 805 dev->gamma_b = gamma_b_default; 806 807 dev->afe_params.r_offset = afe_params.r_offset; 808 dev->afe_params.g_offset = afe_params.g_offset; 809 dev->afe_params.b_offset = afe_params.b_offset; 810 811 dev->afe_params.r_pga = default_afe_params.r_pga; 812 dev->afe_params.g_pga = default_afe_params.g_pga; 813 dev->afe_params.b_pga = default_afe_params.b_pga; 814 815 dev->exp_params.r_time = exp_params.r_time; 816 dev->exp_params.g_time = exp_params.g_time; 817 dev->exp_params.b_time = exp_params.b_time; 818 819 820 ++num_devices; 821 dev->next = first_dev; 822 first_dev = dev; 823 824 if (devp) 825 *devp = first_dev; 826 status = artec48u_device_close (dev); 827 return SANE_STATUS_GOOD; 828} 829 830static SANE_Status 831attach_one_device (SANE_String_Const devname) 832{ 833 Artec48U_Device *dev; 834 SANE_Status status; 835 836 status = attach (devname, &dev); 837 if (SANE_STATUS_GOOD != status) 838 return status; 839 return SANE_STATUS_GOOD; 840} 841 842/** 843 * function to decode an value and give it back to the caller. 844 * @param src - pointer to the source string to check 845 * @param opt - string that keeps the option name to check src for 846 * @param what - _FLOAT or _INT 847 * @param result - pointer to the var that should receive our result 848 * @param def - default value that result should be in case of any error 849 * @return The function returns SANE_TRUE if the option has been found, 850 * if not, it returns SANE_FALSE 851 */ 852static SANE_Bool 853decodeVal (char *src, char *opt, int what, void *result, void *def) 854{ 855 char *tmp, *tmp2; 856 const char *name; 857 858/* skip the option string */ 859 name = (const char *) &src[strlen ("option")]; 860 861/* get the name of the option */ 862 name = sanei_config_get_string (name, &tmp); 863 864 if (tmp) 865 { 866 /* on success, compare with the given one */ 867 if (0 == strcmp (tmp, opt)) 868 { 869 XDBG ((1, "Decoding option >%s<\n", opt)); 870 if (_INT == what) 871 { 872 /* assign the default value for this option... */ 873 *((int *) result) = *((int *) def); 874 if (*name) 875 { 876 /* get the configuration value and decode it */ 877 name = sanei_config_get_string (name, &tmp2); 878 if (tmp2) 879 { 880 *((int *) result) = strtol (tmp2, 0, 0); 881 free (tmp2); 882 } 883 } 884 free (tmp); 885 return SANE_TRUE; 886 } 887 else if (_FLOAT == what) 888 { 889 /* assign the default value for this option... */ 890 *((double *) result) = *((double *) def); 891 if (*name) 892 { 893 /* get the configuration value and decode it */ 894 name = sanei_config_get_string (name, &tmp2); 895 if (tmp2) 896 { 897 *((double *) result) = strtod (tmp2, 0); 898 free (tmp2); 899 } 900 } 901 free (tmp); 902 return SANE_TRUE; 903 } 904 else if (_BYTE == what) 905 { 906 /* assign the default value for this option... */ 907 *((SANE_Byte *) result) = *((SANE_Byte *) def); 908 if (*name) 909 { 910 /* get the configuration value and decode it */ 911 name = sanei_config_get_string (name, &tmp2); 912 if (tmp2) 913 { 914 *((SANE_Byte *) result) = 915 (SANE_Byte) strtol (tmp2, 0, 0); 916 free (tmp2); 917 } 918 } 919 free (tmp); 920 return SANE_TRUE; 921 } 922 else if (_STRING == what) 923 { 924 if (*name) 925 { 926 /* get the configuration value and decode it */ 927 sanei_config_get_string (name, &tmp2); 928 if (tmp2) 929 { 930 strcpy ((char *) result, (char *) tmp2); 931 free (tmp2); 932 } 933 } 934 free (tmp); 935 return SANE_TRUE; 936 } 937 } 938 free (tmp); 939 } 940 return SANE_FALSE; 941} 942 943/** 944 * function to retrieve the device name of a given string 945 * @param src - string that keeps the option name to check src for 946 * @param dest - pointer to the string, that should receive the detected 947 * devicename 948 * @return The function returns SANE_TRUE if the devicename has been found, 949 * if not, it returns SANE_FALSE 950 */ 951static SANE_Bool 952decodeDevName (char *src, char *dest) 953{ 954 char *tmp; 955 const char *name; 956 957 if (0 == strncmp ("device", src, 6)) 958 { 959 name = (const char *) &src[strlen ("device")]; 960 name = sanei_config_skip_whitespace (name); 961 962 XDBG ((1, "Decoding device name >%s<\n", name)); 963 964 if (*name) 965 { 966 name = sanei_config_get_string (name, &tmp); 967 if (tmp) 968 { 969 strcpy (dest, tmp); 970 free (tmp); 971 return SANE_TRUE; 972 } 973 } 974 } 975 return SANE_FALSE; 976} 977 978#ifdef ARTEC48U_USE_BUTTONS 979static SANE_Status 980artec48u_check_buttons (Artec48U_Device * dev, SANE_Int * value) 981{ 982 SANE_Status status; 983 Artec48U_Packet req; 984 985 memset (req, 0, sizeof (req)); 986 req[0] = 0x74; 987 req[1] = 0x01; 988 989 status = artec48u_device_small_req (dev, req, req); 990 if (status != SANE_STATUS_GOOD) 991 return status; 992 993 *value = (SANE_Int) req[2]; 994 return SANE_STATUS_GOOD; 995} 996#endif 997 998#define MAX_DOWNLOAD_BLOCK_SIZE 64 999static SANE_Status 1000artec48u_generic_start_scan (Artec48U_Device * dev) 1001{ 1002 Artec48U_Packet req; 1003 1004 memset (req, 0, sizeof (req)); 1005 req[0] = 0x43; 1006 req[1] = 0x01; 1007 1008 return artec48u_device_req (dev, req, req); 1009 1010} 1011 1012static SANE_Status 1013artec48u_generic_read_scanned_data (Artec48U_Device * dev, SANE_Bool * ready) 1014{ 1015 SANE_Status status; 1016 Artec48U_Packet req; 1017 1018 memset (req, 0, sizeof (req)); 1019 req[0] = 0x35; 1020 req[1] = 0x01; 1021 1022 status = artec48u_device_req (dev, req, req); 1023 if (status != SANE_STATUS_GOOD) 1024 return status; 1025 1026 if (req[1] == 0x35) 1027 { 1028 if (req[0] == 0) 1029 *ready = SANE_TRUE; 1030 else 1031 *ready = SANE_FALSE; 1032 } 1033 else 1034 return SANE_STATUS_IO_ERROR; 1035 1036 return SANE_STATUS_GOOD; 1037} 1038 1039static SANE_Status 1040artec48u_download_firmware (Artec48U_Device * dev, 1041 SANE_Byte * data, SANE_Word size) 1042{ 1043 SANE_Status status; 1044 SANE_Byte download_buf[MAX_DOWNLOAD_BLOCK_SIZE]; 1045 SANE_Byte check_buf[MAX_DOWNLOAD_BLOCK_SIZE]; 1046 SANE_Byte *block; 1047 SANE_Word addr, bytes_left; 1048 Artec48U_Packet boot_req; 1049 SANE_Word block_size = MAX_DOWNLOAD_BLOCK_SIZE; 1050 1051 CHECK_DEV_ACTIVE ((Artec48U_Device *) dev, 1052 (char *) "artec48u_device_download_firmware"); 1053 1054 for (addr = 0; addr < size; addr += block_size) 1055 { 1056 bytes_left = size - addr; 1057 if (bytes_left > block_size) 1058 block = data + addr; 1059 else 1060 { 1061 memset (download_buf, 0, block_size); 1062 memcpy (download_buf, data + addr, bytes_left); 1063 block = download_buf; 1064 } 1065 status = artec48u_device_memory_write (dev, addr, block_size, block); 1066 if (status != SANE_STATUS_GOOD) 1067 return status; 1068 status = artec48u_device_memory_read (dev, addr, block_size, check_buf); 1069 if (status != SANE_STATUS_GOOD) 1070 return status; 1071 if (memcmp (block, check_buf, block_size) != 0) 1072 { 1073 XDBG ((3, 1074 "artec48u_device_download_firmware: mismatch at block 0x%0x\n", 1075 addr)); 1076 return SANE_STATUS_IO_ERROR; 1077 } 1078 } 1079 1080 memset (boot_req, 0, sizeof (boot_req)); 1081 boot_req[0] = 0x69; 1082 boot_req[1] = 0x01; 1083 boot_req[2] = LOBYTE (addr); 1084 boot_req[3] = HIBYTE (addr); 1085 status = artec48u_device_req (dev, boot_req, boot_req); 1086 if (status != SANE_STATUS_GOOD) 1087 return status; 1088 return SANE_STATUS_GOOD; 1089} 1090 1091static SANE_Status 1092artec48u_is_moving (Artec48U_Device * dev, SANE_Bool * moving) 1093{ 1094 SANE_Status status; 1095 Artec48U_Packet req; 1096 memset (req, 0, sizeof (req)); 1097 req[0] = 0x17; 1098 req[1] = 0x01; 1099 1100 status = artec48u_device_req (dev, req, req); 1101 if (status != SANE_STATUS_GOOD) 1102 return status; 1103 1104 if (req[0] == 0x00 && req[1] == 0x17) 1105 { 1106 if (req[2] == 0 && (req[3] == 0 || req[3] == 2)) 1107 *moving = SANE_FALSE; 1108 else 1109 *moving = SANE_TRUE; 1110 } 1111 else 1112 return SANE_STATUS_IO_ERROR; 1113 return SANE_STATUS_GOOD; 1114} 1115 1116static SANE_Status 1117artec48u_carriage_home (Artec48U_Device * dev) 1118{ 1119 Artec48U_Packet req; 1120 1121 memset (req, 0, sizeof (req)); 1122 req[0] = 0x24; 1123 req[1] = 0x01; 1124 1125 return artec48u_device_req (dev, req, req); 1126} 1127 1128 1129static SANE_Status 1130artec48u_stop_scan (Artec48U_Device * dev) 1131{ 1132 Artec48U_Packet req; 1133 1134 memset (req, 0, sizeof (req)); 1135 req[0] = 0x41; 1136 req[1] = 0x01; 1137 return artec48u_device_small_req (dev, req, req); 1138} 1139 1140 1141static SANE_Status 1142artec48u_setup_scan (Artec48U_Scanner * s, 1143 Artec48U_Scan_Request * request, 1144 Artec48U_Scan_Action action, 1145 SANE_Bool calculate_only, 1146 Artec48U_Scan_Parameters * params) 1147{ 1148 DECLARE_FUNCTION_NAME ("artec48u_setup_scan") SANE_Status status; 1149 SANE_Int xdpi, ydpi; 1150 SANE_Bool color; 1151 SANE_Int depth; 1152 SANE_Int pixel_x0, pixel_y0, pixel_xs, pixel_ys; 1153 SANE_Int pixel_align; 1154 1155 SANE_Int abs_x0, abs_y0, abs_xs, abs_ys, base_xdpi, base_ydpi; 1156 SANE_Int scan_xs, scan_ys, scan_bpl; 1157 SANE_Int bits_per_line; 1158 SANE_Byte color_mode_code; 1159 1160 /*If we scan a black line, we use these exposure values */ 1161 Artec48U_Exposure_Parameters exp_params_black = { 4, 4, 4 }; 1162 1163 XDBG ((6, "%s: enter\n", function_name)); 1164 XDBG ((1,"setup scan is_epro %d\n",s->dev->is_epro)); 1165 XDBG ((1,"setup scan epro_mult %d\n",s->dev->epro_mult)); 1166 1167 xdpi = request->xdpi; 1168 ydpi = request->ydpi; 1169 color = request->color; 1170 depth = request->depth; 1171 1172 switch (action) 1173 { 1174 case SA_CALIBRATE_SCAN_WHITE: 1175 { 1176 /*move a bit inside scan mark - 1177 the value for the offset was found by trial and error */ 1178 pixel_y0 = s->dev->shading_offset; 1179 pixel_ys = s->dev->shading_lines_w; 1180 pixel_x0 = 0; 1181 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/ 1182 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/ 1183 color = SANE_TRUE; 1184 depth = 8; 1185 break; 1186 } 1187 case SA_CALIBRATE_SCAN_OFFSET_1: 1188 case SA_CALIBRATE_SCAN_OFFSET_2: 1189 { 1190 pixel_y0 = s->dev->shading_offset; 1191 pixel_ys = s->dev->shading_lines_b; 1192 pixel_x0 = 0; 1193 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/ 1194 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/ 1195 color = SANE_TRUE; 1196 depth = 8; 1197 break; 1198 } 1199 case SA_CALIBRATE_SCAN_EXPOSURE_1: 1200 case SA_CALIBRATE_SCAN_EXPOSURE_2: 1201 { 1202 pixel_y0 = s->dev->shading_offset; 1203 pixel_ys = s->dev->shading_lines_w; 1204 pixel_x0 = 0; 1205 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/ 1206 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/ 1207 color = SANE_TRUE; 1208 depth = 8; 1209 break; 1210 } 1211 case SA_CALIBRATE_SCAN_BLACK: 1212 { 1213 pixel_y0 = s->dev->shading_offset; 1214 pixel_ys = s->dev->shading_lines_w; 1215 pixel_x0 = 0; 1216 pixel_xs = 5120 * s->dev->epro_mult; /*epro*/ 1217 xdpi = ydpi = 600 * s->dev->epro_mult; /*epro*/ 1218 color = SANE_TRUE; 1219 depth = 8; 1220 break; 1221 } 1222 case SA_SCAN: 1223 { 1224 SANE_Fixed x0 = request->x0 + s->dev->xdpi_offset; 1225 SANE_Fixed y0; 1226 /*epro*/ 1227 if ((ydpi == 1200) && (s->dev->is_epro == 0)) 1228 xdpi = 600; 1229 y0 = request->y0 + s->dev->ydpi_offset; 1230 pixel_ys = SANE_UNFIX (request->ys) * ydpi / MM_PER_INCH + 0.5; 1231 pixel_x0 = SANE_UNFIX (x0) * xdpi / MM_PER_INCH + 0.5; 1232 pixel_y0 = SANE_UNFIX (y0) * ydpi / MM_PER_INCH + 0.5; 1233 pixel_xs = SANE_UNFIX (request->xs) * xdpi / MM_PER_INCH + 0.5; 1234 break; 1235 } 1236 1237 default: 1238 XDBG ((6, "%s: invalid action=%d\n", function_name, (int) action)); 1239 return SANE_STATUS_INVAL; 1240 } 1241 1242 XDBG ((6, "%s: xdpi=%d, ydpi=%d\n", function_name, xdpi, ydpi)); 1243 XDBG ((6, "%s: color=%s, depth=%d\n", function_name, 1244 color ? "TRUE" : "FALSE", depth)); 1245 XDBG ((6, "%s: pixel_x0=%d, pixel_y0=%d\n", function_name, 1246 pixel_x0, pixel_y0)); 1247 XDBG ((6, "%s: pixel_xs=%d, pixel_ys=%d\n", function_name, 1248 pixel_xs, pixel_ys)); 1249 1250 switch (depth) 1251 { 1252 case 8: 1253 color_mode_code = color ? 0x84 : 0x82; 1254 break; 1255 1256 case 16: 1257 color_mode_code = color ? 0xa4 : 0xa2; 1258 break; 1259 1260 default: 1261 XDBG ((6, "%s: unsupported depth=%d\n", function_name, depth)); 1262 return SANE_STATUS_UNSUPPORTED; 1263 } 1264 1265 base_xdpi = s->dev->optical_xdpi; 1266 base_ydpi = s->dev->base_ydpi; 1267 1268 XDBG ((6, "%s: base_xdpi=%d, base_ydpi=%d\n", function_name, 1269 base_xdpi, base_ydpi)); 1270 1271 abs_x0 = pixel_x0 * base_xdpi / xdpi; 1272 abs_y0 = pixel_y0 * base_ydpi / ydpi; 1273 1274 /* Calculate minimum number of pixels which span an integral multiple of 64 1275 * bytes. */ 1276 pixel_align = 32; /* best case for depth = 16 */ 1277 while ((depth * pixel_align) % (64 * 8) != 0) 1278 pixel_align *= 2; 1279 XDBG ((6, "%s: pixel_align=%d\n", function_name, pixel_align)); 1280 1281 if (pixel_xs % pixel_align == 0) 1282 scan_xs = pixel_xs; 1283 else 1284 scan_xs = (pixel_xs / pixel_align + 1) * pixel_align; 1285 scan_ys = pixel_ys; 1286 XDBG ((6, "%s: scan_xs=%d, scan_ys=%d\n", function_name, scan_xs, scan_ys)); 1287 1288 abs_xs = scan_xs * base_xdpi / xdpi; 1289 abs_ys = scan_ys * base_ydpi / ydpi; 1290 XDBG ((6, "%s: abs_xs=%d, abs_ys=%d\n", function_name, abs_xs, abs_ys)); 1291 1292 bits_per_line = depth * scan_xs; 1293 if (bits_per_line % 8) /* impossible */ 1294 { 1295 XDBG ((1, "%s: BUG: unaligned bits_per_line=%d\n", function_name, 1296 bits_per_line)); 1297 return SANE_STATUS_INVAL; 1298 } 1299 scan_bpl = bits_per_line / 8; 1300 1301 if (scan_bpl % 64) /* impossible */ 1302 { 1303 XDBG ((1, "%s: BUG: unaligned scan_bpl=%d\n", function_name, scan_bpl)); 1304 return SANE_STATUS_INVAL; 1305 } 1306 1307 if (scan_bpl > 15600) 1308 { 1309 XDBG ((6, "%s: scan_bpl=%d, too large\n", function_name, scan_bpl)); 1310 return SANE_STATUS_INVAL; 1311 } 1312 1313 XDBG ((6, "%s: scan_bpl=%d\n", function_name, scan_bpl)); 1314 1315 if (!calculate_only) 1316 { 1317 Artec48U_Packet req; 1318 char motor_mode_1, motor_mode_2; 1319 switch (action) 1320 { 1321 case SA_CALIBRATE_SCAN_WHITE: 1322 motor_mode_1 = 0x01; 1323 motor_mode_2 = 0x00; 1324 break; 1325 1326 case SA_CALIBRATE_SCAN_BLACK: 1327 motor_mode_1 = 0x04; 1328 motor_mode_2 = 0x00; 1329 break; 1330 1331 case SA_SCAN: 1332 motor_mode_1 = 0x01; 1333 motor_mode_2 = 0x00; 1334 break; 1335 1336 default: 1337 XDBG ((6, "%s: invalid action=%d\n", function_name, (int) action)); 1338 return SANE_STATUS_INVAL; 1339 } 1340 1341 /* Fill in the setup command */ 1342 memset (req, 0, sizeof (req)); 1343 req[0x00] = 0x20; 1344 req[0x01] = 0x01; 1345 req[0x02] = LOBYTE (abs_y0); 1346 req[0x03] = HIBYTE (abs_y0); 1347 req[0x04] = LOBYTE (abs_ys); 1348 req[0x05] = HIBYTE (abs_ys); 1349 req[0x06] = LOBYTE (abs_x0); 1350 req[0x07] = HIBYTE (abs_x0); 1351 req[0x08] = LOBYTE (abs_xs); 1352 req[0x09] = HIBYTE (abs_xs); 1353 req[0x0a] = color_mode_code; 1354 req[0x0b] = 0x60; 1355 req[0x0c] = LOBYTE (xdpi); 1356 req[0x0d] = HIBYTE (xdpi); 1357 req[0x0e] = 0x12; 1358 req[0x0f] = 0x00; 1359 req[0x10] = LOBYTE (scan_bpl); 1360 req[0x11] = HIBYTE (scan_bpl); 1361 req[0x12] = LOBYTE (scan_ys); 1362 req[0x13] = HIBYTE (scan_ys); 1363 req[0x14] = motor_mode_1; 1364 req[0x15] = motor_mode_2; 1365 req[0x16] = LOBYTE (ydpi); 1366 req[0x17] = HIBYTE (ydpi); 1367 req[0x18] = 0x00; 1368 1369 status = artec48u_device_req (s->dev, req, req); 1370 if (status != SANE_STATUS_GOOD) 1371 { 1372 XDBG ((3, "%s: setup request failed: %s\n", function_name, 1373 sane_strstatus (status))); 1374 return status; 1375 } 1376 1377 if (action == SA_SCAN) 1378 { 1379 artec48u_calculate_shading_buffer (s, pixel_x0, pixel_xs + pixel_x0, 1380 xdpi, color); 1381 artec48u_generic_set_exposure_time (s->dev, 1382 &(s->dev-> 1383 artec_48u_exposure_params)); 1384 artec48u_generic_set_afe (s->dev, &(s->dev->artec_48u_afe_params)); 1385 } 1386 else if (action == SA_CALIBRATE_SCAN_BLACK) 1387 { 1388 artec48u_generic_set_exposure_time (s->dev, &exp_params_black); 1389 artec48u_generic_set_afe (s->dev, &(s->dev->afe_params)); 1390 } 1391 else if (action == SA_CALIBRATE_SCAN_WHITE) 1392 { 1393 artec48u_generic_set_exposure_time (s->dev, &(s->dev->exp_params)); 1394 artec48u_generic_set_afe (s->dev, &(s->dev->afe_params)); 1395 } 1396 } 1397 /* Fill in calculated values */ 1398 params->xdpi = xdpi; 1399 params->ydpi = ydpi; 1400 params->depth = depth; 1401 params->color = color; 1402 params->pixel_xs = pixel_xs; 1403 params->pixel_ys = pixel_ys; 1404 params->scan_xs = scan_xs; 1405 params->scan_ys = scan_ys; 1406 params->scan_bpl = scan_bpl; 1407 1408 XDBG ((6, "%s: leave: ok\n", function_name)); 1409 return SANE_STATUS_GOOD; 1410} 1411 1412static SANE_Status 1413artec48u_generic_set_afe (Artec48U_Device * dev, 1414 Artec48U_AFE_Parameters * params) 1415{ 1416 Artec48U_Packet req; 1417 memset (req, 0, sizeof (req)); 1418 req[0] = 0x22; 1419 req[1] = 0x01; 1420 req[2] = params->r_offset; 1421 req[3] = params->r_pga; 1422 req[4] = params->g_offset; 1423 req[5] = params->g_pga; 1424 req[6] = params->b_offset; 1425 req[7] = params->b_pga; 1426 1427 return artec48u_device_req (dev, req, req); 1428} 1429 1430 1431static SANE_Status 1432artec48u_generic_set_exposure_time (Artec48U_Device * dev, 1433 Artec48U_Exposure_Parameters * params) 1434{ 1435 Artec48U_Packet req; 1436 memset (req, 0, sizeof (req)); 1437 req[0] = 0x76; 1438 req[1] = 0x01; 1439 req[2] = req[6] = req[10] = 0x04; 1440 req[4] = LOBYTE (params->r_time); 1441 req[5] = HIBYTE (params->r_time); 1442 req[8] = LOBYTE (params->g_time); 1443 req[9] = HIBYTE (params->g_time); 1444 req[12] = LOBYTE (params->b_time); 1445 req[13] = HIBYTE (params->b_time); 1446 return artec48u_device_req (dev, req, req); 1447} 1448 1449static SANE_Status 1450artec48u_device_new (Artec48U_Device ** dev_return) 1451{ 1452 DECLARE_FUNCTION_NAME ("artec48u_device_new") Artec48U_Device *dev; 1453 1454 XDBG ((7, "%s: enter\n", function_name)); 1455 if (!dev_return) 1456 return SANE_STATUS_INVAL; 1457 1458 dev = (Artec48U_Device *) malloc (sizeof (Artec48U_Device)); 1459 1460 if (!dev) 1461 { 1462 XDBG ((3, "%s: couldn't malloc %lu bytes for device\n", 1463 function_name, (u_long) sizeof (Artec48U_Device))); 1464 *dev_return = 0; 1465 return SANE_STATUS_NO_MEM; 1466 } 1467 *dev_return = dev; 1468 1469 memset (dev, 0, sizeof (Artec48U_Device)); 1470 1471 dev->fd = -1; 1472 dev->active = SANE_FALSE; 1473 1474 dev->read_buffer = NULL; 1475 dev->requested_buffer_size = 32768; 1476 1477 XDBG ((7, "%s: leave: ok\n", function_name)); 1478 return SANE_STATUS_GOOD; 1479} 1480 1481static SANE_Status 1482artec48u_device_free (Artec48U_Device * dev) 1483{ 1484 DECLARE_FUNCTION_NAME ("artec48u_device_free") 1485 XDBG ((7, "%s: enter: dev=%p\n", function_name, (void *) dev)); 1486 if (dev) 1487 { 1488 if (dev->active) 1489 artec48u_device_deactivate (dev); 1490 1491 if (dev->fd != -1) 1492 artec48u_device_close (dev); 1493 1494 XDBG ((7, "%s: freeing dev\n", function_name)); 1495 free (dev); 1496 } 1497 XDBG ((7, "%s: leave: ok\n", function_name)); 1498 return SANE_STATUS_GOOD; 1499} 1500 1501static SANE_Status 1502artec48u_device_open (Artec48U_Device * dev) 1503{ 1504 DECLARE_FUNCTION_NAME ("artec48u_device_open") 1505 SANE_Status status; 1506 SANE_Int fd; 1507 1508 XDBG ((7, "%s: enter: dev=%p\n", function_name, (void *) dev)); 1509 1510 CHECK_DEV_NOT_NULL (dev, function_name); 1511 1512 if (dev->fd != -1) 1513 { 1514 XDBG ((3, "%s: device already open\n", function_name)); 1515 return SANE_STATUS_INVAL; 1516 } 1517 1518 status = sanei_usb_open (dev->sane.name, &fd); 1519 if (status != SANE_STATUS_GOOD) 1520 { 1521 XDBG ((3, "%s: sanei_usb_open failed: %s\n", 1522 function_name, sane_strstatus (status))); 1523 return status; 1524 } 1525 1526 dev->fd = fd; 1527 1528 XDBG ((7, "%s: leave: ok\n", function_name)); 1529 return SANE_STATUS_GOOD; 1530} 1531 1532static SANE_Status 1533artec48u_device_close (Artec48U_Device * dev) 1534{ 1535 DECLARE_FUNCTION_NAME ("artec48u_device_close") 1536 XDBG ((7, "%s: enter: dev=%p\n", function_name, (void *) dev)); 1537 1538 CHECK_DEV_OPEN (dev, function_name); 1539 1540 if (dev->active) 1541 artec48u_device_deactivate (dev); 1542 1543 sanei_usb_close (dev->fd); 1544 dev->fd = -1; 1545 1546 XDBG ((7, "%s: leave: ok\n", function_name)); 1547 return SANE_STATUS_GOOD; 1548} 1549 1550static SANE_Status 1551artec48u_device_activate (Artec48U_Device * dev) 1552{ 1553 DECLARE_FUNCTION_NAME ("artec48u_device_activate") 1554 CHECK_DEV_OPEN (dev, function_name); 1555 1556 if (dev->active) 1557 { 1558 XDBG ((3, "%s: device already active\n", function_name)); 1559 return SANE_STATUS_INVAL; 1560 } 1561 1562 XDBG ((7, "%s: model \"%s\"\n", function_name, dev->sane.model)); 1563 1564 dev->xdpi_offset = SANE_FIX (dev->xdpi_offset * 1565 MM_PER_INCH / dev->optical_xdpi); 1566 dev->ydpi_offset = SANE_FIX (dev->ydpi_offset * 1567 MM_PER_INCH / dev->optical_ydpi); 1568 1569 dev->active = SANE_TRUE; 1570 1571 return SANE_STATUS_GOOD; 1572} 1573 1574static SANE_Status 1575artec48u_device_deactivate (Artec48U_Device * dev) 1576{ 1577 DECLARE_FUNCTION_NAME ("artec48u_device_deactivate") 1578 SANE_Status status = SANE_STATUS_GOOD; 1579 1580 CHECK_DEV_ACTIVE (dev, function_name); 1581 1582 if (dev->read_active) 1583 artec48u_device_read_finish (dev); 1584 1585 dev->active = SANE_FALSE; 1586 1587 return status; 1588} 1589 1590static SANE_Status 1591artec48u_device_memory_write (Artec48U_Device * dev, 1592 SANE_Word addr, 1593 SANE_Word size, SANE_Byte * data) 1594{ 1595 DECLARE_FUNCTION_NAME ("artec48u_device_memory_write") 1596 SANE_Status status; 1597 1598 XDBG ((8, "%s: dev=%p, addr=0x%x, size=0x%x, data=%p\n", 1599 function_name, (void *) dev, addr, size, (void *) data)); 1600 CHECK_DEV_ACTIVE (dev, function_name); 1601 1602 status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 1603 memory_write_value, addr, size, data); 1604 1605 if (status != SANE_STATUS_GOOD) 1606 { 1607 XDBG ((3, "%s: sanei_usb_control_msg failed: %s\n", 1608 function_name, sane_strstatus (status))); 1609 } 1610 1611 return status; 1612} 1613 1614static SANE_Status 1615artec48u_device_memory_read (Artec48U_Device * dev, 1616 SANE_Word addr, SANE_Word size, SANE_Byte * data) 1617{ 1618 DECLARE_FUNCTION_NAME ("artec48u_device_memory_read") 1619 SANE_Status status; 1620 1621 XDBG ((8, "%s: dev=%p, addr=0x%x, size=0x%x, data=%p\n", 1622 function_name, (void *) dev, addr, size, (void *) data)); 1623 CHECK_DEV_ACTIVE (dev, function_name); 1624 1625 status = sanei_usb_control_msg (dev->fd, 0xc0, 0x01, 1626 memory_read_value, addr, size, data); 1627 1628 if (status != SANE_STATUS_GOOD) 1629 { 1630 XDBG ((3, "%s: sanei_usb_control_msg failed: %s\n", 1631 function_name, sane_strstatus (status))); 1632 } 1633 1634 return status; 1635} 1636 1637static SANE_Status 1638artec48u_device_generic_req (Artec48U_Device * dev, 1639 SANE_Word cmd_value, SANE_Word cmd_index, 1640 SANE_Word res_value, SANE_Word res_index, 1641 Artec48U_Packet cmd, Artec48U_Packet res) 1642{ 1643 DECLARE_FUNCTION_NAME ("artec48u_device_generic_req") 1644 SANE_Status status; 1645 1646 XDBG ((7, "%s: command=0x%02x\n", function_name, cmd[0])); 1647 CHECK_DEV_ACTIVE (dev, function_name); 1648 1649 status = sanei_usb_control_msg (dev->fd, 1650 0x40, 0x01, cmd_value, cmd_index, 1651 ARTEC48U_PACKET_SIZE, cmd); 1652 if (status != SANE_STATUS_GOOD) 1653 { 1654 XDBG ((3, "%s: writing command failed: %s\n", 1655 function_name, sane_strstatus (status))); 1656 return status; 1657 } 1658 1659 memset (res, 0, sizeof (Artec48U_Packet)); 1660 1661 status = sanei_usb_control_msg (dev->fd, 1662 0xc0, 0x01, res_value, res_index, 1663 ARTEC48U_PACKET_SIZE, res); 1664 if (status != SANE_STATUS_GOOD) 1665 { 1666 XDBG ((3, "%s: reading response failed: %s\n", 1667 function_name, sane_strstatus (status))); 1668 return status; 1669 } 1670 return status; 1671} 1672 1673static SANE_Status 1674artec48u_device_req (Artec48U_Device * dev, Artec48U_Packet cmd, 1675 Artec48U_Packet res) 1676{ 1677 return artec48u_device_generic_req (dev, 1678 send_cmd_value, 1679 send_cmd_index, 1680 recv_res_value, 1681 recv_res_index, cmd, res); 1682} 1683 1684static SANE_Status 1685artec48u_device_small_req (Artec48U_Device * dev, Artec48U_Packet cmd, 1686 Artec48U_Packet res) 1687{ 1688 Artec48U_Packet fixed_cmd; 1689 int i; 1690 1691 for (i = 0; i < 8; ++i) 1692 memcpy (fixed_cmd + i * 8, cmd, 8); 1693 1694 return artec48u_device_generic_req (dev, 1695 send_small_cmd_value, 1696 send_small_cmd_index, 1697 recv_small_res_value, 1698 recv_small_res_index, fixed_cmd, res); 1699} 1700 1701static SANE_Status 1702artec48u_device_read_raw (Artec48U_Device * dev, SANE_Byte * buffer, 1703 size_t * size) 1704{ 1705 DECLARE_FUNCTION_NAME ("artec48u_device_read_raw") 1706 SANE_Status status; 1707 1708 CHECK_DEV_ACTIVE (dev, function_name); 1709 1710 XDBG ((7, "%s: enter: size=0x%lx\n", function_name, (unsigned long) *size)); 1711 1712 status = sanei_usb_read_bulk (dev->fd, buffer, size); 1713 1714 if (status != SANE_STATUS_GOOD) 1715 { 1716 XDBG ((3, "%s: bulk read failed: %s\n", 1717 function_name, sane_strstatus (status))); 1718 return status; 1719 } 1720 1721 XDBG ((7, "%s: leave: size=0x%lx\n", function_name, (unsigned long) *size)); 1722 1723 return SANE_STATUS_GOOD; 1724} 1725 1726static SANE_Status 1727artec48u_device_set_read_buffer_size (Artec48U_Device * dev, 1728 size_t buffer_size) 1729{ 1730 DECLARE_FUNCTION_NAME ("gt68xx_device_set_read_buffer_size") 1731 CHECK_DEV_NOT_NULL (dev, function_name); 1732 1733 if (dev->read_active) 1734 { 1735 XDBG ((3, "%s: BUG: read already active\n", function_name)); 1736 return SANE_STATUS_INVAL; 1737 } 1738 1739 buffer_size = (buffer_size + 63UL) & ~63UL; 1740 if (buffer_size > 0) 1741 { 1742 dev->requested_buffer_size = buffer_size; 1743 return SANE_STATUS_GOOD; 1744 } 1745 1746 XDBG ((3, "%s: bad buffer size\n", function_name)); 1747 return SANE_STATUS_INVAL; 1748} 1749 1750static SANE_Status 1751artec48u_device_read_prepare (Artec48U_Device * dev, size_t expected_count) 1752{ 1753 DECLARE_FUNCTION_NAME ("artec48u_device_read_prepare") 1754 CHECK_DEV_ACTIVE (dev, function_name); 1755 1756 if (dev->read_active) 1757 { 1758 XDBG ((3, "%s: read already active\n", function_name)); 1759 return SANE_STATUS_INVAL; 1760 } 1761 1762 dev->read_buffer = (SANE_Byte *) malloc (dev->requested_buffer_size); 1763 if (!dev->read_buffer) 1764 { 1765 XDBG ((3, "%s: not enough memory for the read buffer (%lu bytes)\n", 1766 function_name, (unsigned long) dev->requested_buffer_size)); 1767 return SANE_STATUS_NO_MEM; 1768 } 1769 1770 dev->read_active = SANE_TRUE; 1771 dev->read_pos = dev->read_bytes_in_buffer = 0; 1772 dev->read_bytes_left = expected_count; 1773 1774 return SANE_STATUS_GOOD; 1775} 1776 1777static void 1778reader_process_sigterm_handler (int signal) 1779{ 1780 XDBG ((1, "reader_process: terminated by signal %d\n", signal)); 1781 _exit (SANE_STATUS_GOOD); 1782} 1783 1784static void 1785usb_reader_process_sigterm_handler (int signal) 1786{ 1787 XDBG ((1, "reader_process (usb): terminated by signal %d\n", signal)); 1788 cancelRead = SANE_TRUE; 1789} 1790 1791static SANE_Status 1792artec48u_device_read_start (Artec48U_Device * dev) 1793{ 1794 CHECK_DEV_ACTIVE (dev, "artec48u_device_read_start"); 1795 1796 return SANE_STATUS_GOOD; 1797} 1798 1799static SANE_Status 1800artec48u_device_read (Artec48U_Device * dev, SANE_Byte * buffer, 1801 size_t * size) 1802{ 1803 DECLARE_FUNCTION_NAME ("artec48u_device_read") SANE_Status status; 1804 size_t byte_count = 0; 1805 size_t left_to_read = *size; 1806 size_t transfer_size, block_size, raw_block_size; 1807 1808 CHECK_DEV_ACTIVE (dev, function_name); 1809 1810 if (!dev->read_active) 1811 { 1812 XDBG ((3, "%s: read not active\n", function_name)); 1813 return SANE_STATUS_INVAL; 1814 } 1815 1816 while (left_to_read > 0) 1817 { 1818 if (dev->read_bytes_in_buffer == 0) 1819 { 1820 block_size = dev->requested_buffer_size; 1821 if (block_size > dev->read_bytes_left) 1822 block_size = dev->read_bytes_left; 1823 if (block_size == 0) 1824 break; 1825 raw_block_size = (block_size + 63UL) & ~63UL; 1826 status = artec48u_device_read_raw (dev, dev->read_buffer, 1827 &raw_block_size); 1828 if (status != SANE_STATUS_GOOD) 1829 { 1830 XDBG ((3, "%s: read failed\n", function_name)); 1831 return status; 1832 } 1833 dev->read_pos = 0; 1834 dev->read_bytes_in_buffer = block_size; 1835 dev->read_bytes_left -= block_size; 1836 } 1837 1838 transfer_size = left_to_read; 1839 if (transfer_size > dev->read_bytes_in_buffer) 1840 transfer_size = dev->read_bytes_in_buffer; 1841 if (transfer_size > 0) 1842 { 1843 memcpy (buffer, dev->read_buffer + dev->read_pos, transfer_size); 1844 dev->read_pos += transfer_size; 1845 dev->read_bytes_in_buffer -= transfer_size; 1846 byte_count += transfer_size; 1847 left_to_read -= transfer_size; 1848 buffer += transfer_size; 1849 } 1850 } 1851 1852 *size = byte_count; 1853 1854 if (byte_count == 0) 1855 return SANE_STATUS_EOF; 1856 else 1857 return SANE_STATUS_GOOD; 1858} 1859 1860static SANE_Status 1861artec48u_device_read_finish (Artec48U_Device * dev) 1862{ 1863 DECLARE_FUNCTION_NAME ("artec48u_device_read_finish") 1864 CHECK_DEV_ACTIVE (dev, function_name); 1865 1866 if (!dev->read_active) 1867 { 1868 XDBG ((3, "%s: read not active\n", function_name)); 1869 return SANE_STATUS_INVAL; 1870 } 1871 1872 XDBG ((7, "%s: read_bytes_left = %ld\n", 1873 function_name, (long) dev->read_bytes_left)); 1874 1875 free (dev->read_buffer); 1876 dev->read_buffer = NULL; 1877 1878 dev->read_active = SANE_FALSE; 1879 1880 return SANE_STATUS_GOOD; 1881} 1882 1883static SANE_Status 1884artec48u_delay_buffer_init (Artec48U_Delay_Buffer * delay, 1885 SANE_Int pixels_per_line) 1886{ 1887 DECLARE_FUNCTION_NAME ("artec48u_delay_buffer_init") 1888 SANE_Int bytes_per_line; 1889 SANE_Int line_count, i; 1890 1891 if (pixels_per_line <= 0) 1892 { 1893 XDBG ((3, "%s: BUG: pixels_per_line=%d\n", 1894 function_name, pixels_per_line)); 1895 return SANE_STATUS_INVAL; 1896 } 1897 1898 bytes_per_line = pixels_per_line * sizeof (unsigned int); 1899 1900 delay->line_count = line_count = 1; 1901 delay->read_index = 0; 1902 delay->write_index = 0; 1903 1904 delay->mem_block = (SANE_Byte *) malloc (bytes_per_line * line_count); 1905 if (!delay->mem_block) 1906 { 1907 XDBG ((3, "%s: no memory for delay block\n", function_name)); 1908 return SANE_STATUS_NO_MEM; 1909 } 1910 1911 delay->lines = 1912 (unsigned int **) malloc (sizeof (unsigned int *) * line_count); 1913 if (!delay->lines) 1914 { 1915 free (delay->mem_block); 1916 XDBG ((3, "%s: no memory for delay line pointers\n", function_name)); 1917 return SANE_STATUS_NO_MEM; 1918 } 1919 1920 for (i = 0; i < line_count; ++i) 1921 delay->lines[i] = 1922 (unsigned int *) (delay->mem_block + i * bytes_per_line); 1923 1924 return SANE_STATUS_GOOD; 1925} 1926 1927static SANE_Status 1928artec48u_delay_buffer_done (Artec48U_Delay_Buffer * delay) 1929{ 1930 if (delay->lines) 1931 { 1932 free (delay->lines); 1933 delay->lines = NULL; 1934 } 1935 1936 if (delay->mem_block) 1937 { 1938 free (delay->mem_block); 1939 delay->mem_block = NULL; 1940 } 1941 1942 return SANE_STATUS_GOOD; 1943} 1944 1945#define DELAY_BUFFER_WRITE_PTR(delay) ( (delay)->lines[(delay)->write_index] ) 1946 1947#define DELAY_BUFFER_READ_PTR(delay) ( (delay)->lines[(delay)->read_index ] ) 1948 1949#define DELAY_BUFFER_STEP(delay) \ 1950 do { \ 1951 (delay)->read_index = ((delay)->read_index + 1) % (delay)->line_count; \ 1952 (delay)->write_index = ((delay)->write_index + 1) % (delay)->line_count; \ 1953 } while (SANE_FALSE) 1954 1955 1956static inline void 1957unpack_8_mono (SANE_Byte * src, unsigned int *dst, SANE_Int pixels_per_line) 1958{ 1959 XDBG ((3, "unpack_8_mono\n")); 1960 for (; pixels_per_line > 0; ++src, ++dst, --pixels_per_line) 1961 { 1962 *dst = (((unsigned int) *src) << 8) | *src; 1963 } 1964} 1965 1966static inline void 1967unpack_16_le_mono (SANE_Byte * src, unsigned int *dst, 1968 SANE_Int pixels_per_line) 1969{ 1970 XDBG ((3, "unpack_16_le_mono\n")); 1971 for (; pixels_per_line > 0; src += 2, dst++, --pixels_per_line) 1972 { 1973 *dst = (((unsigned int) src[1]) << 8) | src[0]; 1974 } 1975} 1976 1977static SANE_Status 1978line_read_gray_8 (Artec48U_Line_Reader * reader, 1979 unsigned int **buffer_pointers_return) 1980{ 1981 SANE_Status status; 1982 size_t size; 1983 unsigned int *buffer; 1984 XDBG ((3, "line_read_gray_8\n")); 1985 1986 size = reader->params.scan_bpl; 1987 status = artec48u_device_read (reader->dev, reader->pixel_buffer, &size); 1988 if (status != SANE_STATUS_GOOD) 1989 return status; 1990 1991 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay); 1992 buffer_pointers_return[0] = buffer; 1993 unpack_8_mono (reader->pixel_buffer, buffer, reader->pixels_per_line); 1994 1995 return SANE_STATUS_GOOD; 1996} 1997 1998static SANE_Status 1999line_read_gray_16 (Artec48U_Line_Reader * reader, 2000 unsigned int **buffer_pointers_return) 2001{ 2002 SANE_Status status; 2003 size_t size; 2004 unsigned int *buffer; 2005 2006 XDBG ((3, "line_read_gray_16\n")); 2007 size = reader->params.scan_bpl; 2008 status = artec48u_device_read (reader->dev, reader->pixel_buffer, &size); 2009 if (status != SANE_STATUS_GOOD) 2010 return status; 2011 2012 buffer = DELAY_BUFFER_READ_PTR (&reader->g_delay); 2013 buffer_pointers_return[0] = buffer; 2014 unpack_16_le_mono (reader->pixel_buffer, buffer, reader->pixels_per_line); 2015 2016 return SANE_STATUS_GOOD; 2017} 2018 2019static SANE_Status 2020line_read_bgr_8_line_mode (Artec48U_Line_Reader * reader, 2021 unsigned int **buffer_pointers_return) 2022{ 2023 SANE_Status status; 2024 size_t size; 2025 SANE_Int pixels_per_line; 2026 SANE_Byte *pixel_buffer = reader->pixel_buffer; 2027 XDBG ((3, "line_read_bgr_8_line_mode\n")); 2028 2029 size = reader->params.scan_bpl * 3; 2030 status = artec48u_device_read (reader->dev, pixel_buffer, &size); 2031 if (status != SANE_STATUS_GOOD) 2032 return status; 2033 2034 pixels_per_line = reader->pixels_per_line; 2035 unpack_8_mono (pixel_buffer, 2036 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), pixels_per_line); 2037 pixel_buffer += reader->params.scan_bpl; 2038 unpack_8_mono (pixel_buffer, 2039 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), pixels_per_line); 2040 pixel_buffer += reader->params.scan_bpl; 2041 unpack_8_mono (pixel_buffer, 2042 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), pixels_per_line); 2043 2044 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay); 2045 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay); 2046 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay); 2047 2048 DELAY_BUFFER_STEP (&reader->r_delay); 2049 DELAY_BUFFER_STEP (&reader->g_delay); 2050 DELAY_BUFFER_STEP (&reader->b_delay); 2051 2052 return SANE_STATUS_GOOD; 2053} 2054 2055static SANE_Status 2056line_read_bgr_16_line_mode (Artec48U_Line_Reader * reader, 2057 unsigned int **buffer_pointers_return) 2058{ 2059 SANE_Status status; 2060 size_t size; 2061 SANE_Int pixels_per_line; 2062 SANE_Byte *pixel_buffer = reader->pixel_buffer; 2063 2064 XDBG ((3, "line_read_bgr_16_line_mode\n")); 2065 size = reader->params.scan_bpl * 3; 2066 status = artec48u_device_read (reader->dev, pixel_buffer, &size); 2067 if (status != SANE_STATUS_GOOD) 2068 return status; 2069 2070 pixels_per_line = reader->pixels_per_line; 2071 unpack_16_le_mono (pixel_buffer, 2072 DELAY_BUFFER_WRITE_PTR (&reader->b_delay), 2073 pixels_per_line); 2074 pixel_buffer += reader->params.scan_bpl; 2075 unpack_16_le_mono (pixel_buffer, 2076 DELAY_BUFFER_WRITE_PTR (&reader->g_delay), 2077 pixels_per_line); 2078 pixel_buffer += reader->params.scan_bpl; 2079 unpack_16_le_mono (pixel_buffer, 2080 DELAY_BUFFER_WRITE_PTR (&reader->r_delay), 2081 pixels_per_line); 2082 2083 buffer_pointers_return[0] = DELAY_BUFFER_READ_PTR (&reader->r_delay); 2084 buffer_pointers_return[1] = DELAY_BUFFER_READ_PTR (&reader->g_delay); 2085 buffer_pointers_return[2] = DELAY_BUFFER_READ_PTR (&reader->b_delay); 2086 2087 DELAY_BUFFER_STEP (&reader->r_delay); 2088 DELAY_BUFFER_STEP (&reader->g_delay); 2089 DELAY_BUFFER_STEP (&reader->b_delay); 2090 2091 return SANE_STATUS_GOOD; 2092} 2093 2094static SANE_Status 2095artec48u_line_reader_init_delays (Artec48U_Line_Reader * reader) 2096{ 2097 SANE_Status status; 2098 2099 if (reader->params.color) 2100 { 2101 status = artec48u_delay_buffer_init (&reader->r_delay, 2102 reader->params.pixel_xs); 2103 if (status != SANE_STATUS_GOOD) 2104 return status; 2105 2106 status = artec48u_delay_buffer_init (&reader->g_delay, 2107 reader->params.pixel_xs); 2108 if (status != SANE_STATUS_GOOD) 2109 { 2110 artec48u_delay_buffer_done (&reader->r_delay); 2111 return status; 2112 } 2113 2114 status = artec48u_delay_buffer_init (&reader->b_delay, 2115 reader->params.pixel_xs); 2116 if (status != SANE_STATUS_GOOD) 2117 { 2118 artec48u_delay_buffer_done (&reader->g_delay); 2119 artec48u_delay_buffer_done (&reader->r_delay); 2120 return status; 2121 } 2122 } 2123 else 2124 { 2125 status = artec48u_delay_buffer_init (&reader->g_delay, 2126 reader->params.pixel_xs); 2127 if (status != SANE_STATUS_GOOD) 2128 return status; 2129 } 2130 2131 reader->delays_initialized = SANE_TRUE; 2132 2133 return SANE_STATUS_GOOD; 2134} 2135 2136static void 2137artec48u_line_reader_free_delays (Artec48U_Line_Reader * reader) 2138{ 2139 if (!reader) 2140 { 2141 return; 2142 } 2143 if (reader->delays_initialized) 2144 { 2145 if (reader->params.color) 2146 { 2147 artec48u_delay_buffer_done (&reader->b_delay); 2148 artec48u_delay_buffer_done (&reader->g_delay); 2149 artec48u_delay_buffer_done (&reader->r_delay); 2150 } 2151 else 2152 { 2153 artec48u_delay_buffer_done (&reader->g_delay); 2154 } 2155 reader->delays_initialized = SANE_FALSE; 2156 } 2157} 2158 2159static SANE_Status 2160artec48u_line_reader_new (Artec48U_Device * dev, 2161 Artec48U_Scan_Parameters * params, 2162 Artec48U_Line_Reader ** reader_return) 2163{ 2164 DECLARE_FUNCTION_NAME ("artec48u_line_reader_new") SANE_Status status; 2165 Artec48U_Line_Reader *reader; 2166 SANE_Int image_size; 2167 SANE_Int scan_bpl_full; 2168 2169 XDBG ((6, "%s: enter\n", function_name)); 2170 XDBG ((6, "%s: enter params xdpi: %i\n", function_name, params->xdpi)); 2171 XDBG ((6, "%s: enter params ydpi: %i\n", function_name, params->ydpi)); 2172 XDBG ((6, "%s: enter params depth: %i\n", function_name, params->depth)); 2173 XDBG ((6, "%s: enter params color: %i\n", function_name, params->color)); 2174 XDBG ((6, "%s: enter params pixel_xs: %i\n", function_name, params->pixel_xs)); 2175 XDBG ((6, "%s: enter params pixel_ys: %i\n", function_name, params->pixel_ys)); 2176 XDBG ((6, "%s: enter params scan_xs: %i\n", function_name, params->scan_xs)); 2177 XDBG ((6, "%s: enter params scan_ys: %i\n", function_name, params->scan_ys)); 2178 XDBG ((6, "%s: enter params scan_bpl: %i\n", function_name, params->scan_bpl)); 2179 *reader_return = NULL; 2180 2181 reader = (Artec48U_Line_Reader *) malloc (sizeof (Artec48U_Line_Reader)); 2182 if (!reader) 2183 { 2184 XDBG ((3, "%s: cannot allocate Artec48U_Line_Reader\n", function_name)); 2185 return SANE_STATUS_NO_MEM; 2186 } 2187 memset (reader, 0, sizeof (Artec48U_Line_Reader)); 2188 2189 reader->dev = dev; 2190 memcpy (&reader->params, params, sizeof (Artec48U_Scan_Parameters)); 2191 reader->pixel_buffer = 0; 2192 reader->delays_initialized = SANE_FALSE; 2193 2194 reader->read = NULL; 2195 2196 status = artec48u_line_reader_init_delays (reader); 2197 if (status != SANE_STATUS_GOOD) 2198 { 2199 XDBG ((3, "%s: cannot allocate line buffers: %s\n", 2200 function_name, sane_strstatus (status))); 2201 free (reader); 2202 return status; 2203 } 2204 2205 reader->pixels_per_line = reader->params.pixel_xs; 2206 2207 if (!reader->params.color) 2208 { 2209 XDBG ((2, "!reader->params.color\n")); 2210 if (reader->params.depth == 8) 2211 reader->read = line_read_gray_8; 2212 else if (reader->params.depth == 16) 2213 reader->read = line_read_gray_16; 2214 } 2215 else 2216 { 2217 XDBG ((2, "reader line mode\n")); 2218 if (reader->params.depth == 8) 2219 { 2220 XDBG ((2, "depth 8\n")); 2221 reader->read = line_read_bgr_8_line_mode; 2222 } 2223 else if (reader->params.depth == 16) 2224 { 2225 XDBG ((2, "depth 16\n")); 2226 reader->read = line_read_bgr_16_line_mode; 2227 } 2228 } 2229 2230 if (reader->read == NULL) 2231 { 2232 XDBG ((3, "%s: unsupported bit depth (%d)\n", 2233 function_name, reader->params.depth)); 2234 artec48u_line_reader_free_delays (reader); 2235 free (reader); 2236 return SANE_STATUS_UNSUPPORTED; 2237 } 2238 2239 scan_bpl_full = reader->params.scan_bpl; 2240 if (reader->params.color) 2241 scan_bpl_full *= 3; 2242 2243 reader->pixel_buffer = malloc (scan_bpl_full); 2244 if (!reader->pixel_buffer) 2245 { 2246 XDBG ((3, "%s: cannot allocate pixel buffer\n", function_name)); 2247 artec48u_line_reader_free_delays (reader); 2248 free (reader); 2249 return SANE_STATUS_NO_MEM; 2250 } 2251 2252 artec48u_device_set_read_buffer_size (reader->dev, 2253 scan_bpl_full /* 200 */ ); 2254 2255 image_size = scan_bpl_full * reader->params.scan_ys; 2256 status = artec48u_device_read_prepare (reader->dev, image_size); 2257 if (status != SANE_STATUS_GOOD) 2258 { 2259 XDBG ((3, "%s: artec48u_device_read_prepare failed: %s\n", 2260 function_name, sane_strstatus (status))); 2261 free (reader->pixel_buffer); 2262 artec48u_line_reader_free_delays (reader); 2263 free (reader); 2264 return status; 2265 } 2266 2267 XDBG ((6, "%s: leave: ok\n", function_name)); 2268 *reader_return = reader; 2269 return SANE_STATUS_GOOD; 2270} 2271 2272static SANE_Status 2273artec48u_line_reader_free (Artec48U_Line_Reader * reader) 2274{ 2275 DECLARE_FUNCTION_NAME ("artec48u_line_reader_free") SANE_Status status; 2276 2277 XDBG ((6, "%s: enter\n", function_name)); 2278 2279 if (!reader) 2280 { 2281 return SANE_STATUS_GOOD; 2282 } 2283 artec48u_line_reader_free_delays (reader); 2284 2285 if (reader->pixel_buffer) 2286 { 2287 free (reader->pixel_buffer); 2288 reader->pixel_buffer = NULL; 2289 } 2290 2291 status = artec48u_device_read_finish (reader->dev); 2292 if (status != SANE_STATUS_GOOD) 2293 { 2294 XDBG ((3, "%s: artec48u_device_read_finish failed: %s\n", 2295 function_name, sane_strstatus (status))); 2296 } 2297 2298 if (reader) 2299 free (reader); 2300 2301 XDBG ((6, "%s: leave\n", function_name)); 2302 return status; 2303} 2304 2305static SANE_Status 2306artec48u_line_reader_read (Artec48U_Line_Reader * reader, 2307 unsigned int **buffer_pointers_return) 2308{ 2309 return (*reader->read) (reader, buffer_pointers_return); 2310} 2311 2312static SANE_Status 2313artec48u_scanner_new (Artec48U_Device * dev, 2314 Artec48U_Scanner ** scanner_return) 2315{ 2316 DECLARE_FUNCTION_NAME ("artec48u_scanner_new") Artec48U_Scanner *s; 2317 2318 *scanner_return = NULL; 2319 2320 s = (Artec48U_Scanner *) malloc (sizeof (Artec48U_Scanner)); 2321 if (!s) 2322 { 2323 XDBG ((5, "%s: no memory for Artec48U_Scanner\n", function_name)); 2324 return SANE_STATUS_NO_MEM; 2325 } 2326 s->dev = dev; 2327 s->reader = NULL; 2328 s->scanning = SANE_FALSE; 2329 s->line_buffer = NULL; 2330 s->lineart_buffer = NULL; 2331 s->next = NULL; 2332 s->pipe_handle = NULL; 2333 s->buffer_pointers[0] = NULL; 2334 s->buffer_pointers[1] = NULL; 2335 s->buffer_pointers[2] = NULL; 2336 s->shading_buffer_w = NULL; 2337 s->shading_buffer_b = NULL; 2338 s->shading_buffer_white[0] = NULL; 2339 s->shading_buffer_white[1] = NULL; 2340 s->shading_buffer_white[2] = NULL; 2341 s->shading_buffer_black[0] = NULL; 2342 s->shading_buffer_black[1] = NULL; 2343 s->shading_buffer_black[2] = NULL; 2344 *scanner_return = s; 2345 return SANE_STATUS_GOOD; 2346} 2347 2348static SANE_Status 2349artec48u_scanner_read_line (Artec48U_Scanner * s, 2350 unsigned int **buffer_pointers, SANE_Bool shading) 2351{ 2352 DECLARE_FUNCTION_NAME ("artec48u_scanner_read_line") SANE_Status status; 2353 int i, j, c; 2354 2355 status = artec48u_line_reader_read (s->reader, buffer_pointers); 2356 2357 if (status != SANE_STATUS_GOOD) 2358 { 2359 XDBG ((5, "%s: artec48u_line_reader_read failed: %s\n", 2360 function_name, sane_strstatus (status))); 2361 return status; 2362 } 2363 if (shading != SANE_TRUE) 2364 return status; 2365 2366 c = s->reader->pixels_per_line; 2367 if (s->reader->params.color == SANE_TRUE) 2368 { 2369 for (i = c - 1; i >= 0; i--) 2370 { 2371 for (j = 0; j < 3; j++) 2372 { 2373 int new_value; 2374 unsigned int value = buffer_pointers[j][i]; 2375 if (value < s->shading_buffer_black[j][i]) 2376 value = s->shading_buffer_black[j][i]; 2377 if (value > s->shading_buffer_white[j][i]) 2378 value = s->shading_buffer_white[j][i]; 2379 new_value = 2380 (double) (value - 2381 s->shading_buffer_black[j][i]) * 65535.0 / 2382 (double) (s->shading_buffer_white[j][i] - 2383 s->shading_buffer_black[j][i]); 2384 if (new_value < 0) 2385 new_value = 0; 2386 if (new_value > 65535) 2387 new_value = 65535; 2388 new_value = 2389 s->gamma_array[j + 2390 1][s->contrast_array[s-> 2391 brightness_array 2392 [new_value]]]; 2393 new_value = s->gamma_array[0][new_value]; 2394 buffer_pointers[j][i] = new_value; 2395 } 2396 } 2397 } 2398 else 2399 { 2400 for (i = c - 1; i >= 0; i--) 2401 { 2402 int new_value; 2403 unsigned int value = buffer_pointers[0][i]; 2404 new_value = 2405 (double) (value - 2406 s->shading_buffer_black[1][i]) * 65535.0 / 2407 (double) (s->shading_buffer_white[1][i] - 2408 s->shading_buffer_black[1][i]); 2409 if (new_value < 0) 2410 new_value = 0; 2411 if (new_value > 65535) 2412 new_value = 65535; 2413 new_value = 2414 s->gamma_array[0][s-> 2415 contrast_array[s->brightness_array[new_value]]]; 2416 buffer_pointers[0][i] = new_value; 2417 } 2418 } 2419 return status; 2420} 2421 2422static SANE_Status 2423artec48u_scanner_free (Artec48U_Scanner * s) 2424{ 2425 DECLARE_FUNCTION_NAME ("artec48u_scanner_free") if (!s) 2426 { 2427 XDBG ((5, "%s: scanner==NULL\n", function_name)); 2428 return SANE_STATUS_INVAL; 2429 } 2430 2431 if (s->reader) 2432 { 2433 artec48u_line_reader_free (s->reader); 2434 s->reader = NULL; 2435 } 2436 2437 free (s->shading_buffer_w); 2438 free (s->shading_buffer_b); 2439 free (s->shading_buffer_white[0]); 2440 free (s->shading_buffer_black[0]); 2441 free (s->shading_buffer_white[1]); 2442 free (s->shading_buffer_black[1]); 2443 free (s->shading_buffer_white[2]); 2444 free (s->shading_buffer_black[2]); 2445 2446 if (s->line_buffer) 2447 free (s->line_buffer); 2448 if (s->lineart_buffer) 2449 free (s->lineart_buffer); 2450 2451 free (s); 2452 2453 return SANE_STATUS_GOOD; 2454} 2455 2456static SANE_Status 2457artec48u_scanner_internal_start_scan (Artec48U_Scanner * s) 2458{ 2459 DECLARE_FUNCTION_NAME ("artec48u_scanner_internal_start_scan") 2460 SANE_Status status; 2461 SANE_Bool ready; 2462 SANE_Int repeat_count; 2463 2464 status = artec48u_wait_for_positioning (s->dev); 2465 if (status != SANE_STATUS_GOOD) 2466 { 2467 XDBG ((2, "%s: artec48u_scanner_wait_for_positioning error: %s\n", 2468 function_name, sane_strstatus (status))); 2469 return status; 2470 } 2471 2472 status = artec48u_generic_start_scan (s->dev); 2473 if (status != SANE_STATUS_GOOD) 2474 { 2475 XDBG ((2, "%s: artec48u_device_start_scan error: %s\n", 2476 function_name, sane_strstatus (status))); 2477 return status; 2478 } 2479 2480 for (repeat_count = 0; repeat_count < 30 * 10; ++repeat_count) 2481 { 2482 status = artec48u_generic_read_scanned_data (s->dev, &ready); 2483 if (status != SANE_STATUS_GOOD) 2484 { 2485 XDBG ((2, "%s: artec48u_device_read_scanned_data error: %s\n", 2486 function_name, sane_strstatus (status))); 2487 return status; 2488 } 2489 if (ready) 2490 break; 2491 usleep (100000); 2492 } 2493 2494 if (!ready) 2495 { 2496 XDBG ((2, "%s: scanner still not ready - giving up\n", function_name)); 2497 return SANE_STATUS_DEVICE_BUSY; 2498 } 2499 2500 status = artec48u_device_read_start (s->dev); 2501 if (status != SANE_STATUS_GOOD) 2502 { 2503 XDBG ((2, "%s: artec48u_device_read_start error: %s\n", 2504 function_name, sane_strstatus (status))); 2505 return status; 2506 } 2507 2508 return SANE_STATUS_GOOD; 2509} 2510 2511static SANE_Status 2512artec48u_scanner_start_scan_extended (Artec48U_Scanner * s, 2513 Artec48U_Scan_Request * request, 2514 Artec48U_Scan_Action action, 2515 Artec48U_Scan_Parameters * params) 2516{ 2517 DECLARE_FUNCTION_NAME ("artec48u_scanner_start_scan_extended") 2518 SANE_Status status; 2519 2520 status = artec48u_wait_for_positioning (s->dev); 2521 if (status != SANE_STATUS_GOOD) 2522 { 2523 XDBG ((2, "%s: artec48u_scanner_wait_for_positioning error: %s\n", 2524 function_name, sane_strstatus (status))); 2525 return status; 2526 } 2527 2528 if (action == SA_SCAN) 2529 status = artec48u_setup_scan (s, request, action, SANE_FALSE, params); 2530 if (status != SANE_STATUS_GOOD) 2531 { 2532 XDBG ((2, "%s: artec48u_device_setup_scan failed: %s\n", function_name, 2533 sane_strstatus (status))); 2534 return status; 2535 } 2536 status = artec48u_line_reader_new (s->dev, params, &s->reader); 2537 if (status != SANE_STATUS_GOOD) 2538 { 2539 XDBG ((2, "%s: artec48u_line_reader_new failed: %s\n", function_name, 2540 sane_strstatus (status))); 2541 return status; 2542 } 2543 2544 status = artec48u_scanner_internal_start_scan (s); 2545 2546 if (status != SANE_STATUS_GOOD) 2547 { 2548 XDBG ((2, "%s: artec48u_scanner_internal_start_scan failed: %s\n", 2549 function_name, sane_strstatus (status))); 2550 return status; 2551 } 2552 2553 return SANE_STATUS_GOOD; 2554} 2555 2556static SANE_Status 2557artec48u_scanner_start_scan (Artec48U_Scanner * s, 2558 Artec48U_Scan_Request * request, 2559 Artec48U_Scan_Parameters * params) 2560{ 2561 return artec48u_scanner_start_scan_extended (s, request, SA_SCAN, params); 2562} 2563 2564 2565static SANE_Status 2566artec48u_scanner_stop_scan (Artec48U_Scanner * s) 2567{ 2568 XDBG ((1, "artec48u_scanner_stop_scan begin: \n")); 2569 artec48u_line_reader_free (s->reader); 2570 s->reader = NULL; 2571 2572 return artec48u_stop_scan (s->dev); 2573} 2574 2575static void 2576calculateGamma (Artec48U_Scanner * s) 2577{ 2578 double d; 2579 int gval; 2580 unsigned int i; 2581 2582 double gamma = SANE_UNFIX (s->val[OPT_GAMMA].w); 2583 2584 d = 65536.0 / pow (65536.0, 1.0 / gamma); 2585 for (i = 0; i < 65536; i++) 2586 { 2587 gval = (int) (pow ((double) i, 1.0 / gamma) * d); 2588 s->gamma_array[0][i] = gval; 2589 } 2590} 2591 2592static void 2593calculateGammaRed (Artec48U_Scanner * s) 2594{ 2595 double d; 2596 int gval; 2597 unsigned int i; 2598 2599 double gamma = SANE_UNFIX (s->val[OPT_GAMMA_R].w); 2600 2601 d = 65536.0 / pow (65536.0, 1.0 / gamma); 2602 for (i = 0; i < 65536; i++) 2603 { 2604 gval = (int) (pow ((double) i, 1.0 / gamma) * d); 2605 s->gamma_array[1][i] = gval; 2606 } 2607} 2608 2609static void 2610calculateGammaGreen (Artec48U_Scanner * s) 2611{ 2612 double d; 2613 int gval; 2614 unsigned int i; 2615 2616 double gamma = SANE_UNFIX (s->val[OPT_GAMMA_G].w); 2617 2618 d = 65536.0 / pow (65536.0, 1.0 / gamma); 2619 for (i = 0; i < 65536; i++) 2620 { 2621 gval = (int) (pow ((double) i, 1.0 / gamma) * d); 2622 s->gamma_array[2][i] = gval; 2623 } 2624} 2625 2626static void 2627calculateGammaBlue (Artec48U_Scanner * s) 2628{ 2629 double d; 2630 int gval; 2631 unsigned int i; 2632 2633 double gamma = SANE_UNFIX (s->val[OPT_GAMMA_B].w); 2634 2635 d = 65536.0 / pow (65536.0, 1.0 / gamma); 2636 for (i = 0; i < 65536; i++) 2637 { 2638 gval = (int) (pow ((double) i, 1.0 / gamma) * d); 2639 s->gamma_array[3][i] = gval; 2640 } 2641} 2642 2643static SANE_Status 2644artec48u_calculate_shading_buffer (Artec48U_Scanner * s, int start, int end, 2645 int resolution, SANE_Bool color) 2646{ 2647 int i; 2648 int c; 2649 int bpp; 2650 c = 0; 2651 bpp = 6; 2652 switch (resolution) 2653 { 2654 case 50: 2655 bpp = 72; 2656 break; 2657 case 100: 2658 bpp = 36; 2659 break; 2660 case 200: 2661 bpp = 18; 2662 break; 2663 case 300: 2664 bpp = 12; 2665 break; 2666 case 600: 2667 bpp = 6; 2668 break; 2669 case 1200: 2670 if(s->dev->is_epro == 0) 2671 bpp = 6; 2672 else 2673 bpp = 3; 2674 } 2675 2676 for (i = start * bpp; i < end * bpp; i += bpp) 2677 { 2678 if (color) 2679 { 2680 s->shading_buffer_white[0][c] = 2681 (unsigned int) s->shading_buffer_w[i] + 2682 ((((unsigned int) s->shading_buffer_w[i + 1]) << 8)); 2683 s->shading_buffer_white[2][c] = 2684 (unsigned int) s->shading_buffer_w[i + 4] + 2685 ((((unsigned int) s->shading_buffer_w[i + 5]) << 8)); 2686 s->shading_buffer_black[0][c] = 2687 (unsigned int) s->shading_buffer_b[i] + 2688 ((((unsigned int) s->shading_buffer_b[i + 1]) << 8)); 2689 s->shading_buffer_black[2][c] = 2690 (unsigned int) s->shading_buffer_b[i + 4] + 2691 ((((unsigned int) s->shading_buffer_b[i + 5]) << 8)); 2692 } 2693 s->shading_buffer_white[1][c] = 2694 (unsigned int) s->shading_buffer_w[i + 2] + 2695 ((((unsigned int) s->shading_buffer_w[i + 3]) << 8)); 2696 s->shading_buffer_black[1][c] = 2697 (unsigned int) s->shading_buffer_b[i + 2] + 2698 ((((unsigned int) s->shading_buffer_b[i + 3]) << 8)); 2699 ++c; 2700 } 2701 return SANE_STATUS_GOOD; 2702} 2703 2704static size_t 2705max_string_size (const SANE_String_Const strings[]) 2706{ 2707 size_t size, max_size = 0; 2708 SANE_Int i; 2709 2710 for (i = 0; strings[i]; ++i) 2711 { 2712 size = strlen (strings[i]) + 1; 2713 if (size > max_size) 2714 max_size = size; 2715 } 2716 return max_size; 2717} 2718 2719static SANE_Status 2720init_options (Artec48U_Scanner * s) 2721{ 2722 int i; 2723 2724 XDBG ((5, "init_options: scanner %p\n", (void *) s)); 2725 XDBG ((5, "init_options: start\n")); 2726 XDBG ((5, "init_options: num options %i\n", NUM_OPTIONS)); 2727 2728 memset (s->val, 0, sizeof (s->val)); 2729 memset (s->opt, 0, sizeof (s->opt)); 2730 2731 for (i = 0; i < NUM_OPTIONS; ++i) 2732 { 2733 s->opt[i].size = sizeof (SANE_Word); 2734 s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; 2735 } 2736 s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS; 2737 s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; 2738 s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; 2739 s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; 2740 s->opt[OPT_NUM_OPTS].unit = SANE_UNIT_NONE; 2741 s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; 2742 s->opt[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE; 2743 s->val[OPT_NUM_OPTS].w = NUM_OPTIONS; 2744 2745 s->opt[OPT_MODE_GROUP].name = "scanmode-group"; 2746 s->opt[OPT_MODE_GROUP].title = SANE_TITLE_SCAN_MODE; 2747 s->opt[OPT_MODE_GROUP].desc = ""; 2748 s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; 2749 s->opt[OPT_MODE_GROUP].size = 0; 2750 s->opt[OPT_MODE_GROUP].unit = SANE_UNIT_NONE; 2751 s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; 2752 s->opt[OPT_MODE_GROUP].cap = 0; 2753 2754 s->opt[OPT_SCAN_MODE].name = SANE_NAME_SCAN_MODE; 2755 s->opt[OPT_SCAN_MODE].title = SANE_TITLE_SCAN_MODE; 2756 s->opt[OPT_SCAN_MODE].desc = SANE_DESC_SCAN_MODE; 2757 s->opt[OPT_SCAN_MODE].type = SANE_TYPE_STRING; 2758 s->opt[OPT_SCAN_MODE].size = max_string_size (mode_list); 2759 s->opt[OPT_SCAN_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; 2760 s->opt[OPT_SCAN_MODE].constraint.string_list = mode_list; 2761 s->val[OPT_SCAN_MODE].s = strdup (mode_list[1]); 2762 2763 s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH; 2764 s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH; 2765 s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH; 2766 s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT; 2767 s->opt[OPT_BIT_DEPTH].unit = SANE_UNIT_NONE; 2768 s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST; 2769 s->opt[OPT_BIT_DEPTH].constraint.word_list = bitdepth_list; 2770 s->val[OPT_BIT_DEPTH].w = bitdepth_list[1]; 2771 2772 /* black level (lineart only) */ 2773 s->opt[OPT_BLACK_LEVEL].name = SANE_NAME_BLACK_LEVEL; 2774 s->opt[OPT_BLACK_LEVEL].title = SANE_TITLE_BLACK_LEVEL; 2775 s->opt[OPT_BLACK_LEVEL].desc = SANE_DESC_BLACK_LEVEL; 2776 s->opt[OPT_BLACK_LEVEL].type = SANE_TYPE_INT; 2777 s->opt[OPT_BLACK_LEVEL].unit = SANE_UNIT_NONE; 2778 s->opt[OPT_BLACK_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE; 2779 s->opt[OPT_BLACK_LEVEL].constraint.range = &blacklevel_range; 2780 s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE; 2781 s->val[OPT_BLACK_LEVEL].w = 127; 2782 2783 s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; 2784 s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; 2785 s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; 2786 s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; 2787 s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; 2788 s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; 2789 s->opt[OPT_RESOLUTION].constraint.word_list = resbit_list; 2790 s->val[OPT_RESOLUTION].w = resbit_list[1]; 2791 2792 /* "Enhancement" group: */ 2793 s->opt[OPT_ENHANCEMENT_GROUP].name = "enhancement-group"; 2794 s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); 2795 s->opt[OPT_ENHANCEMENT_GROUP].desc = ""; 2796 s->opt[OPT_ENHANCEMENT_GROUP].size = 0; 2797 s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; 2798 s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; 2799 s->opt[OPT_ENHANCEMENT_GROUP].cap = 0; 2800 2801 /* brightness */ 2802 s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; 2803 s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; 2804 s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; 2805 s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; 2806 s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; 2807 s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; 2808 s->opt[OPT_BRIGHTNESS].constraint.range = &brightness_contrast_range; 2809 s->val[OPT_BRIGHTNESS].w = 0; 2810 2811 /* contrast */ 2812 s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; 2813 s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; 2814 s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; 2815 s->opt[OPT_CONTRAST].type = SANE_TYPE_INT; 2816 s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; 2817 s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; 2818 s->opt[OPT_CONTRAST].constraint.range = &brightness_contrast_range; 2819 s->val[OPT_CONTRAST].w = 0; 2820 2821 /* master analog gamma */ 2822 s->opt[OPT_GAMMA].name = SANE_NAME_ANALOG_GAMMA; 2823 s->opt[OPT_GAMMA].title = SANE_TITLE_ANALOG_GAMMA; 2824 s->opt[OPT_GAMMA].desc = SANE_DESC_ANALOG_GAMMA; 2825 s->opt[OPT_GAMMA].type = SANE_TYPE_FIXED; 2826 s->opt[OPT_GAMMA].unit = SANE_UNIT_NONE; 2827 s->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_RANGE; 2828 s->opt[OPT_GAMMA].constraint.range = &gamma_range; 2829 s->val[OPT_GAMMA].w = SANE_FIX (s->dev->gamma_master); 2830 s->opt[OPT_GAMMA].size = sizeof (SANE_Word); 2831 2832 /* red analog gamma */ 2833 s->opt[OPT_GAMMA_R].name = SANE_NAME_ANALOG_GAMMA_R; 2834 s->opt[OPT_GAMMA_R].title = SANE_TITLE_ANALOG_GAMMA_R; 2835 s->opt[OPT_GAMMA_R].desc = SANE_DESC_ANALOG_GAMMA_R; 2836 s->opt[OPT_GAMMA_R].type = SANE_TYPE_FIXED; 2837 s->opt[OPT_GAMMA_R].unit = SANE_UNIT_NONE; 2838 s->opt[OPT_GAMMA_R].constraint_type = SANE_CONSTRAINT_RANGE; 2839 s->opt[OPT_GAMMA_R].constraint.range = &gamma_range; 2840 s->val[OPT_GAMMA_R].w = SANE_FIX (s->dev->gamma_r); 2841 2842 /* green analog gamma */ 2843 s->opt[OPT_GAMMA_G].name = SANE_NAME_ANALOG_GAMMA_G; 2844 s->opt[OPT_GAMMA_G].title = SANE_TITLE_ANALOG_GAMMA_G; 2845 s->opt[OPT_GAMMA_G].desc = SANE_DESC_ANALOG_GAMMA_G; 2846 s->opt[OPT_GAMMA_G].type = SANE_TYPE_FIXED; 2847 s->opt[OPT_GAMMA_G].unit = SANE_UNIT_NONE; 2848 s->opt[OPT_GAMMA_G].constraint_type = SANE_CONSTRAINT_RANGE; 2849 s->opt[OPT_GAMMA_G].constraint.range = &gamma_range; 2850 s->val[OPT_GAMMA_G].w = SANE_FIX (s->dev->gamma_g); 2851 2852 /* blue analog gamma */ 2853 s->opt[OPT_GAMMA_B].name = SANE_NAME_ANALOG_GAMMA_B; 2854 s->opt[OPT_GAMMA_B].title = SANE_TITLE_ANALOG_GAMMA_B; 2855 s->opt[OPT_GAMMA_B].desc = SANE_DESC_ANALOG_GAMMA_B; 2856 s->opt[OPT_GAMMA_B].type = SANE_TYPE_FIXED; 2857 s->opt[OPT_GAMMA_B].unit = SANE_UNIT_NONE; 2858 s->opt[OPT_GAMMA_B].constraint_type = SANE_CONSTRAINT_RANGE; 2859 s->opt[OPT_GAMMA_B].constraint.range = &gamma_range; 2860 s->val[OPT_GAMMA_B].w = SANE_FIX (s->dev->gamma_b); 2861 2862 s->opt[OPT_DEFAULT_ENHANCEMENTS].name = "default-enhancements"; 2863 s->opt[OPT_DEFAULT_ENHANCEMENTS].title = SANE_I18N ("Defaults"); 2864 s->opt[OPT_DEFAULT_ENHANCEMENTS].desc = 2865 SANE_I18N ("Set default values for enhancement controls."); 2866 s->opt[OPT_DEFAULT_ENHANCEMENTS].size = 0; 2867 s->opt[OPT_DEFAULT_ENHANCEMENTS].type = SANE_TYPE_BUTTON; 2868 s->opt[OPT_DEFAULT_ENHANCEMENTS].unit = SANE_UNIT_NONE; 2869 s->opt[OPT_DEFAULT_ENHANCEMENTS].constraint_type = SANE_CONSTRAINT_NONE; 2870 2871 /* "Geometry" group: */ 2872 s->opt[OPT_GEOMETRY_GROUP].name = "geometry-group"; 2873 s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); 2874 s->opt[OPT_GEOMETRY_GROUP].desc = ""; 2875 s->opt[OPT_GEOMETRY_GROUP].size = 0; 2876 s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; 2877 s->opt[OPT_GEOMETRY_GROUP].cap = 0; 2878 2879 /* top-left x */ 2880 s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; 2881 s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; 2882 s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; 2883 s->opt[OPT_TL_X].type = SANE_TYPE_FIXED; 2884 s->opt[OPT_TL_X].unit = SANE_UNIT_MM; 2885 s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; 2886 s->opt[OPT_TL_X].constraint.range = &scan_range_x; 2887 s->val[OPT_TL_X].w = SANE_FIX (0.0); 2888 2889 /* top-left y */ 2890 s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; 2891 s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; 2892 s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; 2893 s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; 2894 s->opt[OPT_TL_Y].unit = SANE_UNIT_MM; 2895 s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; 2896 s->opt[OPT_TL_Y].constraint.range = &scan_range_y; 2897 s->val[OPT_TL_Y].w = SANE_FIX (0.0); 2898 2899 /* bottom-right x */ 2900 s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; 2901 s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; 2902 s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; 2903 s->opt[OPT_BR_X].type = SANE_TYPE_FIXED; 2904 s->opt[OPT_BR_X].unit = SANE_UNIT_MM; 2905 s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; 2906 s->opt[OPT_BR_X].constraint.range = &scan_range_x; 2907 s->val[OPT_BR_X].w = SANE_FIX (50.0); 2908 2909 /* bottom-right y */ 2910 s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; 2911 s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; 2912 s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; 2913 s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; 2914 s->opt[OPT_BR_Y].unit = SANE_UNIT_MM; 2915 s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; 2916 s->opt[OPT_BR_Y].constraint.range = &scan_range_y; 2917 s->val[OPT_BR_Y].w = SANE_FIX (50.0); 2918 2919 /* "Calibration" group: */ 2920 s->opt[OPT_CALIBRATION_GROUP].name = "calibration-group"; 2921 s->opt[OPT_CALIBRATION_GROUP].title = SANE_I18N ("Calibration"); 2922 s->opt[OPT_CALIBRATION_GROUP].desc = ""; 2923 s->opt[OPT_CALIBRATION_GROUP].size = 0; 2924 s->opt[OPT_CALIBRATION_GROUP].type = SANE_TYPE_GROUP; 2925 s->opt[OPT_CALIBRATION_GROUP].constraint_type = SANE_CONSTRAINT_NONE; 2926 s->opt[OPT_CALIBRATION_GROUP].cap = 0; 2927 2928 /* calibrate */ 2929 s->opt[OPT_CALIBRATE].name = "calibration"; 2930 s->opt[OPT_CALIBRATE].title = SANE_I18N ("Calibrate before next scan"); 2931 s->opt[OPT_CALIBRATE].desc = 2932 SANE_I18N ("If enabled, the device will be calibrated before the " 2933 "next scan. Otherwise, calibration is performed " 2934 "only before the first start."); 2935 s->opt[OPT_CALIBRATE].type = SANE_TYPE_BOOL; 2936 s->opt[OPT_CALIBRATE].unit = SANE_UNIT_NONE; 2937 s->opt[OPT_CALIBRATE].constraint_type = SANE_CONSTRAINT_NONE; 2938 s->val[OPT_CALIBRATE].w = SANE_FALSE; 2939 2940 /* calibrate */ 2941 s->opt[OPT_CALIBRATE_SHADING].name = "calibration-shading"; 2942 s->opt[OPT_CALIBRATE_SHADING].title = 2943 SANE_I18N ("Only perform shading-correction"); 2944 s->opt[OPT_CALIBRATE_SHADING].desc = 2945 SANE_I18N ("If enabled, only the shading correction is " 2946 "performed during calibration. The default values " 2947 "for gain, offset and exposure time, " 2948 "either built-in or from the configuration file, " 2949 "are used."); 2950 s->opt[OPT_CALIBRATE_SHADING].type = SANE_TYPE_BOOL; 2951 s->opt[OPT_CALIBRATE_SHADING].unit = SANE_UNIT_NONE; 2952 s->opt[OPT_CALIBRATE_SHADING].constraint_type = SANE_CONSTRAINT_NONE; 2953 s->val[OPT_CALIBRATE_SHADING].w = SANE_FALSE; 2954#ifdef ARTEC48U_USE_BUTTONS 2955 s->opt[OPT_BUTTON_STATE].name = "button-state"; 2956 s->opt[OPT_BUTTON_STATE].title = SANE_I18N ("Button state"); 2957 s->opt[OPT_BUTTON_STATE].type = SANE_TYPE_INT; 2958 s->opt[OPT_BUTTON_STATE].unit = SANE_UNIT_NONE; 2959 s->opt[OPT_BUTTON_STATE].constraint_type = SANE_CONSTRAINT_NONE; 2960 s->opt[OPT_BUTTON_STATE].cap = SANE_CAP_SOFT_DETECT; 2961 s->val[OPT_BUTTON_STATE].w = 0; 2962#endif 2963 return SANE_STATUS_GOOD; 2964} 2965 2966static void 2967calculate_brightness (Artec48U_Scanner * s) 2968{ 2969 long cnt; 2970 double bright; 2971 2972 bright = (double) s->val[OPT_BRIGHTNESS].w; 2973 2974 bright *= 257.0; 2975 for (cnt = 0; cnt < 65536; cnt++) 2976 { 2977 if (bright < 0.0) 2978 s->brightness_array[cnt] = 2979 (int) (((double) cnt * (65535.0 + bright)) / 65535.0); 2980 else 2981 s->brightness_array[cnt] = 2982 (int) ((double) cnt + 2983 ((65535.0 - (double) cnt) * bright) / 65535.0); 2984 if (s->brightness_array[cnt] > 65535) 2985 s->brightness_array[cnt] = 65535; 2986 if (s->brightness_array[cnt] < 0) 2987 s->brightness_array[cnt] = 0; 2988 } 2989} 2990 2991static void 2992calculate_contrast (Artec48U_Scanner * s) 2993{ 2994 int val; 2995 double p; 2996 int cnt; 2997 double contr; 2998 2999 contr = (double) s->val[OPT_CONTRAST].w; 3000 3001 contr *= 257.0; 3002 3003 for (cnt = 0; cnt < 65536; cnt++) 3004 { 3005 if (contr < 0.0) 3006 { 3007 val = (int) (cnt > 32769) ? (65535 - cnt) : cnt; 3008 val = (int) (32769.0 * pow ((double) (val ? val : 1) / 32769.0, 3009 (32769.0 + contr) / 32769.0)); 3010 s->contrast_array[cnt] = (cnt > 32769) ? (65535 - val) : val; 3011 if (s->contrast_array[cnt] > 65535) 3012 s->contrast_array[cnt] = 65535; 3013 if (s->contrast_array[cnt] < 0) 3014 s->contrast_array[cnt] = 0; 3015 } 3016 else 3017 { 3018 val = (cnt > 32769) ? (65535 - cnt) : cnt; 3019 p = ((int) contr == 32769) ? 32769.0 : 32769.0 / (32769.0 - contr); 3020 val = (int) (32769.0 * pow ((double) val / 32769.0, p)); 3021 s->contrast_array[cnt] = (cnt > 32639) ? (65535 - val) : val; 3022 if (s->contrast_array[cnt] > 65535) 3023 s->contrast_array[cnt] = 65535; 3024 if (s->contrast_array[cnt] < 0) 3025 s->contrast_array[cnt] = 0; 3026 } 3027 } 3028} 3029 3030/* 3031 The calibration function 3032 Disclaimer: the following might be complete crap :-) 3033 -Gain, offset, exposure time 3034 It seems, that the gain values are actually constants. The windows driver always 3035 uses the values 0x0a,0x03,0x03, during calibration as well as during a normal 3036 scan. The exposure values are set to 0x04 for black calibration. It's not necessary to 3037 move the scan head during this stage. 3038 Calibration starts with default values for offset/exposure. These values are 3039 increased/decreased until the white and black values are within a specific range, defined 3040 by WHITE_MIN, WHITE_MAX, BLACK_MIN and BLACK_MAX. 3041 3042 -White shading correction 3043 The scanning head is moved some lines over the calibration strip. Some lines 3044 are scanned at 600dpi/16bit over the full width. The average values are used for the 3045 shading buffer. The normal exposure values are used. 3046 -Black shading correction 3047 Works like the white shading correction, with the difference, that the red-, green- 3048 and blue exposure time is set to 0x04 (the value is taken from the windoze driver). 3049 -Since we do this over the whole width of the image with the maximal optical resolution, 3050 we can use the shading data for every scan, independent of the size, position or resolution, 3051 because we have the shading values for every sensor/LED. 3052 3053 Note: 3054 For a CIS device, it's sufficient to determine those values once. It's not necessary, to 3055 repeat the calibration sequence before every new scan. The windoze driver even saves the values 3056 to various files to avoid the quite lengthy calibration sequence. This backend can also save 3057 the values to files. For this purpose, the user has to create a hidden directory called 3058 .artec-eplus48u in his/her home directory. If the user insists on calibration 3059 before every new scan, he/she can enable a specific option in the backend. 3060*/ 3061static SANE_Status 3062calibrate_scanner (SANE_Handle handle) 3063{ 3064 Artec48U_Scanner *s = handle; 3065 unsigned int *buffer_pointers[3]; 3066 int avg_black[3]; 3067 int avg_white[3]; 3068 int exp_off; 3069 int c; 3070 int finish = 0; 3071 int noloop = 0; 3072 3073 3074 if ((s->val[OPT_CALIBRATE].w == SANE_TRUE) && 3075 (s->val[OPT_CALIBRATE_SHADING].w == SANE_FALSE)) 3076 { 3077 while (finish == 0) 3078 { 3079 finish = 1; 3080 /*get black values */ 3081 artec48u_carriage_home (s->dev); 3082 3083 artec48u_wait_for_positioning (s->dev); 3084 s->reader = NULL; 3085 3086 s->scanning = SANE_TRUE; 3087 3088 init_shading_buffer (s); 3089 3090 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_BLACK, 3091 SANE_FALSE, &(s->params)); 3092 artec48u_scanner_start_scan_extended (s, &(s->request), 3093 SA_CALIBRATE_SCAN_OFFSET_1, 3094 &(s->params)); 3095 3096 for (c = 0; c < s->dev->shading_lines_b; c++) 3097 { 3098 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE); 3099 /* we abuse the shading buffer for the offset calculation */ 3100 add_to_shading_buffer (s, buffer_pointers); 3101 } 3102 artec48u_scanner_stop_scan (s); 3103 finish_offset_buffer (s, &avg_black[0], &avg_black[1], 3104 &avg_black[2]); 3105 s->scanning = SANE_FALSE; 3106 XDBG ((1, "avg_r: %i, avg_g: %i, avg_b: %i\n", avg_black[0], 3107 avg_black[1], avg_black[2])); 3108 /*adjust offset */ 3109 for (c = 0; c < 3; c++) 3110 { 3111 if (c == 0) 3112 { 3113 if (avg_black[c] < BLACK_MIN) 3114 { 3115 s->dev->afe_params.r_offset -= 1; 3116 finish = 0; 3117 XDBG ((1, "adjust offset r: -1\n")); 3118 } 3119 else if (avg_black[c] > BLACK_MAX) 3120 { 3121 s->dev->afe_params.r_offset += 1; 3122 finish = 0; 3123 XDBG ((1, "adjust offset r: +1\n")); 3124 } 3125 } 3126 if (c == 1) 3127 { 3128 if (avg_black[c] < BLACK_MIN) 3129 { 3130 s->dev->afe_params.g_offset -= 1; 3131 finish = 0; 3132 XDBG ((1, "adjust offset g: -1\n")); 3133 } 3134 else if (avg_black[c] > BLACK_MAX) 3135 { 3136 s->dev->afe_params.g_offset += 1; 3137 finish = 0; 3138 XDBG ((1, "adjust offset g: +1\n")); 3139 } 3140 } 3141 if (c == 2) 3142 { 3143 if (avg_black[c] < BLACK_MIN) 3144 { 3145 s->dev->afe_params.b_offset -= 1; 3146 finish = 0; 3147 XDBG ((1, "adjust offset b: -1\n")); 3148 } 3149 else if (avg_black[c] > BLACK_MAX) 3150 { 3151 s->dev->afe_params.b_offset += 1; 3152 finish = 0; 3153 XDBG ((1, "adjust offset b: +1\n")); 3154 } 3155 } 3156 } 3157 3158 /*adjust exposure */ 3159 /*get white values */ 3160 3161 artec48u_carriage_home (s->dev); 3162 3163 artec48u_wait_for_positioning (s->dev); 3164 s->reader = NULL; 3165 3166 s->scanning = SANE_TRUE; 3167 3168 init_shading_buffer (s); 3169 3170 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_WHITE, 3171 SANE_FALSE, &(s->params)); 3172 artec48u_scanner_start_scan_extended (s, &(s->request), 3173 SA_CALIBRATE_SCAN_EXPOSURE_1, 3174 &(s->params)); 3175 3176 for (c = 0; c < s->dev->shading_lines_w; c++) 3177 { 3178 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE); 3179 /* we abuse the shading buffer for the exposure calculation */ 3180 add_to_shading_buffer (s, buffer_pointers); 3181 } 3182 artec48u_scanner_stop_scan (s); 3183 finish_exposure_buffer (s, &avg_white[0], &avg_white[1], 3184 &avg_white[2]); 3185 s->scanning = SANE_FALSE; 3186 XDBG ((1, "avg_r: %i, avg_g: %i, avg_b: %i\n", avg_white[0], 3187 avg_white[1], avg_white[2])); 3188 for (c = 0; c < 3; c++) 3189 { 3190 if (c == 0) 3191 { 3192 if (avg_white[c] < WHITE_MIN) 3193 { 3194 exp_off = 3195 ((WHITE_MAX + WHITE_MIN) / 2 - 3196 avg_white[c]) / EXPOSURE_STEP; 3197 if (exp_off < 1) 3198 exp_off = 1; 3199 s->dev->exp_params.r_time += exp_off; 3200 finish = 0; 3201 XDBG ((1, "adjust exposure r: ++\n")); 3202 } 3203 else if (avg_white[c] > WHITE_MAX) 3204 { 3205 exp_off = 3206 (avg_white[c] - 3207 (WHITE_MAX + WHITE_MIN) / 2) / EXPOSURE_STEP; 3208 if (exp_off < 1) 3209 exp_off = 1; 3210 s->dev->exp_params.r_time -= exp_off; 3211 finish = 0; 3212 XDBG ((1, "adjust exposure r: --\n")); 3213 } 3214 } 3215 else if (c == 1) 3216 { 3217 if (avg_white[c] < WHITE_MIN) 3218 { 3219 exp_off = 3220 ((WHITE_MAX + WHITE_MIN) / 2 - 3221 avg_white[c]) / EXPOSURE_STEP; 3222 if (exp_off < 1) 3223 exp_off = 1; 3224 s->dev->exp_params.g_time += exp_off; 3225 finish = 0; 3226 XDBG ((1, "adjust exposure g: ++\n")); 3227 } 3228 else if (avg_white[c] > WHITE_MAX) 3229 { 3230 exp_off = 3231 (avg_white[c] - 3232 (WHITE_MAX + WHITE_MIN) / 2) / EXPOSURE_STEP; 3233 if (exp_off < 1) 3234 exp_off = 1; 3235 s->dev->exp_params.g_time -= exp_off; 3236 finish = 0; 3237 XDBG ((1, "adjust exposure g: --\n")); 3238 } 3239 } 3240 else if (c == 2) 3241 { 3242 if (avg_white[c] < WHITE_MIN) 3243 { 3244 exp_off = 3245 ((WHITE_MAX + WHITE_MIN) / 2 - 3246 avg_white[c]) / EXPOSURE_STEP; 3247 if (exp_off < 1) 3248 exp_off = 1; 3249 s->dev->exp_params.b_time += exp_off; 3250 finish = 0; 3251 XDBG ((1, "adjust exposure b: ++\n")); 3252 } 3253 else if (avg_white[c] > WHITE_MAX) 3254 { 3255 exp_off = 3256 (avg_white[c] - 3257 (WHITE_MAX + WHITE_MIN) / 2) / EXPOSURE_STEP; 3258 if (exp_off < 1) 3259 exp_off = 1; 3260 s->dev->exp_params.b_time -= exp_off; 3261 finish = 0; 3262 XDBG ((1, "adjust exposure b: --\n")); 3263 } 3264 } 3265 } 3266 3267 XDBG ((1, "time_r: %x, time_g: %x, time_b: %x\n", 3268 s->dev->exp_params.r_time, s->dev->exp_params.g_time, 3269 s->dev->exp_params.b_time)); 3270 XDBG ((1, "offset_r: %x, offset_g: %x, offset_b: %x\n", 3271 s->dev->afe_params.r_offset, s->dev->afe_params.g_offset, 3272 s->dev->afe_params.b_offset)); 3273 ++noloop; 3274 if (noloop > 10) 3275 break; 3276 } 3277 } 3278 3279 XDBG ((1, "option redOffset 0x%x\n", s->dev->afe_params.r_offset)); 3280 XDBG ((1, "option greenOffset 0x%x\n", s->dev->afe_params.g_offset)); 3281 XDBG ((1, "option blueOffset 0x%x\n", s->dev->afe_params.b_offset)); 3282 XDBG ((1, "option redExposure 0x%x\n", s->dev->exp_params.r_time)); 3283 XDBG ((1, "option greenExposure 0x%x\n", s->dev->exp_params.g_time)); 3284 XDBG ((1, "option blueExposure 0x%x\n", s->dev->exp_params.b_time)); 3285 3286 s->dev->artec_48u_afe_params.r_offset = s->dev->afe_params.r_offset; 3287 s->dev->artec_48u_afe_params.g_offset = s->dev->afe_params.g_offset; 3288 s->dev->artec_48u_afe_params.b_offset = s->dev->afe_params.b_offset; 3289 /*don't forget the gain */ 3290 s->dev->artec_48u_afe_params.r_pga = s->dev->afe_params.r_pga; 3291 s->dev->artec_48u_afe_params.g_pga = s->dev->afe_params.g_pga; 3292 s->dev->artec_48u_afe_params.b_pga = s->dev->afe_params.b_pga; 3293 3294 s->dev->artec_48u_exposure_params.r_time = s->dev->exp_params.r_time; 3295 s->dev->artec_48u_exposure_params.g_time = s->dev->exp_params.g_time; 3296 s->dev->artec_48u_exposure_params.b_time = s->dev->exp_params.b_time; 3297 3298 /******************************* 3299 *get the black shading values * 3300 *******************************/ 3301 artec48u_carriage_home (s->dev); 3302 3303 artec48u_wait_for_positioning (s->dev); 3304 s->reader = NULL; 3305 3306 s->scanning = SANE_TRUE; 3307 3308 init_shading_buffer (s); 3309 3310 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_BLACK, SANE_FALSE, 3311 &(s->params)); 3312 artec48u_scanner_start_scan_extended (s, &(s->request), 3313 SA_CALIBRATE_SCAN_BLACK, 3314 &(s->params)); 3315 3316 for (c = 0; c < s->dev->shading_lines_b; c++) 3317 { 3318 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE); 3319 add_to_shading_buffer (s, buffer_pointers); 3320 } 3321 artec48u_scanner_stop_scan (s); 3322 finish_shading_buffer (s, SANE_FALSE); 3323 s->scanning = SANE_FALSE; 3324 3325 /******************************* 3326 *get the white shading values * 3327 *******************************/ 3328 artec48u_carriage_home (s->dev); 3329 3330 artec48u_wait_for_positioning (s->dev); 3331 s->reader = NULL; 3332 s->scanning = SANE_TRUE; 3333 3334 init_shading_buffer (s); 3335 3336 artec48u_setup_scan (s, &(s->request), SA_CALIBRATE_SCAN_WHITE, SANE_FALSE, 3337 &(s->params)); 3338 artec48u_scanner_start_scan_extended (s, &(s->request), 3339 SA_CALIBRATE_SCAN_WHITE, 3340 &(s->params)); 3341 for (c = 0; c < s->dev->shading_lines_w; c++) 3342 { 3343 artec48u_scanner_read_line (s, buffer_pointers, SANE_FALSE); 3344 add_to_shading_buffer (s, buffer_pointers); 3345 } 3346 artec48u_scanner_stop_scan (s); 3347 finish_shading_buffer (s, SANE_TRUE); 3348 s->scanning = SANE_FALSE; 3349 save_calibration_data (s); 3350 return SANE_STATUS_GOOD; 3351} 3352 3353static SANE_Status 3354close_pipe (Artec48U_Scanner * s) 3355{ 3356 if (s->pipe >= 0) 3357 { 3358 XDBG ((1, "close_pipe\n")); 3359 close (s->pipe); 3360 s->pipe = -1; 3361 } 3362 return SANE_STATUS_EOF; 3363} 3364static void 3365sigalarm_handler (int __sane_unused__ signal) 3366{ 3367 XDBG ((1, "ALARM!!!\n")); 3368 cancelRead = SANE_TRUE; 3369} 3370 3371static void 3372sig_chldhandler (int signo) 3373{ 3374 XDBG ((1, "Child is down (signal=%d)\n", signo)); 3375} 3376 3377static int 3378reader_process (void * data) 3379{ 3380 Artec48U_Scanner * s = (Artec48U_Scanner *) data; 3381 int fd = s->reader_pipe; 3382 3383 SANE_Status status; 3384 struct SIGACTION act; 3385 sigset_t ignore_set; 3386 ssize_t bytes_written = 0; 3387 3388 XDBG ((1, "reader process...\n")); 3389 3390 if (sanei_thread_is_forked()) close (s->pipe); 3391 3392 sigfillset (&ignore_set); 3393 sigdelset (&ignore_set, SIGTERM); 3394 sigdelset (&ignore_set, SIGUSR1); 3395#if defined (__APPLE__) && defined (__MACH__) 3396 sigdelset (&ignore_set, SIGUSR2); 3397#endif 3398 sigprocmask (SIG_SETMASK, &ignore_set, 0); 3399 3400 memset (&act, 0, sizeof (act)); 3401 sigaction (SIGTERM, &act, 0); 3402 sigaction (SIGUSR1, &act, 0); 3403 3404 cancelRead = SANE_FALSE; 3405 if (sigemptyset (&(act.sa_mask)) < 0) 3406 XDBG ((2, "(child) reader_process: sigemptyset() failed\n")); 3407 act.sa_flags = 0; 3408 3409 act.sa_handler = reader_process_sigterm_handler; 3410 if (sigaction (SIGTERM, &act, 0) < 0) 3411 XDBG ((2, "(child) reader_process: sigaction(SIGTERM,...) failed\n")); 3412 3413 act.sa_handler = usb_reader_process_sigterm_handler; 3414 if (sigaction (SIGUSR1, &act, 0) < 0) 3415 XDBG ((2, "(child) reader_process: sigaction(SIGUSR1,...) failed\n")); 3416 3417 3418 XDBG ((2, "(child) reader_process: s=%p, fd=%d\n", (void *) s, fd)); 3419 3420 /*read line by line into buffer */ 3421 /*copy buffer pointers to line_buffer */ 3422 XDBG ((2, "(child) reader_process: byte_cnt %d\n", (int) s->byte_cnt)); 3423 s->eof = SANE_FALSE; 3424 while (s->lines_to_read > 0) 3425 { 3426 if (cancelRead == SANE_TRUE) 3427 { 3428 XDBG ((2, "(child) reader_process: cancelRead == SANE_TRUE\n")); 3429 s->scanning = SANE_FALSE; 3430 s->eof = SANE_FALSE; 3431 return SANE_STATUS_CANCELLED; 3432 } 3433 if (s->scanning != SANE_TRUE) 3434 { 3435 XDBG ((2, "(child) reader_process: scanning != SANE_TRUE\n")); 3436 return SANE_STATUS_CANCELLED; 3437 } 3438 status = artec48u_scanner_read_line (s, s->buffer_pointers, SANE_TRUE); 3439 if (status != SANE_STATUS_GOOD) 3440 { 3441 XDBG ((2, "(child) reader_process: scanner_read_line failed\n")); 3442 return SANE_STATUS_IO_ERROR; 3443 } 3444 copy_scan_line (s); 3445 s->lines_to_read -= 1; 3446 bytes_written = 3447 write (fd, s->line_buffer, s->sane_params.bytes_per_line); 3448 3449 if (bytes_written < 0) 3450 { 3451 XDBG ((2, "(child) reader_process: write returned %s\n", 3452 strerror (errno))); 3453 s->eof = SANE_FALSE; 3454 return SANE_STATUS_IO_ERROR; 3455 } 3456 3457 XDBG ((2, "(child) reader_process: lines to read %i\n", s->lines_to_read)); 3458 } 3459 s->eof = SANE_TRUE; 3460 close (fd); 3461 return SANE_STATUS_GOOD; 3462} 3463 3464static SANE_Status 3465do_cancel (Artec48U_Scanner * s, SANE_Bool closepipe) 3466{ 3467 struct SIGACTION act; 3468 SANE_Pid res; 3469 XDBG ((1, "do_cancel\n")); 3470 3471 s->scanning = SANE_FALSE; 3472 3473 if (sanei_thread_is_valid (s->reader_pid)) 3474 { 3475 /*parent */ 3476 XDBG ((1, "killing reader_process\n")); 3477 /* tell the driver to stop scanning */ 3478 sigemptyset (&(act.sa_mask)); 3479 act.sa_flags = 0; 3480 3481 act.sa_handler = sigalarm_handler; 3482 3483 if (sigaction (SIGALRM, &act, 0) == -1) 3484 XDBG ((1, "sigaction() failed !\n")); 3485 3486 /* kill our child process and wait until done */ 3487 alarm (10); 3488 if (sanei_thread_kill (s->reader_pid) < 0) 3489 XDBG ((1, "sanei_thread_kill() failed !\n")); 3490 res = sanei_thread_waitpid (s->reader_pid, 0); 3491 alarm (0); 3492 3493 if (res != s->reader_pid) 3494 { 3495 XDBG ((1, "sanei_thread_waitpid() failed !\n")); 3496 } 3497 sanei_thread_invalidate (s->reader_pid); 3498 XDBG ((1, "reader_process killed\n")); 3499 } 3500 if (SANE_TRUE == closepipe) 3501 { 3502 close_pipe (s); 3503 XDBG ((1, "pipe closed\n")); 3504 } 3505 artec48u_scanner_stop_scan (s); 3506 artec48u_carriage_home (s->dev); 3507 if (s->line_buffer) 3508 { 3509 XDBG ((2, "freeing line_buffer\n")); 3510 free (s->line_buffer); 3511 s->line_buffer = NULL; 3512 } 3513 if (s->lineart_buffer) 3514 { 3515 XDBG ((2, "freeing lineart_buffer\n")); 3516 free (s->lineart_buffer); 3517 s->lineart_buffer = NULL; 3518 } 3519 3520 return SANE_STATUS_CANCELLED; 3521} 3522 3523SANE_Status 3524sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) 3525{ 3526 static const SANE_Device **devlist = 0; 3527 Artec48U_Device *dev; 3528 SANE_Int dev_num; 3529 3530 XDBG ((5, "sane_get_devices: start: local_only = %s\n", 3531 local_only == SANE_TRUE ? "true" : "false")); 3532 3533 if (devlist) 3534 free (devlist); 3535 3536 devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); 3537 if (!devlist) 3538 return SANE_STATUS_NO_MEM; 3539 3540 dev_num = 0; 3541 for (dev = first_dev; dev_num < num_devices; dev = dev->next) 3542 { 3543 devlist[dev_num] = &dev->sane; 3544 XDBG ((3, "sane_get_devices: name %s\n", dev->sane.name)); 3545 XDBG ((3, "sane_get_devices: vendor %s\n", dev->sane.vendor)); 3546 XDBG ((3, "sane_get_devices: model %s\n", dev->sane.model)); 3547 ++dev_num; 3548 } 3549 devlist[dev_num] = 0; 3550 ++dev_num; 3551 3552 *device_list = devlist; 3553 3554 XDBG ((5, "sane_get_devices: exit\n")); 3555 3556 return SANE_STATUS_GOOD; 3557} 3558 3559static SANE_Status 3560load_calibration_data (Artec48U_Scanner * s) 3561{ 3562 SANE_Status status = SANE_STATUS_GOOD; 3563 FILE *f = 0; 3564 size_t cnt; 3565 char path[PATH_MAX]; 3566 char filename[PATH_MAX]; 3567 3568 s->calibrated = SANE_FALSE; 3569 path[0] = 0; 3570 3571 /* return SANE_STATUS_INVAL if HOME environment variable is not set */ 3572 if (getenv ("HOME") == NULL) 3573 { 3574 XDBG ((1, "Environment variable HOME not set\n")); 3575 return SANE_STATUS_INVAL; 3576 } 3577 3578 if (strlen (getenv ("HOME")) < (PATH_MAX - 1)) 3579 strcat (path, getenv ("HOME")); 3580 else 3581 return SANE_STATUS_INVAL; 3582 3583 if (strlen (path) < (PATH_MAX - 1 - strlen ("/.artec_eplus48u/"))) 3584 strcat (path, "/.artec_eplus48u/"); 3585 else 3586 return SANE_STATUS_INVAL; 3587 3588 /*try to load black shading file */ 3589 strcpy (filename, path); 3590 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_black"))) 3591 strcat (filename, "artec48ushading_black"); 3592 else 3593 return SANE_STATUS_INVAL; 3594 XDBG ((1, "Try to read black shading file: \"%s\"\n", filename)); 3595 3596 f = fopen (filename, "rb"); 3597 if (!f) 3598 return SANE_STATUS_INVAL; 3599 3600 /*read values */ 3601 cnt = fread (s->shading_buffer_b, sizeof (unsigned char), 30720*s->dev->epro_mult, f); /*epro*/ 3602 if (cnt != (30720*s->dev->epro_mult)) /*epro*/ 3603 { 3604 fclose (f); 3605 XDBG ((1, "Could not load black shading file\n")); 3606 return SANE_STATUS_INVAL; 3607 } 3608 fclose (f); 3609 3610 /*try to load white shading file */ 3611 strcpy (filename, path); 3612 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_white"))) 3613 strcat (filename, "artec48ushading_white"); 3614 else 3615 return SANE_STATUS_INVAL; 3616 XDBG ((1, "Try to read white shading file: \"%s\"\n", filename)); 3617 f = fopen (filename, "rb"); 3618 if (!f) 3619 return SANE_STATUS_INVAL; 3620 /*read values */ 3621 cnt = fread (s->shading_buffer_w, sizeof (unsigned char), 30720*s->dev->epro_mult, f);/*epro*/ 3622 if (cnt != (30720*s->dev->epro_mult)) /*epro*/ 3623 { 3624 fclose (f); 3625 XDBG ((1, "Could not load white shading file\n")); 3626 return SANE_STATUS_INVAL; 3627 } 3628 fclose (f); 3629 3630 /*try to load offset file */ 3631 strcpy (filename, path); 3632 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uoffset"))) 3633 strcat (filename, "artec48uoffset"); 3634 else 3635 return SANE_STATUS_INVAL; 3636 XDBG ((1, "Try to read offset file: \"%s\"\n", filename)); 3637 f = fopen (filename, "rb"); 3638 if (!f) 3639 return SANE_STATUS_INVAL; 3640 /*read values */ 3641 cnt = 3642 fread (&s->dev->artec_48u_afe_params, sizeof (Artec48U_AFE_Parameters), 1, 3643 f); 3644 if (cnt != 1) 3645 { 3646 fclose (f); 3647 XDBG ((1, "Could not load offset file\n")); 3648 return SANE_STATUS_INVAL; 3649 } 3650 fclose (f); 3651 3652 /*load exposure file */ 3653 strcpy (filename, path); 3654 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uexposure"))) 3655 strcat (filename, "artec48uexposure"); 3656 else 3657 return SANE_STATUS_INVAL; 3658 XDBG ((1, "Try to read exposure file: \"%s\"\n", filename)); 3659 f = fopen (filename, "rb"); 3660 if (!f) 3661 return SANE_STATUS_INVAL; 3662 /*read values */ 3663 cnt = 3664 fread (&s->dev->artec_48u_exposure_params, 3665 sizeof (Artec48U_Exposure_Parameters), 1, f); 3666 if (cnt != 1) 3667 { 3668 fclose (f); 3669 XDBG ((1, "Could not load exposure file\n")); 3670 return SANE_STATUS_INVAL; 3671 } 3672 fclose (f); 3673 s->calibrated = SANE_TRUE; 3674 return status; 3675} 3676 3677static SANE_Status 3678save_calibration_data (Artec48U_Scanner * s) 3679{ 3680 SANE_Status status = SANE_STATUS_GOOD; 3681 FILE *f = 0; 3682 size_t cnt; 3683 char path[PATH_MAX]; 3684 char filename[PATH_MAX]; 3685 mode_t mode = S_IRUSR | S_IWUSR; 3686 3687 path[0] = 0; 3688 3689 /* return SANE_STATUS_INVAL if HOME environment variable is not set */ 3690 if (getenv ("HOME") == NULL) 3691 { 3692 XDBG ((1, "Environment variable HOME not set\n")); 3693 return SANE_STATUS_INVAL; 3694 } 3695 3696 if (strlen (getenv ("HOME")) < (PATH_MAX - 1)) 3697 strcat (path, getenv ("HOME")); 3698 else 3699 return SANE_STATUS_INVAL; 3700 3701 if (strlen (path) < (PATH_MAX - 1 - strlen ("/.artec_eplus48u/"))) 3702 strcat (path, "/.artec_eplus48u/"); 3703 else 3704 return SANE_STATUS_INVAL; 3705 3706 /*try to save black shading file */ 3707 strcpy (filename, path); 3708 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_black"))) 3709 strcat (filename, "artec48ushading_black"); 3710 else 3711 return SANE_STATUS_INVAL; 3712 XDBG ((1, "Try to save black shading file: \"%s\"\n", filename)); 3713 f = fopen (filename, "w"); 3714 if (!f) 3715 { 3716 XDBG ((1, "Could not save artec48ushading_black\n")); 3717 return SANE_STATUS_INVAL; 3718 } 3719 if (chmod (filename, mode) != 0) 3720 return SANE_STATUS_INVAL; 3721 3722 /*read values */ 3723 cnt = fwrite (s->shading_buffer_b, sizeof (unsigned char), 30720*s->dev->epro_mult, f); /*epro*/ 3724 XDBG ((1, "Wrote %li bytes to black shading buffer \n", (u_long) cnt)); 3725 if (cnt != (30720*s->dev->epro_mult))/*epro*/ 3726 { 3727 fclose (f); 3728 XDBG ((1, "Could not write black shading buffer\n")); 3729 return SANE_STATUS_INVAL; 3730 } 3731 fclose (f); 3732 3733 /*try to save white shading file */ 3734 strcpy (filename, path); 3735 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48ushading_white"))) 3736 strcat (filename, "artec48ushading_white"); 3737 else 3738 return SANE_STATUS_INVAL; 3739 XDBG ((1, "Try to save white shading file: \"%s\"\n", filename)); 3740 f = fopen (filename, "w"); 3741 if (!f) 3742 return SANE_STATUS_INVAL; 3743 if (chmod (filename, mode) != 0) 3744 return SANE_STATUS_INVAL; 3745 /*read values */ 3746 cnt = fwrite (s->shading_buffer_w, sizeof (unsigned char), 30720*s->dev->epro_mult, f);/*epro*/ 3747 if (cnt != (30720*s->dev->epro_mult)) /*epro*/ 3748 { 3749 fclose (f); 3750 XDBG ((1, "Could not write white shading buffer\n")); 3751 return SANE_STATUS_INVAL; 3752 } 3753 fclose (f); 3754 3755 /*try to save offset file */ 3756 strcpy (filename, path); 3757 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uoffset"))) 3758 strcat (filename, "artec48uoffset"); 3759 else 3760 return SANE_STATUS_INVAL; 3761 XDBG ((1, "Try to write offset file: \"%s\"\n", filename)); 3762 f = fopen (filename, "w"); 3763 if (!f) 3764 return SANE_STATUS_INVAL; 3765 if (chmod (filename, mode) != 0) 3766 return SANE_STATUS_INVAL; 3767 /*read values */ 3768 cnt = 3769 fwrite (&s->dev->artec_48u_afe_params, sizeof (Artec48U_AFE_Parameters), 3770 1, f); 3771 if (cnt != 1) 3772 { 3773 fclose (f); 3774 XDBG ((1, "Could not write afe values\n")); 3775 return SANE_STATUS_INVAL; 3776 } 3777 fclose (f); 3778 3779 /*try to write exposure file */ 3780 strcpy (filename, path); 3781 if (strlen (filename) < (PATH_MAX - 1 - strlen ("artec48uexposure"))) 3782 strcat (filename, "artec48uexposure"); 3783 else 3784 return SANE_STATUS_INVAL; 3785 XDBG ((1, "Try to write exposure file: \"%s\"\n", filename)); 3786 f = fopen (filename, "w"); 3787 if (!f) 3788 return SANE_STATUS_INVAL; 3789 if (chmod (filename, mode) != 0) 3790 return SANE_STATUS_INVAL; 3791 /*read values */ 3792 cnt = 3793 fwrite (&s->dev->artec_48u_exposure_params, 3794 sizeof (Artec48U_Exposure_Parameters), 1, f); 3795 if (cnt != 1) 3796 { 3797 fclose (f); 3798 XDBG ((1, "Could not write exposure values\n")); 3799 return SANE_STATUS_INVAL; 3800 } 3801 fclose (f); 3802 return status; 3803} 3804 3805SANE_Status 3806sane_open (SANE_String_Const devicename, SANE_Handle * handle) 3807{ 3808 SANE_Status status = SANE_STATUS_INVAL; 3809 Artec48U_Device *dev = 0; 3810 Artec48U_Scanner *s = 0; 3811 3812 if (!devicename) 3813 return SANE_STATUS_INVAL; 3814 XDBG ((2, "sane_open: devicename = \"%s\"\n", devicename)); 3815 3816 3817 if (devicename[0]) 3818 { 3819 for (dev = first_dev; dev; dev = dev->next) 3820 { 3821 if (strcmp (dev->sane.name, devicename) == 0) 3822 { 3823 XDBG ((2, "sane_open: found matching device %s\n", 3824 dev->sane.name)); 3825 break; 3826 } 3827 } 3828 if (!dev) 3829 { 3830 status = attach (devicename, &dev); 3831 if (status != SANE_STATUS_GOOD) 3832 XDBG ((2, "sane_open: attach failed %s\n", devicename)); 3833 } 3834 } 3835 else 3836 { 3837 /* empty devicename -> use first device */ 3838 XDBG ((2, "sane_open: empty devicename\n")); 3839 dev = first_dev; 3840 } 3841 if (!dev) 3842 return SANE_STATUS_INVAL; 3843 3844 status = artec48u_device_open (dev); 3845 3846 if (status != SANE_STATUS_GOOD) 3847 { 3848 XDBG ((3, "could not open device\n")); 3849 return status; 3850 } 3851 XDBG ((2, "sane_open: opening device `%s', handle = %p\n", dev->sane.name, 3852 (void *) dev)); 3853 3854 XDBG ((1, "sane_open - %s\n", dev->sane.name)); 3855 XDBG ((2, "sane_open: try to open %s\n", dev->sane.name)); 3856 3857 status = artec48u_device_activate (dev); 3858 if (status != SANE_STATUS_GOOD) 3859 { 3860 XDBG ((3, "could not activate device\n")); 3861 return status; 3862 } 3863 /* We do not check anymore, whether the firmware is already loaded */ 3864 /* because that caused problems after rebooting; furthermore, loading */ 3865 /* of the firmware is fast, therefore the test doesn't make much sense */ 3866 status = download_firmware_file (dev); 3867 if (status != SANE_STATUS_GOOD) 3868 { 3869 XDBG ((3, "download_firmware_file failed\n")); 3870 return status; 3871 } 3872 /* If a scan is interrupted without sending stop_scan, bad things happen. 3873 * Send the stop scan command now just in case. */ 3874 artec48u_stop_scan (dev); 3875 3876 artec48u_wait_for_positioning (dev); 3877 3878 artec48u_scanner_new (dev, &s); 3879 init_calibrator (s); 3880 s->next = first_handle; 3881 first_handle = s; 3882 *handle = s; 3883 3884 status = init_options (s); 3885 if (status != SANE_STATUS_GOOD) 3886 return status; 3887 /*Try to load the calibration values */ 3888 status = load_calibration_data (s); 3889 3890 return SANE_STATUS_GOOD; 3891} 3892 3893void 3894sane_close (SANE_Handle handle) 3895{ 3896 Artec48U_Scanner *s; 3897 3898 XDBG ((5, "sane_close: start\n")); 3899 3900 /* remove handle from list of open handles: */ 3901 for (s = first_handle; s; s = s->next) 3902 { 3903 if (s == handle) 3904 break; 3905 } 3906 if (!s) 3907 { 3908 XDBG ((5, "close: invalid handle %p\n", handle)); 3909 return; 3910 } 3911 artec48u_device_close (s->dev); 3912 artec48u_scanner_free (s); 3913 XDBG ((5, "sane_close: exit\n")); 3914} 3915 3916const SANE_Option_Descriptor * 3917sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) 3918{ 3919 Artec48U_Scanner *s = handle; 3920 3921 if ((unsigned) option >= NUM_OPTIONS) 3922 return 0; 3923 XDBG ((5, "sane_get_option_descriptor: option = %s (%d)\n", 3924 s->opt[option].name, option)); 3925 return s->opt + option; 3926} 3927 3928SANE_Status 3929sane_control_option (SANE_Handle handle, SANE_Int option, 3930 SANE_Action action, void *value, SANE_Int * info) 3931{ 3932 Artec48U_Scanner *s = handle; 3933#ifdef ARTEC48U_USE_BUTTONS 3934 SANE_Int button_state; 3935#endif 3936 SANE_Status status; 3937 XDBG ((8, "sane_control_option: handle=%p, opt=%d, act=%d, val=%p, info=%p\n", 3938 (void *) handle, option, action, (void *) value, (void *) info)); 3939 3940 if (info) 3941 *info = 0; 3942 3943 if (option < 0 || option >= NUM_OPTIONS) 3944 return SANE_STATUS_INVAL; /* Unknown option ... */ 3945 3946 if (!SANE_OPTION_IS_ACTIVE (s->opt[option].cap)) 3947 return SANE_STATUS_INVAL; 3948 3949 switch (action) 3950 { 3951 case SANE_ACTION_SET_VALUE: 3952 if (s->scanning == SANE_TRUE) 3953 return SANE_STATUS_INVAL; 3954 3955 if (!SANE_OPTION_IS_SETTABLE (s->opt[option].cap)) 3956 return SANE_STATUS_INVAL; 3957 3958 status = sanei_constrain_value (s->opt + option, value, info); 3959 3960 if (status != SANE_STATUS_GOOD) 3961 return status; 3962 3963 switch (option) 3964 { 3965 case OPT_RESOLUTION: 3966 if(s->dev->is_epro != 0) 3967 { 3968 if((s->val[option].w == 1200) && (*(SANE_Word *) value < 1200)) 3969 { 3970 s->opt[OPT_BIT_DEPTH].constraint.word_list = bitdepth_list; 3971 *info |= SANE_INFO_RELOAD_OPTIONS; 3972 } 3973 else if((s->val[option].w < 1200) && (*(SANE_Word *) value == 1200)) 3974 { 3975 s->opt[OPT_BIT_DEPTH].constraint.word_list = bitdepth_list2; 3976 if(s->val[OPT_BIT_DEPTH].w > 8) 3977 s->val[OPT_BIT_DEPTH].w = 8; 3978 *info |= SANE_INFO_RELOAD_OPTIONS; 3979 } 3980 } 3981 s->val[option].w = *(SANE_Word *) value; 3982 if (info) 3983 { 3984 *info |= SANE_INFO_RELOAD_PARAMS; 3985 } 3986 break; 3987 /* fall through */ 3988 case OPT_BIT_DEPTH: 3989 case OPT_TL_X: 3990 case OPT_TL_Y: 3991 case OPT_BR_X: 3992 case OPT_BR_Y: 3993 s->val[option].w = *(SANE_Word *) value; 3994 if (info) 3995 *info |= SANE_INFO_RELOAD_PARAMS; 3996 return SANE_STATUS_GOOD; 3997 /* fall through */ 3998 case OPT_BLACK_LEVEL: 3999 case OPT_BRIGHTNESS: 4000 case OPT_CONTRAST: 4001 case OPT_GAMMA: 4002 case OPT_GAMMA_R: 4003 case OPT_GAMMA_G: 4004 case OPT_GAMMA_B: 4005 case OPT_CALIBRATE: 4006 case OPT_CALIBRATE_SHADING: 4007 s->val[option].w = *(SANE_Word *) value; 4008 return SANE_STATUS_GOOD; 4009 case OPT_DEFAULT_ENHANCEMENTS: 4010 s->val[OPT_GAMMA].w = SANE_FIX (s->dev->gamma_master); 4011 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[2]) == 0) 4012 { 4013 s->val[OPT_GAMMA_R].w = SANE_FIX (s->dev->gamma_r); 4014 s->val[OPT_GAMMA_G].w = SANE_FIX (s->dev->gamma_g); 4015 s->val[OPT_GAMMA_B].w = SANE_FIX (s->dev->gamma_b); 4016 } 4017 s->val[OPT_BRIGHTNESS].w = 0; 4018 s->val[OPT_CONTRAST].w = 0; 4019 if (info) 4020 *info |= SANE_INFO_RELOAD_OPTIONS; 4021 break; 4022 case OPT_SCAN_MODE: 4023 if (s->val[option].s) 4024 free (s->val[option].s); 4025 s->val[option].s = strdup (value); 4026 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[0]) == 0) 4027 { 4028 s->opt[OPT_GAMMA_R].cap |= SANE_CAP_INACTIVE; 4029 s->opt[OPT_GAMMA_G].cap |= SANE_CAP_INACTIVE; 4030 s->opt[OPT_GAMMA_B].cap |= SANE_CAP_INACTIVE; 4031 s->opt[OPT_BLACK_LEVEL].cap &= ~SANE_CAP_INACTIVE; 4032 s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE; 4033 } 4034 else if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[1]) == 0) 4035 { 4036 s->opt[OPT_GAMMA_R].cap |= SANE_CAP_INACTIVE; 4037 s->opt[OPT_GAMMA_G].cap |= SANE_CAP_INACTIVE; 4038 s->opt[OPT_GAMMA_B].cap |= SANE_CAP_INACTIVE; 4039 s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE; 4040 s->opt[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE; 4041 } 4042 else 4043 { 4044 s->opt[OPT_GAMMA_R].cap &= ~SANE_CAP_INACTIVE; 4045 s->opt[OPT_GAMMA_G].cap &= ~SANE_CAP_INACTIVE; 4046 s->opt[OPT_GAMMA_B].cap &= ~SANE_CAP_INACTIVE; 4047 s->opt[OPT_BLACK_LEVEL].cap |= SANE_CAP_INACTIVE; 4048 s->opt[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE; 4049 } 4050 if (info) 4051 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; 4052 return SANE_STATUS_GOOD; 4053 } 4054 break; 4055 case SANE_ACTION_GET_VALUE: 4056 switch (option) 4057 { 4058 /* word options: */ 4059 case OPT_NUM_OPTS: 4060 case OPT_RESOLUTION: 4061 case OPT_BIT_DEPTH: 4062 case OPT_BLACK_LEVEL: 4063 case OPT_TL_X: 4064 case OPT_TL_Y: 4065 case OPT_BR_X: 4066 case OPT_BR_Y: 4067 case OPT_BRIGHTNESS: 4068 case OPT_CONTRAST: 4069 case OPT_GAMMA: 4070 case OPT_GAMMA_R: 4071 case OPT_GAMMA_G: 4072 case OPT_GAMMA_B: 4073 case OPT_CALIBRATE: 4074 case OPT_CALIBRATE_SHADING: 4075 *(SANE_Word *) value = (SANE_Word) s->val[option].w; 4076 return SANE_STATUS_GOOD; 4077 /* string options: */ 4078 case OPT_SCAN_MODE: 4079 strcpy (value, s->val[option].s); 4080 return SANE_STATUS_GOOD; 4081#ifdef ARTEC48U_USE_BUTTONS 4082 case OPT_BUTTON_STATE: 4083 status = artec48u_check_buttons (s->dev, &button_state); 4084 if (status == SANE_STATUS_GOOD) 4085 { 4086 s->val[option].w = button_state; 4087 *(SANE_Int *) value = (SANE_Int) s->val[option].w; 4088 } 4089 else 4090 { 4091 s->val[option].w = 0; 4092 *(SANE_Int *) value = 0; 4093 } 4094 return SANE_STATUS_GOOD; 4095#endif 4096 } 4097 break; 4098 default: 4099 return SANE_STATUS_INVAL; 4100 } 4101 return SANE_STATUS_GOOD; 4102} 4103 4104SANE_Status 4105sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) 4106{ 4107 Artec48U_Scanner *s = handle; 4108 SANE_Status status; 4109 SANE_Word resx; 4110/* int scan_mode;*/ 4111 SANE_String str = s->val[OPT_SCAN_MODE].s; 4112 int tlx; 4113 int tly; 4114 int brx; 4115 int bry; 4116 int tmp; 4117 XDBG ((2, "sane_get_params: string %s\n", str)); 4118 XDBG ((2, "sane_get_params: enter\n")); 4119 4120 tlx = s->val[OPT_TL_X].w; 4121 tly = s->val[OPT_TL_Y].w; 4122 brx = s->val[OPT_BR_X].w; 4123 bry = s->val[OPT_BR_Y].w; 4124 4125 /*make sure, that tlx < brx and tly < bry 4126 this will NOT change the options */ 4127 if (tlx > brx) 4128 { 4129 tmp = tlx; 4130 tlx = brx; 4131 brx = tmp; 4132 } 4133 if (tly > bry) 4134 { 4135 tmp = tly; 4136 tly = bry; 4137 bry = tmp; 4138 } 4139 resx = s->val[OPT_RESOLUTION].w; 4140 str = s->val[OPT_SCAN_MODE].s; 4141 4142 s->request.color = SANE_TRUE; 4143 if ((strcmp (str, mode_list[0]) == 0) || (strcmp (str, mode_list[1]) == 0)) 4144 s->request.color = SANE_FALSE; 4145 else 4146 s->request.color = SANE_TRUE; 4147 s->request.depth = s->val[OPT_BIT_DEPTH].w; 4148 if (strcmp (str, mode_list[0]) == 0) 4149 s->request.depth = 8; 4150 s->request.y0 = tly; /**< Top boundary */ 4151 s->request.x0 = SANE_FIX (216.0) - brx; /**< left boundary */ 4152 s->request.xs = brx - tlx; /**< Width */ 4153 s->request.ys = bry - tly; /**< Height */ 4154 s->request.xdpi = resx; /**< Horizontal resolution */ 4155 s->request.ydpi = resx; /**< Vertical resolution */ 4156 /*epro*/ 4157 if ((resx == 1200) && (s->dev->is_epro == 0)) 4158 s->request.xdpi = 600;/**< Vertical resolution */ 4159 4160 status = artec48u_setup_scan (s, &(s->request), SA_SCAN, 4161 SANE_TRUE, &(s->params)); 4162 if (status != SANE_STATUS_GOOD) 4163 return SANE_STATUS_INVAL; 4164 4165/*DBG(1, "sane_get_params: scan_mode %i\n",scan_mode);*/ 4166 4167 params->depth = s->params.depth; 4168 s->params.lineart = SANE_FALSE; 4169 if (s->params.color == SANE_TRUE) 4170 { 4171 params->format = SANE_FRAME_RGB; 4172 params->bytes_per_line = s->params.pixel_xs * 3; 4173 } 4174 else 4175 { 4176 params->format = SANE_FRAME_GRAY; 4177 params->bytes_per_line = s->params.pixel_xs; 4178 if (strcmp (str, mode_list[0]) == 0) 4179 { 4180 params->depth = 1; 4181 params->bytes_per_line = (s->params.pixel_xs + 7) / 8; 4182 s->params.lineart = SANE_TRUE; 4183 } 4184 } 4185 if ((resx == 1200) && (s->dev->is_epro == 0)) 4186 { 4187 if (params->depth == 1) 4188 params->bytes_per_line = (s->params.pixel_xs * 2 + 7) / 8; 4189 else 4190 params->bytes_per_line *= 2; 4191 } 4192 if (params->depth == 16) 4193 params->bytes_per_line *= 2; 4194 params->last_frame = SANE_TRUE; 4195 params->pixels_per_line = s->params.pixel_xs; 4196 if ((resx == 1200) && (s->dev->is_epro == 0)) 4197 params->pixels_per_line *= 2; 4198 params->lines = s->params.pixel_ys; 4199 return SANE_STATUS_GOOD; 4200} 4201 4202SANE_Status 4203sane_start (SANE_Handle handle) 4204{ 4205 Artec48U_Scanner *s = handle; 4206 SANE_Status status; 4207 int fds[2]; 4208 4209 if (s->scanning) 4210 { 4211 return SANE_STATUS_DEVICE_BUSY; 4212 } 4213 4214 if (sane_get_parameters (handle, &s->sane_params) != SANE_STATUS_GOOD) 4215 return SANE_STATUS_INVAL; 4216 4217 if ((s->calibrated != SANE_TRUE) || (s->val[OPT_CALIBRATE].w == SANE_TRUE)) 4218 { 4219 XDBG ((1, "Must calibrate scanner\n")); 4220 status = calibrate_scanner (s); 4221 if (status != SANE_STATUS_GOOD) 4222 return status; 4223 s->calibrated = SANE_TRUE; 4224 } 4225 if (sane_get_parameters (handle, &s->sane_params) != SANE_STATUS_GOOD) 4226 return SANE_STATUS_INVAL; 4227 4228 calculate_brightness (s); 4229 calculate_contrast (s); 4230 calculateGamma (s); 4231 calculateGammaRed (s); 4232 calculateGammaGreen (s); 4233 calculateGammaBlue (s); 4234 4235 artec48u_carriage_home (s->dev); 4236 4237 artec48u_wait_for_positioning (s->dev); 4238 s->reader = NULL; 4239 4240 s->scanning = SANE_TRUE; 4241 s->byte_cnt = 0; 4242 s->lines_to_read = s->params.pixel_ys; 4243 /*allocate a buffer, that can hold a complete scan line */ 4244 /*If resolution is 1200 dpi and we are scanning in lineart mode, 4245 then we also allocate a lineart_buffer, which can hold a complete scan line 4246 in 8 bit/gray. This makes interpolation easier. */ 4247 if ((s->params.ydpi == 1200) && (s->dev->is_epro == 0)) 4248 { 4249 if (s->request.color == SANE_TRUE) 4250 { 4251 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 8); 4252 } 4253 else 4254 { 4255 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 4); 4256 /*lineart ? */ 4257 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[0]) == 0) 4258 s->lineart_buffer = (SANE_Byte *) malloc (s->params.pixel_xs * 2); 4259 } 4260 } 4261 else 4262 { 4263 if (s->request.color == SANE_TRUE) 4264 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 4); 4265 else 4266 { 4267 s->line_buffer = (SANE_Byte *) malloc (s->params.scan_bpl * 2); 4268 /*lineart ? */ 4269 if (strcmp (s->val[OPT_SCAN_MODE].s, mode_list[0]) == 0) 4270 s->lineart_buffer = (SANE_Byte *) malloc (s->params.pixel_xs * 2); 4271 } 4272 } 4273 if (pipe (fds) < 0) 4274 { 4275 s->scanning = SANE_FALSE; 4276 XDBG ((2, "sane_start: pipe failed (%s)\n", strerror (errno))); 4277 return SANE_STATUS_IO_ERROR; 4278 } 4279 status = artec48u_scanner_start_scan (s, &s->request, &s->params); 4280 if (status != SANE_STATUS_GOOD) 4281 { 4282 XDBG ((2, "sane_start: could not start scan\n")); 4283 return status; 4284 } 4285 s->pipe = fds[0]; 4286 s->reader_pipe = fds[1]; 4287 s->reader_pid = sanei_thread_begin (reader_process, s); 4288 cancelRead = SANE_FALSE; 4289 if (!sanei_thread_is_valid (s->reader_pid)) 4290 { 4291 s->scanning = SANE_FALSE; 4292 XDBG ((2, "sane_start: sanei_thread_begin failed (%s)\n", strerror (errno))); 4293 return SANE_STATUS_NO_MEM; 4294 } 4295 signal (SIGCHLD, sig_chldhandler); 4296 4297 if (sanei_thread_is_forked()) close (s->reader_pipe); 4298 4299 XDBG ((1, "sane_start done\n")); 4300 4301 return SANE_STATUS_GOOD; /* parent */ 4302} 4303 4304SANE_Status 4305sane_read (SANE_Handle handle, SANE_Byte * data, 4306 SANE_Int max_length, SANE_Int * length) 4307{ 4308 Artec48U_Scanner *s = handle; 4309 ssize_t nread; 4310 4311 *length = 0; 4312 4313 /* here we read all data from the driver... */ 4314 nread = read (s->pipe, data, max_length); 4315 XDBG ((3, "sane_read - read %ld bytes\n", (long) nread)); 4316 if (cancelRead == SANE_TRUE) 4317 { 4318 return do_cancel (s, SANE_TRUE); 4319 } 4320 4321 if (nread < 0) 4322 { 4323 if (EAGAIN == errno) 4324 { 4325 /* if we already had read the picture, so it's okay and stop */ 4326 if (s->eof == SANE_TRUE) 4327 { 4328 sanei_thread_waitpid (s->reader_pid, 0); 4329 sanei_thread_invalidate (s->reader_pid); 4330 artec48u_scanner_stop_scan (s); 4331 artec48u_carriage_home (s->dev); 4332 return close_pipe (s); 4333 } 4334 /* else force the frontend to try again */ 4335 return SANE_STATUS_GOOD; 4336 } 4337 else 4338 { 4339 XDBG ((4, "ERROR: errno=%d\n", errno)); 4340 do_cancel (s, SANE_TRUE); 4341 return SANE_STATUS_IO_ERROR; 4342 } 4343 } 4344 4345 *length = nread; 4346 s->byte_cnt += nread; 4347 4348 /* nothing read means that we're finished OR we had a problem... */ 4349 if (0 == nread) 4350 { 4351 if (0 == s->byte_cnt) 4352 { 4353 s->exit_code = sanei_thread_get_status (s->reader_pid); 4354 4355 if (SANE_STATUS_GOOD != s->exit_code) 4356 { 4357 close_pipe (s); 4358 return s->exit_code; 4359 } 4360 } 4361 return close_pipe (s); 4362 } 4363 return SANE_STATUS_GOOD; 4364} 4365 4366void 4367sane_cancel (SANE_Handle handle) 4368{ 4369 Artec48U_Scanner *s = handle; 4370 XDBG ((2, "sane_cancel: handle = %p\n", handle)); 4371 if (s->scanning) 4372 do_cancel (s, SANE_FALSE); 4373} 4374 4375SANE_Status 4376sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) 4377{ 4378 Artec48U_Scanner *s = (Artec48U_Scanner *) handle; 4379 4380 XDBG ((1, "sane_set_io_mode: non_blocking=%d\n", non_blocking)); 4381 4382 if (!s->scanning) 4383 { 4384 XDBG ((4, "ERROR: not scanning !\n")); 4385 return SANE_STATUS_INVAL; 4386 } 4387 4388 if (-1 == s->pipe) 4389 { 4390 XDBG ((4, "ERROR: not supported !\n")); 4391 return SANE_STATUS_UNSUPPORTED; 4392 } 4393 4394 if (fcntl (s->pipe, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0) 4395 { 4396 XDBG ((4, "ERROR: can?t set to non-blocking mode !\n")); 4397 return SANE_STATUS_IO_ERROR; 4398 } 4399 4400 XDBG ((1, "sane_set_io_mode done\n")); 4401 return SANE_STATUS_GOOD; 4402} 4403 4404SANE_Status 4405sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) 4406{ 4407 Artec48U_Scanner *s = (Artec48U_Scanner *) handle; 4408 4409 XDBG ((1, "sane_get_select_fd\n")); 4410 4411 if (!s->scanning) 4412 { 4413 XDBG ((4, "ERROR: not scanning !\n")); 4414 return SANE_STATUS_INVAL; 4415 } 4416 4417 *fd = s->pipe; 4418 4419 XDBG ((1, "sane_get_select_fd done\n")); 4420 return SANE_STATUS_GOOD; 4421} 4422 4423SANE_Status 4424sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) 4425{ 4426 Artec48U_Device *device = 0; 4427 SANE_Status status; 4428 char str[PATH_MAX] = _DEFAULT_DEVICE; 4429 char temp[PATH_MAX]; 4430 size_t len; 4431 FILE *fp; 4432 double gamma_m = 1.9; 4433 double gamma_r = 1.0; 4434 double gamma_g = 1.0; 4435 double gamma_b = 1.0; 4436 int epro_default = 0; 4437 4438 DBG_INIT (); 4439 eProMult = 1; 4440 isEPro = 0; 4441 temp[0] = 0; 4442 strcpy (vendor_string, "Artec"); 4443 strcpy (model_string, "E+ 48U"); 4444 4445 sanei_usb_init (); 4446 sanei_thread_init (); 4447 4448 /* do some presettings... */ 4449 auth = authorize; 4450 4451 if (version_code != NULL) 4452 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, 0); 4453 4454 fp = sanei_config_open (ARTEC48U_CONFIG_FILE); 4455 4456 /* default to _DEFAULT_DEVICE instead of insisting on config file */ 4457 if (NULL == fp) 4458 { 4459 status = attach (_DEFAULT_DEVICE, &device); 4460 return status; 4461 } 4462 4463 while (sanei_config_read (str, sizeof (str), fp)) 4464 { 4465 XDBG ((1, "sane_init, >%s<\n", str)); 4466 /* ignore line comments */ 4467 if (str[0] == '#') 4468 continue; 4469 len = strlen (str); 4470 /* ignore empty lines */ 4471 if (0 == len) 4472 continue; 4473 /* check for options */ 4474 if (0 == strncmp (str, "option", 6)) 4475 { 4476 if(decodeVal (str,"ePlusPro",_INT, &isEPro,&epro_default) == SANE_TRUE) 4477 { 4478 eProMult = 1; 4479 if(isEPro != 0) 4480 { 4481 eProMult = 2; 4482 XDBG ((3, "Is Artec E Pro\n")); 4483 } 4484 else 4485 XDBG ((3, "Is Artec E+ 48U\n")); 4486 } 4487 decodeVal (str, "masterGamma", _FLOAT, &gamma_master_default, 4488 &gamma_m); 4489 decodeVal (str, "redGamma", _FLOAT, &gamma_r_default, &gamma_r); 4490 decodeVal (str, "greenGamma", _FLOAT, &gamma_g_default, &gamma_g); 4491 decodeVal (str, "blueGamma", _FLOAT, &gamma_b_default, &gamma_b); 4492 decodeVal (str, "redOffset", _BYTE, &afe_params.r_offset, 4493 &default_afe_params.r_offset); 4494 decodeVal (str, "greenOffset", _BYTE, &afe_params.g_offset, 4495 &default_afe_params.g_offset); 4496 decodeVal (str, "blueOffset", _BYTE, &afe_params.b_offset, 4497 &default_afe_params.b_offset); 4498 4499 decodeVal (str, "redExposure", _INT, &exp_params.r_time, 4500 &default_exp_params.r_time); 4501 decodeVal (str, "greenExposure", _INT, &exp_params.g_time, 4502 &default_exp_params.g_time); 4503 decodeVal (str, "blueExposure", _INT, &exp_params.b_time, 4504 &default_exp_params.b_time); 4505 4506 decodeVal (str, "modelString", _STRING, model_string, model_string); 4507 decodeVal (str, "vendorString", _STRING, vendor_string, 4508 vendor_string); 4509 4510 decodeVal (str, "artecFirmwareFile", _STRING, firmwarePath, 4511 firmwarePath); 4512 } 4513 else if (0 == strncmp (str, "usb", 3)) 4514 { 4515 if (temp[0] != 0) 4516 { 4517 XDBG ((3, "trying to attach: %s\n", temp)); 4518 XDBG ((3, " vendor: %s\n", vendor_string)); 4519 XDBG ((3, " model: %s\n", model_string)); 4520 sanei_usb_attach_matching_devices (temp, attach_one_device); 4521 } 4522 /*save config line in temp */ 4523 strcpy (temp, str); 4524 } 4525 else if (0 == strncmp (str, "device", 6)) 4526 { 4527 if (SANE_TRUE == decodeDevName (str, devName)) 4528 { 4529 if (devName[0] != 0) 4530 sanei_usb_attach_matching_devices (devName, 4531 attach_one_device); 4532 temp[0] = 0; 4533 } 4534 } 4535 else 4536 { 4537 /* ignore other stuff... */ 4538 XDBG ((1, "ignoring >%s<\n", str)); 4539 } 4540 } 4541 if (temp[0] != 0) 4542 { 4543 XDBG ((3, "trying to attach: %s\n", temp)); 4544 XDBG ((3, " vendor: %s\n", vendor_string)); 4545 XDBG ((3, " model: %s\n", model_string)); 4546 sanei_usb_attach_matching_devices (temp, attach_one_device); 4547 temp[0] = 0; 4548 } 4549 4550 fclose (fp); 4551 return SANE_STATUS_GOOD; 4552} 4553 4554void 4555sane_exit (void) 4556{ 4557 Artec48U_Device *dev, *next; 4558 4559 XDBG ((5, "sane_exit: start\n")); 4560 for (dev = first_dev; dev; dev = next) 4561 { 4562 next = dev->next; 4563 /*function will check, whether device is really open */ 4564 artec48u_device_close (dev); 4565 artec48u_device_free (dev); 4566 } 4567 XDBG ((5, "sane_exit: exit\n")); 4568 return; 4569} 4570