From c1dc16d709459e054f50604f86f1ee41c0e7177f Mon Sep 17 00:00:00 2001 From: Jan Hauffa Date: Wed, 20 Apr 2011 23:10:53 +0200 Subject: [PATCH] Extensive changes to reduce the amount of global variables in mustek_usb2_high.c. Might have made MustScanner_SetupScan less readable, though. --- backend/mustek_usb2.c | 343 ++++++++++++++++------------------ backend/mustek_usb2.h | 21 +-- backend/mustek_usb2_high.c | 365 +++++++++++++++++-------------------- backend/mustek_usb2_high.h | 12 +- 4 files changed, 343 insertions(+), 398 deletions(-) diff --git a/backend/mustek_usb2.c b/backend/mustek_usb2.c index f300b46cc..97c407ce6 100644 --- a/backend/mustek_usb2.c +++ b/backend/mustek_usb2.c @@ -117,10 +117,123 @@ static const Scanner_Model mustek_A2nu2_model = { SANE_FIX (1.46 * MM_PER_INCH), /* size of scan area in TA mode in mm (x) */ SANE_FIX (6.45 * MM_PER_INCH), /* size of scan area in TA mode in mm (y) */ - RO_RGB /* order of the CCD/CIS colors */ + SANE_FALSE /* invert order of the CCD/CIS colors? */ }; +static void +get_target_image (Mustek_Scanner * s, TARGETIMAGE * pTarget) +{ + SANE_String val, val_source; + float x1, y1, x2, y2; + + DBG (DBG_FUNC, "get_target_image: start\n"); + + if (s->val[OPT_PREVIEW].w) + pTarget->wXDpi = 75; + else + pTarget->wXDpi = s->val[OPT_RESOLUTION].w; + pTarget->wYDpi = pTarget->wXDpi; + + x1 = SANE_UNFIX (s->val[OPT_TL_X].w) / MM_PER_INCH; + y1 = SANE_UNFIX (s->val[OPT_TL_Y].w) / MM_PER_INCH; + x2 = SANE_UNFIX (s->val[OPT_BR_X].w) / MM_PER_INCH; + y2 = SANE_UNFIX (s->val[OPT_BR_Y].w) / MM_PER_INCH; + + pTarget->wX = (unsigned short) ((x1 * pTarget->wXDpi) + 0.5); + pTarget->wY = (unsigned short) ((y1 * pTarget->wYDpi) + 0.5); + pTarget->wWidth = (unsigned short) (((x2 - x1) * pTarget->wXDpi) + 0.5); + pTarget->wHeight = (unsigned short) (((y2 - y1) * pTarget->wYDpi) + 0.5); + + pTarget->wLineartThreshold = s->val[OPT_THRESHOLD].w; + + val_source = s->val[OPT_SOURCE].s; + DBG (DBG_DET, "get_target_image: scan source = %s\n", val_source); + if (strcmp (val_source, source_list[SS_POSITIVE]) == 0) + pTarget->ssScanSource = SS_POSITIVE; + else if (strcmp (val_source, source_list[SS_NEGATIVE]) == 0) + pTarget->ssScanSource = SS_NEGATIVE; + else + pTarget->ssScanSource = SS_REFLECTIVE; + + val = s->val[OPT_MODE].s; + if (strcmp (val, mode_list[CM_RGB48]) == 0) + { + if (s->val[OPT_PREVIEW].w) + { + DBG (DBG_DET, "get_target_image: preview, set ColorMode CM_RGB24\n"); + pTarget->cmColorMode = CM_RGB24; + } + else + pTarget->cmColorMode = CM_RGB48; + } + else if (strcmp (val, mode_list[CM_RGB24]) == 0) + { + pTarget->cmColorMode = CM_RGB24; + } + else if (strcmp (val, mode_list[CM_GRAY16]) == 0) + { + if (s->val[OPT_PREVIEW].w) + { + DBG (DBG_DET, "get_target_image: preview, set ColorMode CM_GRAY8\n"); + pTarget->cmColorMode = CM_GRAY8; + } + else + pTarget->cmColorMode = CM_GRAY16; + } + else if (strcmp (val, mode_list[CM_GRAY8]) == 0) + { + pTarget->cmColorMode = CM_GRAY8; + } + else + { + pTarget->cmColorMode = CM_TEXT; + } + + DBG (DBG_FUNC, "get_target_image: exit\n"); +} + +static void +calc_parameters (TARGETIMAGE * pTarget, SANE_Parameters * params) +{ + DBG (DBG_FUNC, "calc_parameters: start\n"); + + params->pixels_per_line = pTarget->wWidth; + params->lines = pTarget->wHeight; + params->last_frame = SANE_TRUE; + + switch (pTarget->cmColorMode) + { + case CM_RGB48: + params->format = SANE_FRAME_RGB; + params->depth = 16; + params->bytes_per_line = params->pixels_per_line * 6; + break; + case CM_RGB24: + params->format = SANE_FRAME_RGB; + params->depth = 8; + params->bytes_per_line = params->pixels_per_line * 3; + break; + case CM_GRAY16: + params->format = SANE_FRAME_GRAY; + params->depth = 16; + params->bytes_per_line = params->pixels_per_line * 2; + break; + case CM_GRAY8: + params->format = SANE_FRAME_GRAY; + params->depth = 8; + params->bytes_per_line = params->pixels_per_line; + break; + case CM_TEXT: + params->format = SANE_FRAME_GRAY; + params->depth = 1; + params->bytes_per_line = params->pixels_per_line / 8; + break; + } + + DBG (DBG_FUNC, "calc_parameters: exit\n"); +} + static size_t max_string_size (SANE_String_Const *strings) { @@ -136,120 +249,12 @@ max_string_size (SANE_String_Const *strings) return max_size; } -static void -calc_parameters (Mustek_Scanner * s) -{ - SANE_String val, val_source; - float x1, y1, x2, y2; - - DBG (DBG_FUNC, "calc_parameters: start\n"); - - if (s->val[OPT_PREVIEW].w) - s->setpara.wDpi = 75; - else - s->setpara.wDpi = s->val[OPT_RESOLUTION].w; - - x1 = SANE_UNFIX (s->val[OPT_TL_X].w) / MM_PER_INCH; - y1 = SANE_UNFIX (s->val[OPT_TL_Y].w) / MM_PER_INCH; - x2 = SANE_UNFIX (s->val[OPT_BR_X].w) / MM_PER_INCH; - y2 = SANE_UNFIX (s->val[OPT_BR_Y].w) / MM_PER_INCH; - - s->setpara.wX = (unsigned short) ((x1 * s->setpara.wDpi) + 0.5); - s->setpara.wY = (unsigned short) ((y1 * s->setpara.wDpi) + 0.5); - s->setpara.wWidth = (unsigned short) (((x2 - x1) * s->setpara.wDpi) + 0.5); - s->setpara.wHeight = (unsigned short) (((y2 - y1) * s->setpara.wDpi) + 0.5); - - s->setpara.wLineartThreshold = s->val[OPT_THRESHOLD].w; - - val_source = s->val[OPT_SOURCE].s; - DBG (DBG_DET, "calc_parameters: scan source = %s\n", val_source); - if (strcmp (val_source, source_list[SS_POSITIVE]) == 0) - s->setpara.ssScanSource = SS_POSITIVE; - else if (strcmp (val_source, source_list[SS_NEGATIVE]) == 0) - s->setpara.ssScanSource = SS_NEGATIVE; - else - s->setpara.ssScanSource = SS_REFLECTIVE; - - val = s->val[OPT_MODE].s; - if (strcmp (val, mode_list[CM_RGB48]) == 0) - { - if (s->val[OPT_PREVIEW].w) - { - DBG (DBG_DET, "calc_parameters: preview, set ColorMode CM_RGB24\n"); - s->setpara.cmColorMode = CM_RGB24; - } - else - { - s->setpara.cmColorMode = CM_RGB48; - } - } - else if (strcmp (val, mode_list[CM_RGB24]) == 0) - { - s->setpara.cmColorMode = CM_RGB24; - } - else if (strcmp (val, mode_list[CM_GRAY16]) == 0) - { - if (s->val[OPT_PREVIEW].w) - { - DBG (DBG_DET, "calc_parameters: preview, set ColorMode CM_GRAY8\n"); - s->setpara.cmColorMode = CM_GRAY8; - } - else - { - s->setpara.cmColorMode = CM_GRAY16; - } - } - else if (strcmp (val, mode_list[CM_GRAY8]) == 0) - { - s->setpara.cmColorMode = CM_GRAY8; - } - else - { - s->setpara.cmColorMode = CM_TEXT; - } - - /* provide an estimate for scan parameters returned by sane_get_parameters */ - s->params.pixels_per_line = s->setpara.wWidth; - s->params.lines = s->setpara.wHeight; - s->params.last_frame = SANE_TRUE; - - switch (s->setpara.cmColorMode) - { - case CM_RGB48: - s->params.format = SANE_FRAME_RGB; - s->params.depth = 16; - s->params.bytes_per_line = s->params.pixels_per_line * 6; - break; - case CM_RGB24: - s->params.format = SANE_FRAME_RGB; - s->params.depth = 8; - s->params.bytes_per_line = s->params.pixels_per_line * 3; - break; - case CM_GRAY16: - s->params.format = SANE_FRAME_GRAY; - s->params.depth = 16; - s->params.bytes_per_line = s->params.pixels_per_line * 2; - break; - case CM_GRAY8: - s->params.format = SANE_FRAME_GRAY; - s->params.depth = 8; - s->params.bytes_per_line = s->params.pixels_per_line; - break; - case CM_TEXT: - s->params.format = SANE_FRAME_GRAY; - s->params.depth = 1; - s->params.bytes_per_line = s->params.pixels_per_line / 8; - break; - } - - DBG (DBG_FUNC, "calc_parameters: exit\n"); -} - static SANE_Status init_options (Mustek_Scanner * s) { SANE_Int option, count = 0; SANE_Word *dpi_list; + TARGETIMAGE target; DBG (DBG_FUNC, "init_options: start\n"); @@ -401,40 +406,13 @@ init_options (Mustek_Scanner * s) s->opt[OPT_BR_Y].constraint.range = &y_range; s->val[OPT_BR_Y].w = y_range.max; - calc_parameters (s); + get_target_image (s, &target); + calc_parameters (&target, &s->params); DBG (DBG_FUNC, "init_options: exit\n"); return SANE_STATUS_GOOD; } -static SANE_Bool -ReadScannedData (IMAGEROWS * pImageRows, TARGETIMAGE * pTarget) -{ - SANE_Bool isRGBInvert; - unsigned short Rows; - unsigned int i; - - DBG (DBG_FUNC, "ReadScannedData: start\n"); - - isRGBInvert = (pImageRows->roRgbOrder == RO_RGB) ? SANE_FALSE : SANE_TRUE; - Rows = pImageRows->wWantedLineNum; - DBG (DBG_INFO, "ReadScannedData: wanted rows = %d\n", Rows); - - if (!MustScanner_GetRows (pImageRows->pBuffer, &Rows, isRGBInvert)) - return SANE_FALSE; - pImageRows->wXferedLineNum = Rows; - - if ((pTarget->cmColorMode == CM_TEXT) || - (pTarget->ssScanSource == SS_NEGATIVE)) - { - for (i = 0; i < (Rows * pTarget->dwBytesPerRow); i++) - pImageRows->pBuffer[i] ^= 0xff; - } - - DBG (DBG_FUNC, "ReadScannedData: exit\n"); - return SANE_TRUE; -} - /****************************** SANE API functions ****************************/ @@ -564,6 +542,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Status status; SANE_Word cap; SANE_Int myinfo = 0; + TARGETIMAGE target; DBG (DBG_FUNC, "sane_control_option: start: action = %s, option = %s (%d)\n", (action == SANE_ACTION_GET_VALUE) ? "get" : @@ -645,7 +624,8 @@ sane_control_option (SANE_Handle handle, SANE_Int option, case OPT_BR_X: case OPT_BR_Y: s->val[option].w = *(SANE_Word *) val; - calc_parameters (s); + get_target_image (s, &target); + calc_parameters (&target, &s->params); myinfo |= SANE_INFO_RELOAD_PARAMS; break; case OPT_THRESHOLD: @@ -660,7 +640,8 @@ sane_control_option (SANE_Handle handle, SANE_Int option, s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; else s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; - calc_parameters (s); + get_target_image (s, &target); + calc_parameters (&target, &s->params); myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; break; case OPT_SOURCE: @@ -740,6 +721,7 @@ SANE_Status sane_start (SANE_Handle handle) { Mustek_Scanner *s = handle; + TARGETIMAGE target; DBG (DBG_FUNC, "sane_start: start\n"); @@ -750,29 +732,26 @@ sane_start (SANE_Handle handle) return SANE_FALSE; } - calc_parameters (s); + get_target_image (s, &target); - DBG (DBG_INFO, "sane_start: setpara.wX=%d\n", s->setpara.wX); - DBG (DBG_INFO, "sane_start: setpara.wY=%d\n", s->setpara.wY); - DBG (DBG_INFO, "sane_start: setpara.wWidth=%d\n", s->setpara.wWidth); - DBG (DBG_INFO, "sane_start: setpara.wHeight=%d\n", s->setpara.wHeight); - DBG (DBG_INFO, "sane_start: setpara.wLineartThreshold=%d\n", - s->setpara.wLineartThreshold); - DBG (DBG_INFO, "sane_start: setpara.wDpi=%d\n", s->setpara.wDpi); - DBG (DBG_INFO, "sane_start: setpara.cmColorMode=%d\n", - s->setpara.cmColorMode); - DBG (DBG_INFO, "sane_start: setpara.ssScanSource=%d\n", - s->setpara.ssScanSource); + DBG (DBG_INFO, "sane_start: target.wX=%d\n", target.wX); + DBG (DBG_INFO, "sane_start: target.wY=%d\n", target.wY); + DBG (DBG_INFO, "sane_start: target.wWidth=%d\n", target.wWidth); + DBG (DBG_INFO, "sane_start: target.wHeight=%d\n", target.wHeight); + DBG (DBG_INFO, "sane_start: target.wLineartThreshold=%d\n", + target.wLineartThreshold); + DBG (DBG_INFO, "sane_start: target.wXDpi=%d\n", target.wXDpi); + DBG (DBG_INFO, "sane_start: target.wYDpi=%d\n", target.wYDpi); + DBG (DBG_INFO, "sane_start: target.cmColorMode=%d\n", target.cmColorMode); + DBG (DBG_INFO, "sane_start: target.ssScanSource=%d\n", target.ssScanSource); MustScanner_Reset (); /* adjust parameters to the scanner's requirements */ - MustScanner_ScanSuggest (&s->setpara); - - /* update the scan parameters to be returned by sane_get_parameters */ - s->params.pixels_per_line = s->setpara.wWidth; - s->params.lines = s->setpara.wHeight; - s->params.bytes_per_line = s->setpara.dwBytesPerRow; + MustScanner_ScanSuggest (&target); + calc_parameters (&target, &s->params); + s->bInvertImage = ((target.cmColorMode == CM_TEXT) ^ + (target.ssScanSource == SS_NEGATIVE)); s->read_rows = s->params.lines; DBG (DBG_INFO, "sane_start: read_rows = %d\n", s->read_rows); @@ -787,7 +766,7 @@ sane_start (SANE_Handle handle) return SANE_STATUS_NO_MEM; s->scan_buf_len = 0; - if (!MustScanner_SetupScan (&s->setpara)) + if (!MustScanner_SetupScan (&target)) return SANE_STATUS_INVAL; DBG (DBG_FUNC, "sane_start: exit\n"); @@ -801,8 +780,9 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, Mustek_Scanner *s = handle; SANE_Byte *tempbuf; long int tempbuf_size; - SANE_Int lines_to_read, lines_read; - IMAGEROWS image_row; + SANE_Int lines, lines_read; + unsigned short lines_received; + int i; DBG (DBG_FUNC, "sane_read: start: max_len=%d\n", max_len); @@ -826,33 +806,34 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, { if (s->read_rows > 0) { - lines_to_read = SCAN_BUFFER_SIZE / s->setpara.dwBytesPerRow; - if (lines_to_read > s->read_rows) - lines_to_read = s->read_rows; + lines = SCAN_BUFFER_SIZE / s->params.bytes_per_line; + lines = _MIN (lines, s->read_rows); - tempbuf_size = lines_to_read * s->setpara.dwBytesPerRow + - 3 * 1024 + 1; + tempbuf_size = lines * s->params.bytes_per_line + 3 * 1024 + 1; tempbuf = malloc (tempbuf_size); if (!tempbuf) return SANE_STATUS_NO_MEM; memset (tempbuf, 0, tempbuf_size); DBG (DBG_INFO, "sane_read: buffer size is %ld\n", tempbuf_size); - image_row.roRgbOrder = s->model.line_mode_color_order; - image_row.wWantedLineNum = lines_to_read; - image_row.pBuffer = tempbuf; s->bIsReading = SANE_TRUE; - - if (!ReadScannedData (&image_row, &s->setpara)) + lines_received = (unsigned short) lines; + if (!MustScanner_GetRows (tempbuf, &lines_received, + s->model.isRGBInvert)) { - DBG (DBG_ERR, "sane_read: ReadScannedData error\n"); + DBG (DBG_ERR, "sane_read: MustScanner_GetRows error\n"); s->bIsReading = SANE_FALSE; return SANE_STATUS_INVAL; } + if (s->bInvertImage) + { + for (i = 0; i < (lines_received * s->params.bytes_per_line); i++) + tempbuf[i] ^= 0xff; + } + DBG (DBG_DBG, "sane_read: Finish ReadScanedData\n"); - s->scan_buf_len = - image_row.wXferedLineNum * s->setpara.dwBytesPerRow; + s->scan_buf_len = lines_received * s->params.bytes_per_line; DBG (DBG_INFO, "sane_read : s->scan_buf_len = %ld\n", (long int) s->scan_buf_len); @@ -866,7 +847,7 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, DBG (DBG_DBG, "sane_read: after memcpy\n"); free (tempbuf); s->scan_buf_start = s->scan_buf; - s->read_rows -= image_row.wXferedLineNum; + s->read_rows -= lines_received; s->bIsReading = SANE_FALSE; } else @@ -882,17 +863,14 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, } } - lines_read = _MIN (max_len, (SANE_Int) s->scan_buf_len); + lines_read = _MIN (max_len, s->scan_buf_len); DBG (DBG_DBG, "sane_read: after %d\n", lines_read); + *len = lines_read; - *len = (SANE_Int) lines_read; - - DBG (DBG_INFO, "sane_read: get lines_read = %d\n", lines_read); - DBG (DBG_INFO, "sane_read: get *len = %d\n", *len); memcpy (buf, s->scan_buf_start, lines_read); - s->scan_buf_len -= lines_read; s->scan_buf_start += lines_read; + DBG (DBG_FUNC, "sane_read: exit\n"); return SANE_STATUS_GOOD; } @@ -932,7 +910,6 @@ sane_cancel (SANE_Handle handle) s->read_rows = 0; s->scan_buf_len = 0; - memset (&s->setpara, 0, sizeof (s->setpara)); } else { diff --git a/backend/mustek_usb2.h b/backend/mustek_usb2.h index df566d82e..9b1b11283 100644 --- a/backend/mustek_usb2.h +++ b/backend/mustek_usb2.h @@ -79,20 +79,6 @@ enum NUM_OPTIONS }; -typedef enum -{ - RO_RGB, - RO_BGR -} RGBORDER; - - -typedef struct -{ - RGBORDER roRgbOrder; - unsigned short wWantedLineNum; - unsigned short wXferedLineNum; - SANE_Byte * pBuffer; -} IMAGEROWS; typedef struct { @@ -113,7 +99,8 @@ typedef struct SANE_Fixed x_size_ta; /* size of scan area in TA mode in mm */ SANE_Fixed y_size_ta; - RGBORDER line_mode_color_order; /* order of the CCD/CIS colors */ + SANE_Bool isRGBInvert; /* order of the CCD/CIS colors: + RGB if SANE_False, BGR otherwise */ /*@} */ } Scanner_Model; @@ -125,13 +112,13 @@ typedef struct Mustek_Scanner Option_Value val[NUM_OPTIONS]; SANE_Parameters params; Scanner_Model model; - TARGETIMAGE setpara; SANE_Bool bIsScanning; SANE_Bool bIsReading; + SANE_Bool bInvertImage; SANE_Word read_rows; /* number of image lines left to read */ SANE_Byte * scan_buf; SANE_Byte * scan_buf_start; - size_t scan_buf_len; + SANE_Int scan_buf_len; } Mustek_Scanner; #endif diff --git a/backend/mustek_usb2_high.c b/backend/mustek_usb2_high.c index a9c646be8..9c52a182b 100644 --- a/backend/mustek_usb2_high.c +++ b/backend/mustek_usb2_high.c @@ -59,55 +59,38 @@ #include "mustek_usb2_high.h" + /* HOLD: these global variables should go to scanner structure */ static SANE_Bool g_bOpened; static SANE_Bool g_bPrepared; static SANE_Bool g_isCanceled; static SANE_Bool g_bFirstReadImage; - static SANE_Byte * g_pReadImageHead; -static unsigned short g_X; -static unsigned short g_Y; -static unsigned short g_Width; -static unsigned short g_Height; -static unsigned short g_XDpi; -static unsigned short g_YDpi; +static TARGETIMAGE g_Target; static unsigned short g_SWWidth; static unsigned short g_SWHeight; -static unsigned short g_wPixelDistance; /* even & odd sensor problem */ + +/* even & odd sensor problem */ +static unsigned short g_wPixelDistance; static unsigned short g_wLineDistance; static unsigned short g_wScanLinesPerBlock; -static unsigned short g_wLineartThreshold; static unsigned int g_wtheReadyLines; static unsigned int g_wMaxScanLines; static unsigned int g_dwScannedTotalLines; static unsigned int g_BytesPerRow; static unsigned int g_SWBytesPerRow; - static unsigned int g_dwTotalTotalXferLines; -static unsigned short * g_pGammaTable; - static pthread_t g_threadid_readimage; - -static COLORMODE g_ScanMode; -static SCANSOURCE g_ssScanSource; - -static ASIC g_chip; - -static int g_nSecLength, g_nDarkSecLength; -static int g_nSecNum, g_nDarkSecNum; -static unsigned short g_wCalWidth; -static unsigned short g_wDarkCalWidth; -static int g_nPowerNum; -static unsigned short g_wStartPosition; - static pthread_mutex_t g_scannedLinesMutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_readyLinesMutex = PTHREAD_MUTEX_INITIALIZER; +static unsigned short * g_pGammaTable; +static ASIC g_chip; + /* for modifying the last point */ static SANE_Bool g_bIsFirstReadBefData = SANE_TRUE; static SANE_Byte * g_pBefLineImageData; @@ -129,8 +112,6 @@ MustScanner_Init (void) g_pGammaTable = NULL; - g_ssScanSource = SS_REFLECTIVE; - DBG (DBG_FUNC, "MustScanner_Init: leave MustScanner_Init\n"); } @@ -350,7 +331,7 @@ GetRgb48BitLineFull (SANE_Byte * pLine, SANE_Bool isOrderInvert) unsigned int dwRTempData, dwGTempData, dwBTempData; unsigned short i = 0; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { wRLinePosOdd = g_wtheReadyLines - g_wPixelDistance; wGLinePosOdd = g_wtheReadyLines - g_wLineDistance - g_wPixelDistance; @@ -490,7 +471,7 @@ GetRgb24BitLineFull (SANE_Byte * pLine, SANE_Bool isOrderInvert) unsigned short tempR, tempG, tempB; unsigned short i = 0; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { wRLinePosOdd = g_wtheReadyLines - g_wPixelDistance; wGLinePosOdd = g_wtheReadyLines - g_wLineDistance - g_wPixelDistance; @@ -588,7 +569,7 @@ GetMono16BitLineFull (SANE_Byte * pLine, unsigned short wLinePosEven; unsigned short i = 0; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { wLinePosOdd = g_wtheReadyLines - g_wPixelDistance; wLinePosEven = g_wtheReadyLines; @@ -660,7 +641,7 @@ GetMono8BitLineFull (SANE_Byte * pLine, unsigned short wGray; unsigned short i = 0; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { wLinePosOdd = (g_wtheReadyLines - g_wPixelDistance) % g_wMaxScanLines; wLinePosEven = (g_wtheReadyLines) % g_wMaxScanLines; @@ -705,7 +686,7 @@ GetMono1BitLineHalf (SANE_Byte * pLine, for (i = 0; i < g_SWWidth; i++) { - if (g_pReadImageHead[wLinePos + i] > g_wLineartThreshold) + if (g_pReadImageHead[wLinePos + i] > g_Target.wLineartThreshold) pLine[i / 8] |= 0x80 >> (i % 8); } } @@ -718,7 +699,7 @@ GetMono1BitLineFull (SANE_Byte * pLine, unsigned short wLinePosEven; unsigned short i = 0; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { wLinePosOdd = (g_wtheReadyLines - g_wPixelDistance) % g_wMaxScanLines; wLinePosEven = (g_wtheReadyLines) % g_wMaxScanLines; @@ -736,11 +717,11 @@ GetMono1BitLineFull (SANE_Byte * pLine, if ((i + 1) >= g_SWWidth) break; - if (g_pReadImageHead[wLinePosOdd + i] > g_wLineartThreshold) + if (g_pReadImageHead[wLinePosOdd + i] > g_Target.wLineartThreshold) pLine[i / 8] |= 0x80 >> (i % 8); i++; - if (g_pReadImageHead[wLinePosEven + i] > g_wLineartThreshold) + if (g_pReadImageHead[wLinePosEven + i] > g_Target.wLineartThreshold) pLine[i / 8] |= 0x80 >> (i % 8); i++; } @@ -822,7 +803,7 @@ static void * MustScanner_ReadDataFromScanner (void __sane_unused__ * dummy) { unsigned short wTotalReadImageLines = 0; - unsigned short wWantedLines = g_Height; + unsigned short wWantedLines = g_Target.wHeight; SANE_Byte * pReadImage = g_pReadImageHead; SANE_Bool isWaitImageLineDiff = SANE_FALSE; unsigned int wMaxScanLines = g_wMaxScanLines; @@ -996,24 +977,24 @@ MustScanner_GetRows (SANE_Byte * pBlock, unsigned short * Rows, return SANE_FALSE; } - switch (g_ScanMode) + switch (g_Target.cmColorMode) { case CM_RGB48: - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) pFunc = GetRgb48BitLineFull; else pFunc = GetRgb48BitLineHalf; break; case CM_RGB24: - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) pFunc = GetRgb24BitLineFull; else pFunc = GetRgb24BitLineHalf; break; case CM_GRAY16: - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) { fixEvenOdd = SANE_TRUE; pFunc = GetMono16BitLineFull; @@ -1025,7 +1006,7 @@ MustScanner_GetRows (SANE_Byte * pBlock, unsigned short * Rows, break; case CM_GRAY8: - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) { fixEvenOdd = SANE_TRUE; pFunc = GetMono8BitLineFull; @@ -1039,7 +1020,7 @@ MustScanner_GetRows (SANE_Byte * pBlock, unsigned short * Rows, case CM_TEXT: memset (pBlock, 0, *Rows * g_SWWidth / 8); dwLineIncrement /= 8; - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) pFunc = GetMono1BitLineFull; else pFunc = GetMono1BitLineHalf; @@ -1059,8 +1040,8 @@ MustScanner_ScanSuggest (TARGETIMAGE * pTarget) DBG (DBG_FUNC, "MustScanner_ScanSuggest: call in\n"); /* check width and height */ - wMaxWidth = (MAX_SCANNING_WIDTH * pTarget->wDpi) / 300; - wMaxHeight = (MAX_SCANNING_HEIGHT * pTarget->wDpi) / 300; + wMaxWidth = (MAX_SCANNING_WIDTH * pTarget->wXDpi) / 300; + wMaxHeight = (MAX_SCANNING_HEIGHT * pTarget->wYDpi) / 300; DBG (DBG_FUNC, "MustScanner_ScanSuggest: wMaxWidth = %d\n", wMaxWidth); DBG (DBG_FUNC, "MustScanner_ScanSuggest: wMaxHeight = %d\n", wMaxHeight); @@ -1068,27 +1049,6 @@ MustScanner_ScanSuggest (TARGETIMAGE * pTarget) pTarget->wWidth = _MIN (pTarget->wWidth, wMaxWidth); pTarget->wHeight = _MIN (pTarget->wHeight, wMaxHeight); - switch (pTarget->cmColorMode) - { - case CM_RGB48: - pTarget->dwBytesPerRow = (unsigned int) pTarget->wWidth * 6; - break; - case CM_RGB24: - pTarget->dwBytesPerRow = (unsigned int) pTarget->wWidth * 3; - break; - case CM_GRAY16: - pTarget->dwBytesPerRow = (unsigned int) pTarget->wWidth * 2; - break; - case CM_GRAY8: - pTarget->dwBytesPerRow = (unsigned int) pTarget->wWidth; - break; - case CM_TEXT: - pTarget->dwBytesPerRow = (unsigned int) pTarget->wWidth / 8; - break; - } - DBG (DBG_FUNC, "MustScanner_ScanSuggest: pTarget->dwBytesPerRow = %d\n", - pTarget->dwBytesPerRow); - DBG (DBG_FUNC, "MustScanner_ScanSuggest: leave MustScanner_ScanSuggest\n"); } @@ -1146,7 +1106,7 @@ MustScanner_PrepareScan (void) g_wScanLinesPerBlock) * g_wScanLinesPerBlock; g_dwScannedTotalLines = 0; - switch (g_ScanMode) + switch (g_Target.cmColorMode) { case CM_RGB48: case CM_RGB24: @@ -1201,90 +1161,96 @@ MustScanner_Reset (void) } static void -MustScanner_PrepareCalculateMaxMin (unsigned short wResolution) +MustScanner_PrepareCalculateMaxMin (unsigned short wResolution, + CALIBRATIONPARAM * pCalParam) { - g_wDarkCalWidth = 52; + unsigned short wCalWidth, wDarkCalWidth; + + wDarkCalWidth = 52; if (wResolution <= (SENSOR_DPI / 2)) { - g_wCalWidth = (5120 * wResolution / (SENSOR_DPI / 2) + 511) & ~511; - g_wDarkCalWidth *= wResolution / SENSOR_DPI; + wCalWidth = (5120 * wResolution / (SENSOR_DPI / 2) + 511) & ~511; + wDarkCalWidth *= wResolution / SENSOR_DPI; if (wResolution < 200) { - g_nPowerNum = 3; - g_nSecLength = 8; /* 2^nPowerNum */ + pCalParam->nPowerNum = 3; + pCalParam->nSecLength = 8; /* 2^nPowerNum */ /* dark has at least 2 sections */ - g_nDarkSecLength = g_wDarkCalWidth / 2; + pCalParam->nDarkSecLength = wDarkCalWidth / 2; } else { - g_nPowerNum = 6; - g_nSecLength = 64; /* 2^nPowerNum */ - g_nDarkSecLength = g_wDarkCalWidth / 3; + pCalParam->nPowerNum = 6; + pCalParam->nSecLength = 64; /* 2^nPowerNum */ + pCalParam->nDarkSecLength = wDarkCalWidth / 3; } } else { - g_nPowerNum = 6; - g_nSecLength = 64; /* 2^nPowerNum */ - g_wCalWidth = 10240; - g_nDarkSecLength = g_wDarkCalWidth / 5; + pCalParam->nPowerNum = 6; + pCalParam->nSecLength = 64; /* 2^nPowerNum */ + wCalWidth = 10240; + pCalParam->nDarkSecLength = wDarkCalWidth / 5; } - if (g_nDarkSecLength <= 0) - g_nDarkSecLength = 1; + if (pCalParam->nDarkSecLength <= 0) + pCalParam->nDarkSecLength = 1; - g_wStartPosition = 13 * wResolution / SENSOR_DPI; - g_wCalWidth -= g_wStartPosition; + pCalParam->wStartPosition = 13 * wResolution / SENSOR_DPI; + wCalWidth -= pCalParam->wStartPosition; /* start of find max value */ - g_nSecNum = (int) (g_wCalWidth / g_nSecLength); + pCalParam->nSecNum = wCalWidth / pCalParam->nSecLength; /* start of find min value */ - g_nDarkSecNum = (int) (g_wDarkCalWidth / g_nDarkSecLength); + pCalParam->nDarkSecNum = wDarkCalWidth / pCalParam->nDarkSecLength; } static SANE_Bool -MustScanner_CalculateMaxMin (SANE_Byte * pBuffer, unsigned short * pMaxValue, +MustScanner_CalculateMaxMin (CALIBRATIONPARAM * pCalParam, SANE_Byte * pBuffer, + unsigned short * pMaxValue, unsigned short * pMinValue) { unsigned short *wSecData, *wDarkSecData; int i, j; - wSecData = malloc (g_nSecNum * sizeof (unsigned short)); + wSecData = malloc (pCalParam->nSecNum * sizeof (unsigned short)); if (!wSecData) return SANE_FALSE; - memset (wSecData, 0, g_nSecNum * sizeof (unsigned short)); + memset (wSecData, 0, pCalParam->nSecNum * sizeof (unsigned short)); - for (i = 0; i < g_nSecNum; i++) + for (i = 0; i < pCalParam->nSecNum; i++) { - for (j = 0; j < g_nSecLength; j++) - wSecData[i] += pBuffer[g_wStartPosition + i * g_nSecLength + j]; - wSecData[i] >>= g_nPowerNum; + for (j = 0; j < pCalParam->nSecLength; j++) + wSecData[i] += pBuffer[pCalParam->wStartPosition + + i * pCalParam->nSecLength + j]; + wSecData[i] >>= pCalParam->nPowerNum; } *pMaxValue = wSecData[0]; - for (i = 0; i < g_nSecNum; i++) + for (i = 0; i < pCalParam->nSecNum; i++) { if (*pMaxValue < wSecData[i]) *pMaxValue = wSecData[i]; } free (wSecData); - wDarkSecData = malloc (g_nDarkSecNum * sizeof (unsigned short)); + wDarkSecData = malloc (pCalParam->nDarkSecNum * sizeof (unsigned short)); if (!wDarkSecData) return SANE_FALSE; - memset (wDarkSecData, 0, g_nDarkSecNum * sizeof (unsigned short)); + memset (wDarkSecData, 0, pCalParam->nDarkSecNum * sizeof (unsigned short)); - for (i = 0; i < g_nDarkSecNum; i++) + for (i = 0; i < pCalParam->nDarkSecNum; i++) { - for (j = 0; j < g_nDarkSecLength; j++) - wDarkSecData[i] += pBuffer[g_wStartPosition + i * g_nDarkSecLength + j]; - wDarkSecData[i] /= g_nDarkSecLength; + for (j = 0; j < pCalParam->nDarkSecLength; j++) + wDarkSecData[i] += pBuffer[pCalParam->wStartPosition + + i * pCalParam->nDarkSecLength + j]; + wDarkSecData[i] /= pCalParam->nDarkSecLength; } *pMinValue = wDarkSecData[0]; - for (i = 0; i < g_nDarkSecNum; i++) + for (i = 0; i < pCalParam->nDarkSecNum; i++) { if (*pMinValue > wDarkSecData[i]) *pMinValue = wDarkSecData[i]; @@ -1297,6 +1263,7 @@ MustScanner_CalculateMaxMin (SANE_Byte * pBuffer, unsigned short * pMaxValue, static SANE_Bool MustScanner_AdjustAD (void) { + CALIBRATIONPARAM calParam; SANE_Byte * pCalData; unsigned short wCalWidth; unsigned short wMaxValue[3], wMinValue[3]; @@ -1321,7 +1288,7 @@ MustScanner_AdjustAD (void) g_chip.AD.Direction[i] = DIR_POSITIVE; g_chip.AD.Gain[i] = 0; } - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { g_chip.AD.Offset[0] = 152; /* red */ g_chip.AD.Offset[1] = 56; /* green */ @@ -1334,7 +1301,7 @@ MustScanner_AdjustAD (void) g_chip.AD.Offset[2] = 45; } - if (g_XDpi <= (SENSOR_DPI / 2)) + if (g_Target.wXDpi <= (SENSOR_DPI / 2)) wAdjustADResolution = SENSOR_DPI / 2; else wAdjustADResolution = SENSOR_DPI; @@ -1347,11 +1314,11 @@ MustScanner_AdjustAD (void) return SANE_FALSE; } - if (Asic_SetWindow (&g_chip, g_ssScanSource, SCAN_TYPE_CALIBRATE_DARK, 24, - wAdjustADResolution, wAdjustADResolution, 0, 0, + if (Asic_SetWindow (&g_chip, g_Target.ssScanSource, SCAN_TYPE_CALIBRATE_DARK, + 24, wAdjustADResolution, wAdjustADResolution, 0, 0, wCalWidth, 1) != SANE_STATUS_GOOD) goto error; - MustScanner_PrepareCalculateMaxMin (wAdjustADResolution); + MustScanner_PrepareCalculateMaxMin (wAdjustADResolution, &calParam); for (i = 0; i < 10; i++) { @@ -1378,7 +1345,8 @@ MustScanner_AdjustAD (void) for (j = 0; j < 3; j++) { - if (!MustScanner_CalculateMaxMin (pCalData + (wCalWidth * j), + if (!MustScanner_CalculateMaxMin (&calParam, + pCalData + (wCalWidth * j), &wMaxValue[j], &wMinValue[j])) goto error; @@ -1440,7 +1408,8 @@ MustScanner_AdjustAD (void) for (j = 0; j < 3; j++) { - if (!MustScanner_CalculateMaxMin (pCalData + (wCalWidth * j), + if (!MustScanner_CalculateMaxMin (&calParam, + pCalData + (wCalWidth * j), &wMaxValue[j], &wMinValue[j])) goto error; @@ -1507,7 +1476,8 @@ MustScanner_AdjustAD (void) for (j = 0; j < 3; j++) { - if (!MustScanner_CalculateMaxMin (pCalData + (wCalWidth * j), + if (!MustScanner_CalculateMaxMin (&calParam, + pCalData + (wCalWidth * j), &wMaxValue[j], &wMinValue[j])) goto error; @@ -1579,7 +1549,7 @@ MustScanner_FindTopLeft (unsigned short * pwStartX, unsigned short * pwStartY) return SANE_FALSE; } - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { wCalWidth = FIND_LEFT_TOP_WIDTH_IN_DIP; wCalHeight = FIND_LEFT_TOP_HEIGHT_IN_DIP; @@ -1599,8 +1569,8 @@ MustScanner_FindTopLeft (unsigned short * pwStartX, unsigned short * pwStartY) } nScanBlock = dwTotalSize / CALIBRATION_BLOCK_SIZE; - if (Asic_SetWindow (&g_chip, g_ssScanSource, SCAN_TYPE_CALIBRATE_LIGHT, 8, - FIND_LEFT_TOP_CALIBRATE_RESOLUTION, + if (Asic_SetWindow (&g_chip, g_Target.ssScanSource, SCAN_TYPE_CALIBRATE_LIGHT, + 8, FIND_LEFT_TOP_CALIBRATE_RESOLUTION, FIND_LEFT_TOP_CALIBRATE_RESOLUTION, 0, 0, wCalWidth, wCalHeight) != SANE_STATUS_GOOD) goto error; @@ -1652,7 +1622,7 @@ MustScanner_FindTopLeft (unsigned short * pwStartX, unsigned short * pwStartY) } } - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { /* find top side, i = left side */ for (j = 0; j < wCalHeight; j++) @@ -1781,7 +1751,7 @@ MustScanner_LineCalibration16Bits (void) return SANE_FALSE; } - wCalWidth = g_Width; + wCalWidth = g_Target.wWidth; wCalHeight = LINE_CALIBRATION_HEIGHT; dwTotalSize = wCalWidth * wCalHeight * 3 * 2; DBG (DBG_FUNC, "MustScanner_LineCalibration16Bits: wCalWidth = %d, " \ @@ -1797,9 +1767,9 @@ MustScanner_LineCalibration16Bits (void) /* read white level data */ SetAFEGainOffset (&g_chip); - if (Asic_SetWindow (&g_chip, g_ssScanSource, SCAN_TYPE_CALIBRATE_LIGHT, 48, - g_XDpi, 600, g_X, 0, wCalWidth, wCalHeight) != - SANE_STATUS_GOOD) + if (Asic_SetWindow (&g_chip, g_Target.ssScanSource, SCAN_TYPE_CALIBRATE_LIGHT, + 48, g_Target.wXDpi, 600, g_Target.wX, 0, + wCalWidth, wCalHeight) != SANE_STATUS_GOOD) goto error; if (Asic_ScanStart (&g_chip) != SANE_STATUS_GOOD) @@ -1814,12 +1784,12 @@ MustScanner_LineCalibration16Bits (void) /* read dark level data */ SetAFEGainOffset (&g_chip); - if (Asic_SetWindow (&g_chip, g_ssScanSource, SCAN_TYPE_CALIBRATE_DARK, 48, - g_XDpi, 600, g_X, 0, wCalWidth, wCalHeight) != - SANE_STATUS_GOOD) + if (Asic_SetWindow (&g_chip, g_Target.ssScanSource, SCAN_TYPE_CALIBRATE_DARK, + 48, g_Target.wXDpi, 600, g_Target.wX, 0, wCalWidth, + wCalHeight) != SANE_STATUS_GOOD) goto error; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { if (Asic_TurnLamp (&g_chip, SANE_FALSE) != SANE_STATUS_GOOD) goto error; @@ -1842,7 +1812,7 @@ MustScanner_LineCalibration16Bits (void) if (Asic_ScanStop (&g_chip) != SANE_STATUS_GOOD) goto error; - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { if (Asic_TurnLamp (&g_chip, SANE_TRUE) != SANE_STATUS_GOOD) goto error; @@ -1903,7 +1873,7 @@ MustScanner_LineCalibration16Bits (void) } /* sum of dark level for all pixels */ - if ((g_XDpi == SENSOR_DPI) && ((i % 2) == 0)) + if ((g_Target.wXDpi == SENSOR_DPI) && ((i % 2) == 0)) { /* compute dark shading table with mean */ dwREvenDarkLevel += MustScanner_FiltLower (pRDarkSort, wCalHeight, @@ -1924,7 +1894,7 @@ MustScanner_LineCalibration16Bits (void) } } - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) { dwRDarkLevel /= wCalWidth / 2; dwGDarkLevel /= wCalWidth / 2; @@ -1939,7 +1909,7 @@ MustScanner_LineCalibration16Bits (void) dwGDarkLevel /= wCalWidth; dwBDarkLevel /= wCalWidth; } - if (g_ssScanSource != SS_REFLECTIVE) + if (g_Target.ssScanSource != SS_REFLECTIVE) { dwRDarkLevel -= 512; dwGDarkLevel -= 512; @@ -1964,11 +1934,11 @@ MustScanner_LineCalibration16Bits (void) pBWhiteSort[j] += pWhiteData[j * wCalWidth * 2 * 3 + i * 6 + 5] << 8; } - if ((g_XDpi == SENSOR_DPI) && ((i % 2) == 0)) + if ((g_Target.wXDpi == SENSOR_DPI) && ((i % 2) == 0)) { pDarkShading[i * 3] = dwREvenDarkLevel; pDarkShading[i * 3 + 1] = dwGEvenDarkLevel; - if (g_ssScanSource == SS_POSITIVE) + if (g_Target.ssScanSource == SS_POSITIVE) pDarkShading[i * 3 + 1] *= 0.78; pDarkShading[i * 3 + 2] = dwBEvenDarkLevel; } @@ -1976,7 +1946,7 @@ MustScanner_LineCalibration16Bits (void) { pDarkShading[i * 3] = dwRDarkLevel; pDarkShading[i * 3 + 1] = dwGDarkLevel; - if (g_ssScanSource == SS_POSITIVE) + if (g_Target.ssScanSource == SS_POSITIVE) pDarkShading[i * 3 + 1] *= 0.78; pDarkShading[i * 3 + 2] = dwBDarkLevel; } @@ -1988,7 +1958,7 @@ MustScanner_LineCalibration16Bits (void) wBWhiteLevel = MustScanner_FiltLower (pBWhiteSort, wCalHeight, 20, 30) - pDarkShading[i * 3 + 2]; - switch (g_ssScanSource) + switch (g_Target.ssScanSource) { case SS_REFLECTIVE: if (wRWhiteLevel > 0) @@ -2059,8 +2029,8 @@ MustScanner_LineCalibration16Bits (void) free (pGDarkSort); free (pBDarkSort); - if (Asic_SetShadingTable (&g_chip, pWhiteShading, pDarkShading, g_XDpi, - wCalWidth) != SANE_STATUS_GOOD) + if (Asic_SetShadingTable (&g_chip, pWhiteShading, pDarkShading, + g_Target.wXDpi, wCalWidth) != SANE_STATUS_GOOD) goto error; /* TODO: memory leak */ free (pWhiteShading); @@ -2081,7 +2051,7 @@ error: SANE_Bool MustScanner_SetupScan (TARGETIMAGE * pTarget) { - unsigned short targetY; + unsigned short finalY; SANE_Byte bScanBits; DBG (DBG_FUNC, "MustScanner_SetupScan: call in\n"); @@ -2092,19 +2062,16 @@ MustScanner_SetupScan (TARGETIMAGE * pTarget) return SANE_FALSE; } - g_ScanMode = pTarget->cmColorMode; - g_XDpi = pTarget->wDpi; - g_YDpi = pTarget->wDpi; - g_Width = (pTarget->wWidth + 15) & ~15; /* real scan width */ - g_Height = pTarget->wHeight; - g_SWWidth = pTarget->wWidth; - g_SWHeight = pTarget->wHeight; - g_wLineartThreshold = pTarget->wLineartThreshold; - g_ssScanSource = pTarget->ssScanSource; + g_Target = *pTarget; + g_SWWidth = g_Target.wWidth; + g_SWHeight = g_Target.wHeight; + /* set real scan width according to ASIC limit: width must be 8x */ + g_Target.wWidth = (g_Target.wWidth + 15) & ~15; /* create gamma table */ - if ((pTarget->cmColorMode == CM_GRAY8) || - (pTarget->cmColorMode == CM_RGB24)) + /* TODO: move into separate function */ + if ((g_Target.cmColorMode == CM_GRAY8) || + (g_Target.cmColorMode == CM_RGB24)) { unsigned short i; SANE_Byte bGammaData; @@ -2124,8 +2091,8 @@ MustScanner_SetupScan (TARGETIMAGE * pTarget) g_pGammaTable[i + 8192] = bGammaData; } } - else if ((pTarget->cmColorMode == CM_GRAY16) || - (pTarget->cmColorMode == CM_RGB48)) + else if ((g_Target.cmColorMode == CM_GRAY16) || + (g_Target.cmColorMode == CM_RGB48)) { unsigned int i; unsigned short wGammaData; @@ -2152,12 +2119,12 @@ MustScanner_SetupScan (TARGETIMAGE * pTarget) g_pGammaTable = NULL; } - switch (g_YDpi) + switch (g_Target.wYDpi) { case 1200: g_wPixelDistance = 4; /* even & odd sensor problem */ g_wLineDistance = 24; - g_Height += g_wPixelDistance; + g_Target.wHeight += g_wPixelDistance; break; case 600: g_wPixelDistance = 0; /* no even & odd problem */ @@ -2181,41 +2148,41 @@ MustScanner_SetupScan (TARGETIMAGE * pTarget) g_wLineDistance = 0; } - DBG (DBG_FUNC, "MustScanner_SetupScan: g_YDpi=%d\n", g_YDpi); + DBG (DBG_FUNC, "MustScanner_SetupScan: wYDpi=%d\n", g_Target.wYDpi); DBG (DBG_FUNC, "MustScanner_SetupScan: g_wLineDistance=%d\n", g_wLineDistance); DBG (DBG_FUNC, "MustScanner_SetupScan: g_wPixelDistance=%d\n", g_wPixelDistance); - switch (g_ScanMode) + switch (g_Target.cmColorMode) { case CM_RGB48: - g_BytesPerRow = 6 * g_Width; /* ASIC limit: width must be 8x */ - g_SWBytesPerRow = 6 * g_SWWidth; /* ASIC limit: width must be 8x */ - g_Height += g_wLineDistance * 2; + g_BytesPerRow = 6 * g_Target.wWidth; + g_SWBytesPerRow = 6 * g_SWWidth; + g_Target.wHeight += g_wLineDistance * 2; bScanBits = 48; break; case CM_RGB24: - g_BytesPerRow = 3 * g_Width; + g_BytesPerRow = 3 * g_Target.wWidth; g_SWBytesPerRow = 3 * g_SWWidth; - g_Height += g_wLineDistance * 2; + g_Target.wHeight += g_wLineDistance * 2; bScanBits = 24; break; case CM_GRAY16: - g_BytesPerRow = 2 * g_Width; + g_BytesPerRow = 2 * g_Target.wWidth; g_SWBytesPerRow = 2 * g_SWWidth; bScanBits = 16; break; case CM_GRAY8: case CM_TEXT: default: - g_BytesPerRow = g_Width; + g_BytesPerRow = g_Target.wWidth; g_SWBytesPerRow = g_SWWidth; bScanBits = 8; break; } - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { if (!MustScanner_PowerControl (SANE_TRUE, SANE_FALSE)) return SANE_FALSE; @@ -2232,97 +2199,103 @@ MustScanner_SetupScan (TARGETIMAGE * pTarget) g_bOpened = SANE_TRUE; /* find left & top side */ - if (g_ssScanSource != SS_REFLECTIVE) + if (g_Target.ssScanSource != SS_REFLECTIVE) if (Asic_MotorMove (&g_chip, SANE_TRUE, TRAN_START_POS) != SANE_STATUS_GOOD) return SANE_FALSE; - if (g_XDpi == SENSOR_DPI) + if (g_Target.wXDpi == SENSOR_DPI) { - g_XDpi = SENSOR_DPI / 2; + g_Target.wXDpi = SENSOR_DPI / 2; if (!MustScanner_AdjustAD ()) return SANE_FALSE; - if (!MustScanner_FindTopLeft (&g_X, &g_Y)) + if (!MustScanner_FindTopLeft (&g_Target.wX, &g_Target.wY)) { - g_X = 187; - g_Y = 43; + g_Target.wX = 187; + g_Target.wY = 43; } - g_XDpi = SENSOR_DPI; + g_Target.wXDpi = SENSOR_DPI; if (!MustScanner_AdjustAD ()) return SANE_FALSE; - g_X = g_X * SENSOR_DPI / FIND_LEFT_TOP_CALIBRATE_RESOLUTION + pTarget->wX; - if (g_ssScanSource == SS_REFLECTIVE) + g_Target.wX = g_Target.wX * SENSOR_DPI / + FIND_LEFT_TOP_CALIBRATE_RESOLUTION + pTarget->wX; + if (g_Target.ssScanSource == SS_REFLECTIVE) { - g_X += 47; - g_Y = g_Y * SENSOR_DPI / FIND_LEFT_TOP_CALIBRATE_RESOLUTION + - pTarget->wY * SENSOR_DPI / g_YDpi + 47; + g_Target.wX += 47; + g_Target.wY = g_Target.wY * SENSOR_DPI / + FIND_LEFT_TOP_CALIBRATE_RESOLUTION + + pTarget->wY * SENSOR_DPI / g_Target.wYDpi + 47; } } else { if (!MustScanner_AdjustAD ()) return SANE_FALSE; - if (!MustScanner_FindTopLeft (&g_X, &g_Y)) + if (!MustScanner_FindTopLeft (&g_Target.wX, &g_Target.wY)) { - g_X = 187; - g_Y = 43; + g_Target.wX = 187; + g_Target.wY = 43; } - g_X += pTarget->wX * (SENSOR_DPI / 2) / g_XDpi; - if (g_ssScanSource == SS_REFLECTIVE) + g_Target.wX += pTarget->wX * (SENSOR_DPI / 2) / g_Target.wXDpi; + if (g_Target.ssScanSource == SS_REFLECTIVE) { - if (g_XDpi != 75) - g_X += 23; - g_Y = g_Y * SENSOR_DPI / FIND_LEFT_TOP_CALIBRATE_RESOLUTION + - pTarget->wY * SENSOR_DPI / g_YDpi + 47; + if (g_Target.wXDpi != 75) + g_Target.wX += 23; + g_Target.wY = g_Target.wY * SENSOR_DPI / + FIND_LEFT_TOP_CALIBRATE_RESOLUTION + + pTarget->wY * SENSOR_DPI / g_Target.wYDpi + 47; } else { - if (g_XDpi == 75) - g_X -= 23; + if (g_Target.wXDpi == 75) + g_Target.wX -= 23; } } - DBG (DBG_FUNC, "MustScanner_SetupScan: before line calibration g_X=%d," \ - "g_Y=%d\n", g_X, g_Y); + DBG (DBG_FUNC, "MustScanner_SetupScan: before line calibration wX=%d," \ + "wY=%d\n", g_Target.wX, g_Target.wY); if (!MustScanner_LineCalibration16Bits ()) return SANE_FALSE; DBG (DBG_FUNC, "MustScanner_SetupScan: after " \ - "MustScanner_LineCalibration16Bits g_X=%d,g_Y=%d\n", g_X, g_Y); + "MustScanner_LineCalibration16Bits wX=%d,wY=%d\n", + g_Target.wX, g_Target.wY); - DBG (DBG_FUNC, "MustScanner_SetupScan: bScanBits=%d, g_XDpi=%d, " \ - "g_YDpi=%d, g_X=%d, g_Y=%d, g_Width=%d, g_Height=%d\n", - bScanBits, g_XDpi, g_YDpi, g_X, g_Y, g_Width, g_Height); + DBG (DBG_FUNC, "MustScanner_SetupScan: bScanBits=%d, wXDpi=%d, " \ + "wYDpi=%d, wX=%d, wY=%d, wWidth=%d, wHeight=%d\n", + bScanBits, g_Target.wXDpi, g_Target.wYDpi, g_Target.wX, g_Target.wY, + g_Target.wWidth, g_Target.wHeight); - if (g_ssScanSource == SS_REFLECTIVE) + if (g_Target.ssScanSource == SS_REFLECTIVE) { - targetY = 300; + finalY = 300; } else { - g_Y = pTarget->wY * SENSOR_DPI / g_YDpi + (300 - 40) + 189; - targetY = 360; + g_Target.wY = pTarget->wY * SENSOR_DPI / g_Target.wYDpi + (300 - 40) +189; + finalY = 360; } - if (g_Y > targetY) + if (g_Target.wY > finalY) { - if (Asic_MotorMove (&g_chip, SANE_TRUE, g_Y - targetY) != + if (Asic_MotorMove (&g_chip, SANE_TRUE, g_Target.wY - finalY) != SANE_STATUS_GOOD) return SANE_FALSE; } else { - if (Asic_MotorMove (&g_chip, SANE_FALSE, targetY - g_Y) != + if (Asic_MotorMove (&g_chip, SANE_FALSE, finalY - g_Target.wY) != SANE_STATUS_GOOD) return SANE_FALSE; } - g_Y = targetY; + g_Target.wY = finalY; - if (Asic_SetWindow (&g_chip, g_ssScanSource, SCAN_TYPE_NORMAL, bScanBits, - g_XDpi, g_YDpi, g_X, g_Y, g_Width, g_Height) != + if (Asic_SetWindow (&g_chip, g_Target.ssScanSource, SCAN_TYPE_NORMAL, + bScanBits, g_Target.wXDpi, g_Target.wYDpi, g_Target.wX, + g_Target.wY, g_Target.wWidth, g_Target.wHeight) != SANE_STATUS_GOOD) return SANE_FALSE; diff --git a/backend/mustek_usb2_high.h b/backend/mustek_usb2_high.h index cdfc4bec6..442cb5cb6 100644 --- a/backend/mustek_usb2_high.h +++ b/backend/mustek_usb2_high.h @@ -65,15 +65,23 @@ typedef struct { COLORMODE cmColorMode; SCANSOURCE ssScanSource; - unsigned short wDpi; + unsigned short wXDpi; + unsigned short wYDpi; unsigned short wX; unsigned short wY; unsigned short wWidth; unsigned short wHeight; unsigned short wLineartThreshold; - unsigned int dwBytesPerRow; } TARGETIMAGE; +typedef struct +{ + int nSecLength, nDarkSecLength; + int nSecNum, nDarkSecNum; + int nPowerNum; + unsigned short wStartPosition; +} CALIBRATIONPARAM; + #define _MAX(a,b) ((a)>(b)?(a):(b)) #define _MIN(a,b) ((a)<(b)?(a):(b))