diff options
Diffstat (limited to 'backend/mustek_usb2_transparent.c')
| -rw-r--r-- | backend/mustek_usb2_transparent.c | 1745 |
1 files changed, 1745 insertions, 0 deletions
diff --git a/backend/mustek_usb2_transparent.c b/backend/mustek_usb2_transparent.c new file mode 100644 index 0000000..43bda0b --- /dev/null +++ b/backend/mustek_usb2_transparent.c @@ -0,0 +1,1745 @@ +/* sane - Scanner Access Now Easy. + + Copyright (C) 2005 Mustek. + Originally maintained by Mustek + Author:Jack Roy 2005.5.24 + + This file is part of the SANE package. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + This file implements a SANE backend for the Mustek BearPaw 2448 TA Pro + and similar USB2 scanners. */ + + +/* forward declarations */ +static SANE_Bool Transparent_Reset (void); +static SANE_Bool Transparent_ScanSuggest (PTARGETIMAGE pTarget, PSUGGESTSETTING pSuggest); +static SANE_Bool Transparent_SetupScan (COLORMODE ColorMode, unsigned short XDpi, unsigned short YDpi, + SANE_Bool isInvert, unsigned short X, unsigned short Y, unsigned short Width, + unsigned short Height); +static SANE_Bool Transparent_StopScan (void); +static SANE_Bool Transparent_GetRows (SANE_Byte * lpBlock, unsigned short * Rows, SANE_Bool isOrderInvert); +static SANE_Bool Transparent_AdjustAD (void); +static SANE_Bool Transparent_FindTopLeft (unsigned short * lpwStartX, unsigned short * lpwStartY); +static SANE_Bool Transparent_LineCalibration16Bits (unsigned short wTAShadingMinus); +static SANE_Bool Transparent_PrepareScan (void); + + +/*function description*/ + +/********************************************************************** +Author: Jack Date: 2005/05/13 +Routine Description: + reset the scanner +Parameters: + none +Return value: + if operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_Reset () +{ + DBG (DBG_FUNC, "Transparent_Reset: call in\n"); + + if (g_bOpened) + { + DBG (DBG_FUNC, "Transparent_Reset: scanner has been opened\n"); + return FALSE; + } + if (STATUS_GOOD != Asic_Open (&g_chip, g_pDeviceFile)) + { + DBG (DBG_FUNC, "Transparent_Reset: can not open scanner\n"); + return FALSE; + } + + if (STATUS_GOOD != Asic_Reset (&g_chip)) + { + DBG (DBG_FUNC, "Reflective_Reset: Asic_Reset return error\n"); + return FALSE; + } + + if (STATUS_GOOD != Asic_SetSource (&g_chip, LS_POSITIVE)) + { + DBG (DBG_FUNC, "Reflective_Reset: Asic_SetSource return error\n"); + return FALSE; + } + + if (STATUS_GOOD != Asic_TurnLamp (&g_chip, FALSE)) + { + DBG (DBG_FUNC, "Reflective_Reset: Asic_TurnLamp return error\n"); + return FALSE; + } + + if (STATUS_GOOD != Asic_TurnTA (&g_chip, TRUE)) + { + DBG (DBG_FUNC, "Reflective_Reset: Asic_TurnTA return error\n"); + return FALSE; + } + + if (STATUS_GOOD != Asic_Close (&g_chip)) + { + DBG (DBG_FUNC, "Reflective_Reset: Asic_Close return error\n"); + return FALSE; + } + + g_Y = 0; + g_wLineartThreshold = 128; + g_dwTotalTotalXferLines = 0; + g_bFirstReadImage = TRUE; + g_pGammaTable = NULL; + + DBG (DBG_FUNC, "Transparent_Reset: leave Transparent_Reset\n"); + return TRUE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/13 +Routine Description: + get suggest parameter of scaning +Parameters: + pTarget: the information of scaning + pSuggest: the suggest parameter of scaning +Return value: + if operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_ScanSuggest (PTARGETIMAGE pTarget, PSUGGESTSETTING pSuggest) +{ + unsigned short wMaxWidth, wMaxHeight; + int i; + + DBG (DBG_FUNC, "Transparent_ScanSuggest: call in\n"); + + for (i = 0; s_wOpticalYDpi[i] != 0; i++) + { + if (s_wOpticalYDpi[i] <= pTarget->wDpi) + { + pSuggest->wYDpi = s_wOpticalYDpi[i]; + break; + } + } + if (s_wOpticalYDpi[i] == 0) + { + i--; + pSuggest->wYDpi = s_wOpticalYDpi[i]; + } + + for (i = 0; s_wOpticalXDpi[i] != 0; i++) + { + if (s_wOpticalXDpi[i] <= pTarget->wDpi) + { + pSuggest->wXDpi = s_wOpticalXDpi[i]; + break; + } + } + if (s_wOpticalXDpi[i] == 0) + { + i--; + pSuggest->wXDpi = s_wOpticalXDpi[i]; + } + + pSuggest->wX = + (unsigned short) (((unsigned int) (pTarget->wX) * (unsigned int) (pSuggest->wXDpi)) / + (unsigned int) (pTarget->wDpi)); + pSuggest->wY = + (unsigned short) (((unsigned int) (pTarget->wY) * (unsigned int) (pSuggest->wYDpi)) / + (unsigned int) (pTarget->wDpi)); + pSuggest->wWidth = + (unsigned short) (((unsigned int) (pTarget->wWidth) * (unsigned int) (pSuggest->wXDpi)) / + (unsigned int) (pTarget->wDpi)); + pSuggest->wHeight = + (unsigned short) (((unsigned int) (pTarget->wHeight) * (unsigned int) (pSuggest->wYDpi)) / + (unsigned int) (pTarget->wDpi)); + + pSuggest->wWidth = (pSuggest->wWidth / 2) * 2; + + if (pTarget->cmColorMode == CM_TEXT) + { + pSuggest->wWidth = ((pSuggest->wWidth + 7) >> 3) << 3; + if (pSuggest->wWidth < 8) + pSuggest->wWidth = 8; + } + + g_Width = ((pSuggest->wWidth + 15) >> 4) << 4; /* Real Scan Width */ + g_Height = pSuggest->wHeight; + + wMaxWidth = (MAX_SCANNING_WIDTH * pSuggest->wXDpi) / 300; + wMaxHeight = (MAX_SCANNING_HEIGHT * pSuggest->wYDpi) / 300; + + if (pTarget->cmColorMode == CM_TEXT) + wMaxWidth = (wMaxWidth >> 3) << 3; + + if (pSuggest->wWidth > wMaxWidth) + pSuggest->wWidth = wMaxWidth; + if (pSuggest->wHeight > wMaxHeight) + pSuggest->wHeight = wMaxHeight; + + if (pTarget->isOptimalSpeed) + { + DBG (DBG_FUNC, "Transparent_ScanSuggest: isOptimalSpeed is true\n"); + + switch (pTarget->cmColorMode) + { + case CM_RGB48: + pSuggest->cmScanMode = CM_RGB48; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 6); + break; + case CM_RGB24: + pSuggest->cmScanMode = CM_RGB24ext; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 3); + break; + + case CM_GRAY16: + pSuggest->cmScanMode = CM_GRAY16ext; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 2); + break; + case CM_GRAY8: + pSuggest->cmScanMode = CM_GRAY8ext; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth)); + break; + case CM_TEXT: + pSuggest->cmScanMode = CM_TEXT; + pSuggest->dwBytesPerRow = (unsigned int) (pSuggest->wWidth) / 8; + break; + default: + break; + } + } + else + { + DBG (DBG_FUNC, "Transparent_ScanSuggest: isOptimalSpeed not true\n"); + + switch (pTarget->cmColorMode) + { + case CM_RGB48: + pSuggest->cmScanMode = CM_RGB48; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 6); + break; + case CM_RGB24: + pSuggest->cmScanMode = CM_RGB24ext; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 3); + break; + case CM_GRAY16: + pSuggest->cmScanMode = CM_GRAY16ext; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth) * 2); + break; + case CM_GRAY8: + pSuggest->cmScanMode = CM_GRAY8ext; + pSuggest->dwBytesPerRow = (unsigned int) ((pSuggest->wWidth)); + break; + case CM_TEXT: + pSuggest->cmScanMode = CM_TEXT; + pSuggest->dwBytesPerRow = (unsigned int) (pSuggest->wWidth) / 8; + break; + default: + break; + } + } + + DBG (DBG_FUNC, "Transparent_ScanSuggest: leave Transparent_ScanSuggest\n"); + return TRUE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/13 +Routine Description: + setup scanning process +Parameters: + ColorMode: ScanMode of Scanning, CM_RGB48, CM_GRAY and so on + XDpi: X Resolution + YDpi: Y Resolution + isInvert: the RGB order + X: X start coordinate + Y: Y start coordinate + Width: Width of Scan Image + Height: Height of Scan Image +Return value: + if the operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_SetupScan (COLORMODE ColorMode, unsigned short XDpi, unsigned short YDpi, + SANE_Bool isInvert, unsigned short X, unsigned short Y, unsigned short Width, unsigned short Height) +{ + SANE_Bool hasTA; + unsigned short wTAShadingMinus = 0; + + isInvert = isInvert; + DBG (DBG_FUNC, "Transparent_SetupScan: call in\n"); + + if (g_bOpened) + { + DBG (DBG_FUNC, "Transparent_SetupScan: scanner has been opened\n"); + return FALSE; + } + + if (!g_bPrepared) + { + DBG (DBG_FUNC, "Transparent_SetupScan: scanner not prepared\n"); + return FALSE; + } + + g_ScanMode = ColorMode; + g_XDpi = XDpi; + g_YDpi = YDpi; + g_SWWidth = Width; + g_SWHeight = Height; + + switch (g_YDpi) + { + case 1200: + g_wPixelDistance = 4; + g_wLineDistance = 24; + g_Height += g_wPixelDistance; + break; + case 600: + g_wPixelDistance = 0; + g_wLineDistance = 12; + g_Height += g_wPixelDistance; + break; + case 300: + g_wPixelDistance = 0; + g_wLineDistance = 6; + break; + case 150: + g_wPixelDistance = 0; + g_wLineDistance = 3; + break; + case 75: + case 50: + g_wPixelDistance = 0; + g_wLineDistance = 1; + break; + default: + g_wLineDistance = 0; + + } + + DBG (DBG_FUNC, "Transparent_SetupScan: g_YDpi=%d\n", g_YDpi); + DBG (DBG_FUNC, "Transparent_SetupScan: g_wLineDistance=%d\n", + g_wLineDistance); + DBG (DBG_FUNC, "Transparent_SetupScan: g_wPixelDistance=%d\n", + g_wPixelDistance); + + switch (g_ScanMode) + { + 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_bScanBits = 48; + g_Height += g_wLineDistance * 2; + break; + case CM_RGB24ext: + g_BytesPerRow = 3 * g_Width; /*ASIC limit : width must be 8x */ + g_SWBytesPerRow = 3 * g_SWWidth; + g_bScanBits = 24; + g_Height += g_wLineDistance * 2; + break; + case CM_GRAY16ext: + g_BytesPerRow = 2 * g_Width; /* ASIC limit : width must be 8x */ + g_SWBytesPerRow = 2 * g_SWWidth; + g_bScanBits = 16; + break; + case CM_GRAY8ext: + case CM_TEXT: + g_BytesPerRow = g_Width; /*ASIC limit : width must be 8x */ + g_SWBytesPerRow = g_SWWidth; + g_bScanBits = 8; + break; + default: + break; + } + + if (Asic_Open (&g_chip, g_pDeviceFile) != STATUS_GOOD) + { + DBG (DBG_FUNC, "Transparent_SetupScan: Asic_Open return error\n"); + return FALSE; + } + + g_bOpened = TRUE; + + if (STATUS_GOOD != Asic_TurnLamp (&g_chip, FALSE)) + { + DBG (DBG_FUNC, "Transparent_SetupScan: Asic_TurnLamp return error\n"); + return FALSE; + } + + if (Asic_IsTAConnected (&g_chip, &hasTA) != STATUS_GOOD) + { + DBG (DBG_FUNC, + "Transparent_SetupScan: Asic_IsTAConnected return error\n"); + return FALSE; + } + if (!hasTA) + { + DBG (DBG_FUNC, "Transparent_SetupScan: no TA device\n"); + return FALSE; + } + + if (Asic_TurnTA (&g_chip, TRUE) != STATUS_GOOD) + { + DBG (DBG_FUNC, "Transparent_SetupScan: Asic_TurnTA return error\n"); + return FALSE; + } + + /* Begin Find Left&Top Side */ + Asic_MotorMove (&g_chip, TRUE, TRAN_START_POS); + + if (1200 == g_XDpi) + { + wTAShadingMinus = 1680; + g_XDpi = 600; + Transparent_AdjustAD (); + Transparent_FindTopLeft (&g_X, &g_Y); + + g_XDpi = 1200; + Transparent_AdjustAD (); + } + else + { + wTAShadingMinus = 840; + Transparent_AdjustAD (); + Transparent_FindTopLeft (&g_X, &g_Y); + } + + DBG (DBG_FUNC, + "Transparent_SetupScan: after find top and left g_X=%d, g_Y=%d\n", g_X, + g_Y); + + if (1200 == g_XDpi) + { + g_X = + g_X * 1200 / FIND_LEFT_TOP_CALIBRATE_RESOLUTION + X * 1200 / g_XDpi; + } + else + { + if (75 == g_XDpi) + { + g_X = g_X + X * 600 / g_XDpi - 23; + } + else + { + g_X = g_X + X * 600 / g_XDpi; + } + } + + DBG (DBG_FUNC, + "Transparent_SetupScan: before line calibration,g_X=%d,g_Y=%d\n", g_X, + g_Y); + + Transparent_LineCalibration16Bits (wTAShadingMinus); + + DBG (DBG_FUNC, + "Transparent_SetupScan: after Reflective_LineCalibration16Bits,g_X=%d,g_Y=%d\n", + g_X, g_Y); + + DBG (DBG_FUNC, + "Transparent_SetupScan: g_bScanBits=%d, g_XDpi=%d, g_YDpi=%d, g_X=%d, g_Y=%d, g_Width=%d, g_Height=%d\n", + g_bScanBits, g_XDpi, g_YDpi, g_X, g_Y, g_Width, g_Height); + + g_Y = Y * 1200 / g_YDpi + (300 - 40) + 189; + Asic_MotorMove (&g_chip, TRUE, g_Y - 360); + g_Y = 360; + + Asic_SetWindow (&g_chip, g_bScanBits, g_XDpi, g_YDpi, g_X, g_Y, g_Width, + g_Height); + + DBG (DBG_FUNC, "Transparent_SetupScan: leave Transparent_SetupScan\n"); + return Transparent_PrepareScan (); +} + +/********************************************************************** +Author: Jack Date: 2005/05/14 +Routine Description: + Stop scan +Parameters: + none +Return value: + if operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_StopScan () +{ + DBG (DBG_FUNC, "Transparent_StopScan: call in\n"); + + if (!g_bOpened) + { + return FALSE; + } + if (!g_bPrepared) + { + return FALSE; + } + + g_isCanceled = TRUE; + + pthread_cancel (g_threadid_readimage); + pthread_join (g_threadid_readimage, NULL); + + DBG (DBG_FUNC, "Transparent_StopScan: thread exit\n"); + + Asic_ScanStop (&g_chip); + Asic_Close (&g_chip); + g_bOpened = FALSE; + + DBG (DBG_FUNC, "Transparent_StopScan: leave Transparent_StopScan\n"); + return TRUE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/15 +Routine Description: + Get the data of image +Parameters: + lpBlock: the data of image + Rows: the rows of image + isOrderInvert: the RGB order +Return value: + if the operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_GetRows (SANE_Byte * lpBlock, unsigned short * Rows, SANE_Bool isOrderInvert) +{ + DBG (DBG_FUNC, "Transparent_GetRows: call in\n"); + + if (!g_bOpened) + { + return FALSE; + } + if (!g_bPrepared) + { + return FALSE; + } + + switch (g_ScanMode) + { + case CM_RGB48: + if (g_XDpi == 1200) + return MustScanner_GetRgb48BitLine1200DPI (lpBlock, isOrderInvert, + Rows); + else + return MustScanner_GetRgb48BitLine (lpBlock, isOrderInvert, Rows); + + case CM_RGB24ext: + if (g_XDpi == 1200) + return MustScanner_GetRgb24BitLine1200DPI (lpBlock, isOrderInvert, + Rows); + else + return MustScanner_GetRgb24BitLine (lpBlock, isOrderInvert, Rows); + + case CM_GRAY16ext: + if (g_XDpi == 1200) + return MustScanner_GetMono16BitLine1200DPI (lpBlock, isOrderInvert, + Rows); + else + return MustScanner_GetMono16BitLine (lpBlock, isOrderInvert, Rows); + + case CM_GRAY8ext: + if (g_XDpi == 1200) + return MustScanner_GetMono8BitLine1200DPI (lpBlock, isOrderInvert, + Rows); + else + return MustScanner_GetMono8BitLine (lpBlock, isOrderInvert, Rows); + + case CM_TEXT: + if (g_XDpi == 1200) + return MustScanner_GetMono1BitLine1200DPI (lpBlock, isOrderInvert, + Rows); + else + return MustScanner_GetMono1BitLine (lpBlock, isOrderInvert, Rows); + default: + return FALSE; + } + return FALSE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/13 +Routine Description: + To adjust the value of offset gain of R/G/B +Parameters: + none +Return value: + if operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_AdjustAD () +{ + SANE_Byte * lpCalData; + unsigned short wCalWidth; + int nTimesOfCal; + unsigned short wMaxValueR, wMinValueR, wMaxValueG, wMinValueG, wMaxValueB, wMinValueB; +#if 0 + float fRFactor = 1.0; + float fGFactor = 1.0; + float fBFactor = 1.0; + SANE_Byte bDarkMaxLevel; + SANE_Byte bDarkMinLevel; + SANE_Byte bLastMinR, bLastROffset, bROffsetUpperBound = 255, bROffsetLowerBound = + 0; + SANE_Byte bLastMinG, bLastGOffset, bGOffsetUpperBound = 255, bGOffsetLowerBound = + 0; + SANE_Byte bLastMinB, bLastBOffset, bBOffsetUpperBound = 255, bBOffsetLowerBound = + 0; +#endif + unsigned short wAdjustADResolution; + + DBG (DBG_FUNC, "Transparent_AdjustAD: call in\n"); + if (!g_bOpened) + { + return FALSE; + } + if (!g_bPrepared) + { + return FALSE; + } + + + g_chip.AD.DirectionR = R_DIRECTION; + g_chip.AD.DirectionG = G_DIRECTION; + g_chip.AD.DirectionB = B_DIRECTION; + g_chip.AD.GainR = R_GAIN; + g_chip.AD.GainG = G_GAIN; + g_chip.AD.GainB = B_GAIN; + g_chip.AD.OffsetR = 159; + g_chip.AD.OffsetG = 50; + g_chip.AD.OffsetB = 45; + + if (g_XDpi <= 600) + { + wAdjustADResolution = 600; + } + else + { + wAdjustADResolution = 1200; + } + + wCalWidth = 10240; + + lpCalData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * wCalWidth * 3); + if (lpCalData == NULL) + { + return FALSE; + } + + Asic_SetMotorType (&g_chip, FALSE, TRUE); + + Asic_SetCalibrate (&g_chip, 24, wAdjustADResolution, wAdjustADResolution, 0, + 0, wCalWidth, 1, FALSE); + MustScanner_PrepareCalculateMaxMin (wAdjustADResolution); + nTimesOfCal = 0; + +#ifdef DEBUG_SAVE_IMAGE + Asic_SetAFEGainOffset (&g_chip); + Asic_ScanStart (&g_chip); + Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24); + Asic_ScanStop (&g_chip); + + FILE *stream = NULL; + SANE_Byte * lpBuf = (SANE_Byte *) malloc (50); + if (NULL == lpBuf) + { + DBG (DBG_FUNC, + "Transparent_AdjustAD: Leave Transparent_AdjustAD for malloc fail!\n"); + return FALSE; + } + memset (lpBuf, 0, 50); + stream = fopen ("/root/AD(Tra).pnm", "wb+\n"); + sprintf (lpBuf, "P6\n%d %d\n255\n", wCalWidth, 3); + fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream); + fwrite (lpCalData, sizeof (SANE_Byte), wCalWidth * 3, stream); + fclose (stream); + free (lpBuf); +#endif + + do + { + DBG (DBG_FUNC, + "Transparent_AdjustAD: run in first adjust offset do-while\n"); + Asic_SetAFEGainOffset (&g_chip); + Asic_ScanStart (&g_chip); + Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24); + Asic_ScanStop (&g_chip); + + MustScanner_CalculateMaxMin (lpCalData, &wMaxValueR, &wMinValueR, + wAdjustADResolution); + MustScanner_CalculateMaxMin (lpCalData + wCalWidth, &wMaxValueG, + &wMinValueG, wAdjustADResolution); + MustScanner_CalculateMaxMin (lpCalData + wCalWidth * 2, &wMaxValueB, + &wMinValueB, wAdjustADResolution); + + if (g_chip.AD.DirectionR == 0) + { + if (wMinValueR > 15) + { + if (g_chip.AD.OffsetR < 8) + g_chip.AD.DirectionR = 1; + else + g_chip.AD.OffsetR -= 8; + } + else if (wMinValueR < 5) + g_chip.AD.OffsetR += 8; + } + else + { + if (wMinValueR > 15) + g_chip.AD.OffsetR += 8; + else if (wMinValueR < 5) + g_chip.AD.OffsetR -= 8; + } + + if (g_chip.AD.DirectionG == 0) + { + if (wMinValueG > 15) + { + if (g_chip.AD.OffsetG < 8) + g_chip.AD.DirectionG = 1; + + else + g_chip.AD.OffsetG -= 8; + } + else if (wMinValueG < 5) + g_chip.AD.OffsetG += 8; + } + else + { + if (wMinValueG > 15) + g_chip.AD.OffsetG += 8; + else if (wMinValueG < 5) + g_chip.AD.OffsetG -= 8; + } + + if (g_chip.AD.DirectionB == 0) + { + if (wMinValueB > 15) + { + if (g_chip.AD.OffsetB < 8) + g_chip.AD.DirectionB = 1; + else + g_chip.AD.OffsetB -= 8; + } + else if (wMinValueB < 5) + g_chip.AD.OffsetB += 8; + } + else + { + if (wMinValueB > 15) + g_chip.AD.OffsetB += 8; + else if (wMinValueB < 5) + g_chip.AD.OffsetB -= 8; + } + + nTimesOfCal++; + if (nTimesOfCal > 10) + break; + } + while (wMinValueR > 15 || wMinValueR < 5 + || wMinValueG > 15 || wMinValueG < 5 + || wMinValueB > 15 || wMinValueB < 5); + + g_chip.AD.GainR = 1 - (double) (wMaxValueR - wMinValueR) / 210 > 0 ? + (SANE_Byte) (((1 - + (double) (wMaxValueR - wMinValueR) / 210)) * 63 * 6 / 5) : 0; + g_chip.AD.GainG = + 1 - (double) (wMaxValueG - wMinValueG) / 210 > + 0 ? (SANE_Byte) (((1 - (double) (wMaxValueG - wMinValueG) / 210)) * 63 * 6 / + 5) : 0; + g_chip.AD.GainB = + 1 - (double) (wMaxValueB - wMinValueB) / 210 > + 0 ? (SANE_Byte) (((1 - (double) (wMaxValueB - wMinValueB) / 210)) * 63 * 6 / + 5) : 0; + + if (g_chip.AD.GainR > 63) + g_chip.AD.GainR = 63; + if (g_chip.AD.GainG > 63) + g_chip.AD.GainG = 63; + if (g_chip.AD.GainB > 63) + g_chip.AD.GainB = 63; + + + + nTimesOfCal = 0; + do + { + Asic_SetAFEGainOffset (&g_chip); + Asic_ScanStart (&g_chip); + Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24); + Asic_ScanStop (&g_chip); + + MustScanner_CalculateMaxMin (lpCalData, &wMaxValueR, &wMinValueR, + wAdjustADResolution); + MustScanner_CalculateMaxMin (lpCalData + wCalWidth, &wMaxValueG, + &wMinValueG, wAdjustADResolution); + MustScanner_CalculateMaxMin (lpCalData + wCalWidth * 2, &wMaxValueB, + &wMinValueB, wAdjustADResolution); + + DBG (DBG_FUNC, "Transparent_AdjustAD: " + "RGain=%d, ROffset=%d, RDir=%d GGain=%d, GOffset=%d, GDir=%d BGain=%d, BOffset=%d, BDir=%d\n", + g_chip.AD.GainR, g_chip.AD.OffsetR, g_chip.AD.DirectionR, + g_chip.AD.GainG, g_chip.AD.OffsetG, g_chip.AD.DirectionG, + g_chip.AD.GainB, g_chip.AD.OffsetB, g_chip.AD.DirectionB); + + DBG (DBG_FUNC, "Transparent_AdjustAD: " + "MaxR=%d, MinR=%d MaxG=%d, MinG=%d MaxB=%d, MinB=%d\n", + wMaxValueR, wMinValueR, wMaxValueG, wMinValueG, wMaxValueB, + wMinValueB); + + /*R Channel */ + if ((wMaxValueR - wMinValueR) > TRAN_MAX_LEVEL_RANGE) + { + if (g_chip.AD.GainR > 0) + g_chip.AD.GainR--; + } + else + { + if ((wMaxValueR - wMinValueR) < TRAN_MIN_LEVEL_RANGE) + { + if (wMaxValueR < TRAN_WHITE_MIN_LEVEL) + { + g_chip.AD.GainR++; + if (g_chip.AD.GainR > 63) + g_chip.AD.GainR = 63; + } + else + { + if (wMaxValueR > TRAN_WHITE_MAX_LEVEL) + { + if (g_chip.AD.GainR < 1) + g_chip.AD.GainR = 0; + else + g_chip.AD.GainR--; + } + else + { + if (g_chip.AD.GainR > 63) + g_chip.AD.GainR = 63; + else + g_chip.AD.GainR++; + } + } + } + else + { + if (wMaxValueR > TRAN_WHITE_MAX_LEVEL) + { + if (g_chip.AD.GainR < 1) + g_chip.AD.GainR = 0; + else + g_chip.AD.GainR--; + } + + if (wMaxValueR < TRAN_WHITE_MIN_LEVEL) + { + if (g_chip.AD.GainR > 63) + g_chip.AD.GainR = 63; + else + g_chip.AD.GainR++; + + } + } + } + + /*G Channel */ + if ((wMaxValueG - wMinValueG) > TRAN_MAX_LEVEL_RANGE) + { + if (g_chip.AD.GainG > 0) + g_chip.AD.GainG--; + } + else + { + if ((wMaxValueG - wMinValueG) < TRAN_MIN_LEVEL_RANGE) + { + if (wMaxValueG < TRAN_WHITE_MIN_LEVEL) + { + g_chip.AD.GainG++; + if (g_chip.AD.GainG > 63) + g_chip.AD.GainG = 63; + } + else + { + if (wMaxValueG > TRAN_WHITE_MAX_LEVEL) + { + if (g_chip.AD.GainG < 1) + g_chip.AD.GainG = 0; + else + g_chip.AD.GainG--; + } + else + { + if (g_chip.AD.GainG > 63) + g_chip.AD.GainG = 63; + else + g_chip.AD.GainG++; + } + } + } + else + { + if (wMaxValueG > TRAN_WHITE_MAX_LEVEL) + { + if (g_chip.AD.GainG < 1) + g_chip.AD.GainG = 0; + else + g_chip.AD.GainG--; + } + + if (wMaxValueG < TRAN_WHITE_MIN_LEVEL) + { + if (g_chip.AD.GainG > 63) + g_chip.AD.GainG = 63; + else + g_chip.AD.GainG++; + } + } + } + + /* B Channel */ + if ((wMaxValueB - wMinValueB) > TRAN_MAX_LEVEL_RANGE) + { + if (g_chip.AD.GainB > 0) + g_chip.AD.GainB--; + } + else + { + if ((wMaxValueB - wMinValueB) < TRAN_MIN_LEVEL_RANGE) + { + if (wMaxValueB < TRAN_WHITE_MIN_LEVEL) + { + g_chip.AD.GainB++; + if (g_chip.AD.GainB > 63) + g_chip.AD.GainB = 63; + } + else + { + if (wMaxValueB > TRAN_WHITE_MAX_LEVEL) + { + if (g_chip.AD.GainB < 1) + g_chip.AD.GainB = 0; + else + g_chip.AD.GainB--; + } + else + { + if (g_chip.AD.GainB > 63) + g_chip.AD.GainB = 63; + else + g_chip.AD.GainB++; + } + } + } + else + { + if (wMaxValueB > TRAN_WHITE_MAX_LEVEL) + { + if (g_chip.AD.GainB < 1) + g_chip.AD.GainB = 0; + else + g_chip.AD.GainB--; + } + + if (wMaxValueB < TRAN_WHITE_MIN_LEVEL) + { + if (g_chip.AD.GainB > 63) + g_chip.AD.GainB = 63; + else + g_chip.AD.GainB++; + } + } + } + + nTimesOfCal++; + if (nTimesOfCal > 10) + break; + } + while ((wMaxValueR - wMinValueR) > TRAN_MAX_LEVEL_RANGE + || (wMaxValueR - wMinValueR) < TRAN_MIN_LEVEL_RANGE + || (wMaxValueG - wMinValueG) > TRAN_MAX_LEVEL_RANGE + || (wMaxValueG - wMinValueG) < TRAN_MIN_LEVEL_RANGE + || (wMaxValueB - wMinValueB) > TRAN_MAX_LEVEL_RANGE + || (wMaxValueB - wMinValueB) < TRAN_MIN_LEVEL_RANGE); + + /* Adjust Offset 2nd */ + nTimesOfCal = 0; + do + { + Asic_SetAFEGainOffset (&g_chip); + Asic_ScanStart (&g_chip); + Asic_ReadCalibrationData (&g_chip, lpCalData, wCalWidth * 3, 24); + Asic_ScanStop (&g_chip); + + MustScanner_CalculateMaxMin (lpCalData, &wMaxValueR, &wMinValueR, + wAdjustADResolution); + MustScanner_CalculateMaxMin (lpCalData + wCalWidth, &wMaxValueG, + &wMinValueG, wAdjustADResolution); + MustScanner_CalculateMaxMin (lpCalData + wCalWidth * 2, &wMaxValueB, + &wMinValueB, wAdjustADResolution); + DBG (DBG_FUNC, + "Transparent_AdjustAD: " + "RGain=%d, ROffset=%d, RDir=%d GGain=%d, GOffset=%d, GDir=%d BGain=%d, BOffset=%d, BDir=%d\n", + g_chip.AD.GainR, g_chip.AD.OffsetR, g_chip.AD.DirectionR, + g_chip.AD.GainG, g_chip.AD.OffsetG, g_chip.AD.DirectionG, + g_chip.AD.GainB, g_chip.AD.OffsetB, g_chip.AD.DirectionB); + + DBG (DBG_FUNC, "Transparent_AdjustAD: " + "MaxR=%d, MinR=%d MaxG=%d, MinG=%d MaxB=%d, MinB=%d\n", + wMaxValueR, wMinValueR, wMaxValueG, wMinValueG, wMaxValueB, + wMinValueB); + + if (g_chip.AD.DirectionR == 0) + { + if (wMinValueR > 20) + { + if (g_chip.AD.OffsetR < 8) + g_chip.AD.DirectionR = 1; + else + g_chip.AD.OffsetR -= 8; + } + else if (wMinValueR < 10) + g_chip.AD.OffsetR += 8; + } + else + { + if (wMinValueR > 20) + g_chip.AD.OffsetR += 8; + else if (wMinValueR < 10) + g_chip.AD.OffsetR -= 8; + } + + if (g_chip.AD.DirectionG == 0) + { + if (wMinValueG > 20) + { + if (g_chip.AD.OffsetG < 8) + g_chip.AD.DirectionG = 1; + else + g_chip.AD.OffsetG -= 8; + } + else if (wMinValueG < 10) + g_chip.AD.OffsetG += 8; + } + else + { + if (wMinValueG > 20) + g_chip.AD.OffsetG += 8; + else if (wMinValueG < 10) + g_chip.AD.OffsetG -= 8; + } + + if (g_chip.AD.DirectionB == 0) + { + if (wMinValueB > 20) + { + if (g_chip.AD.OffsetB < 8) + g_chip.AD.DirectionB = 1; + else + g_chip.AD.OffsetB -= 8; + } + else if (wMinValueB < 10) + g_chip.AD.OffsetB += 8; + } + else + { + if (wMinValueB > 20) + g_chip.AD.OffsetB += 8; + else if (wMinValueB < 10) + g_chip.AD.OffsetB -= 8; + } + + nTimesOfCal++; + if (nTimesOfCal > 8) + break; + + } + while (wMinValueR > 20 || wMinValueR < 10 + || wMinValueG > 20 || wMinValueG < 10 + || wMinValueB > 20 || wMinValueB < 10); + + DBG (DBG_FUNC, "Transparent_AdjustAD: leave Transparent_AdjustAD\n"); + free (lpCalData); + + return TRUE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/14 +Routine Description: + Find top and left side +Parameters: + lpwStartX: the left side + lpwStartY: the top side +Return value: + if operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_FindTopLeft (unsigned short * lpwStartX, unsigned short * lpwStartY) +{ + unsigned short wCalWidth = TA_FIND_LEFT_TOP_WIDTH_IN_DIP; + unsigned short wCalHeight = TA_FIND_LEFT_TOP_HEIGHT_IN_DIP; + + int i, j; + unsigned short wLeftSide; + unsigned short wTopSide; + int nScanBlock; + SANE_Byte * lpCalData; + unsigned int dwTotalSize; + unsigned short wXResolution, wYResolution; + + DBG (DBG_FUNC, "Transparent_FindTopLeft: call in\n"); + if (!g_bOpened) + { + DBG (DBG_FUNC, "Transparent_FindTopLeft: scanner not opened\n"); + + return FALSE; + } + if (!g_bPrepared) + { + DBG (DBG_FUNC, "Transparent_FindTopLeft: scanner not prepared\n"); + return FALSE; + } + + wXResolution = wYResolution = FIND_LEFT_TOP_CALIBRATE_RESOLUTION; + + + lpCalData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * wCalWidth * wCalHeight); + if (lpCalData == NULL) + { + DBG (DBG_FUNC, "Transparent_FindTopLeft: lpCalData malloc fail\n"); + return FALSE; + } + + dwTotalSize = wCalWidth * wCalHeight; + nScanBlock = (int) (dwTotalSize / g_dwCalibrationSize); + + Asic_SetMotorType (&g_chip, TRUE, TRUE); + Asic_SetCalibrate (&g_chip, 8, wXResolution, wYResolution, 0, 0, wCalWidth, + wCalHeight, FALSE); + Asic_SetAFEGainOffset (&g_chip); + Asic_ScanStart (&g_chip); + + for (i = 0; i < nScanBlock; i++) + Asic_ReadCalibrationData (&g_chip, lpCalData + i * g_dwCalibrationSize, + g_dwCalibrationSize, 8); + + Asic_ReadCalibrationData (&g_chip, + lpCalData + (nScanBlock) * g_dwCalibrationSize, + (dwTotalSize - g_dwCalibrationSize * nScanBlock), + 8); + Asic_ScanStop (&g_chip); + + +#ifdef DEBUG_SAVE_IMAGE + FILE *stream = NULL; + SANE_Byte * lpBuf = (SANE_Byte *) malloc (50); + if (NULL == lpBuf) + { + return FALSE; + } + memset (lpBuf, 0, 50); + stream = fopen ("/root/bound(Tra).pnm", "wb+\n"); + sprintf (lpBuf, "P5\n%d %d\n255\n", wCalWidth, wCalHeight); + fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream); + fwrite (lpCalData, sizeof (SANE_Byte), wCalWidth * wCalHeight, stream); + fclose (stream); + free (lpBuf); +#endif + + wLeftSide = 0; + wTopSide = 0; + + /* Find Left Side */ + for (i = (wCalWidth - 1); i > 0; i--) + { + wLeftSide = *(lpCalData + i); + wLeftSide += *(lpCalData + wCalWidth * 2 + i); + wLeftSide += *(lpCalData + wCalWidth * 4 + i); + wLeftSide += *(lpCalData + wCalWidth * 6 + i); + wLeftSide += *(lpCalData + wCalWidth * 8 + i); + wLeftSide /= 5; + if (wLeftSide < 60) + { + if (i == (wCalWidth - 1)) + { + break; + } + *lpwStartX = i; + break; + } + } + + /* Find Top Side i=left side */ + for (j = 0; j < wCalHeight; j++) + { + wTopSide = *(lpCalData + wCalWidth * j + i + 2); + wTopSide += *(lpCalData + wCalWidth * j + i + 4); + wTopSide += *(lpCalData + wCalWidth * j + i + 6); + wTopSide += *(lpCalData + wCalWidth * j + i + 8); + wTopSide += *(lpCalData + wCalWidth * j + i + 10); + wTopSide /= 5; + if (wTopSide < 60) + { + if (j == 0) + { + break; + } + *lpwStartY = j; + break; + } + } + + if ((*lpwStartX < 2200) || (*lpwStartX > 2300)) + { + *lpwStartX = 2260; + } + + if ((*lpwStartY < 100) || (*lpwStartY > 200)) + { + *lpwStartY = 124; + } + + + Asic_MotorMove (&g_chip, FALSE, + (wCalHeight - *lpwStartY) * 1200 / wYResolution + 300); + + free (lpCalData); + + DBG (DBG_FUNC, + "Transparent_FindTopLeft: *lpwStartY = %d, *lpwStartX = %d\n", + *lpwStartY, *lpwStartX); + DBG (DBG_FUNC, "Transparent_FindTopLeft: leave Transparent_FindTopLeft\n"); + return TRUE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/15 +Routine Description: + Get the calibration data +Parameters: + none +Return value: + if the operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_LineCalibration16Bits (unsigned short wTAShadingMinus) +{ + + unsigned short *lpWhiteShading; + unsigned short *lpDarkShading; + double wRWhiteLevel = 0; + double wGWhiteLevel = 0; + double wBWhiteLevel = 0; + unsigned int dwRDarkLevel = 0; + unsigned int dwGDarkLevel = 0; + unsigned int dwBDarkLevel = 0; + unsigned int dwREvenDarkLevel = 0; + unsigned int dwGEvenDarkLevel = 0; + unsigned int dwBEvenDarkLevel = 0; + unsigned short * lpRWhiteSort; + unsigned short * lpGWhiteSort; + unsigned short * lpBWhiteSort; + unsigned short * lpRDarkSort; + unsigned short * lpGDarkSort; + unsigned short * lpBDarkSort; + int i, j; + + SANE_Byte * lpWhiteData; + SANE_Byte * lpDarkData; + unsigned int dwWhiteTotalSize; + unsigned int dwDarkTotalSize; + unsigned short wCalHeight = LINE_CALIBRATION__16BITS_HEIGHT; + unsigned short wCalWidth = g_Width; + + DBG (DBG_FUNC, "Transparent_LineCalibration16Bits: call in\n"); + if (!g_bOpened) + { + DBG (DBG_FUNC, + "Transparent_LineCalibration16Bits: scanner not opened\n"); + return FALSE; + } + if (!g_bPrepared) + { + DBG (DBG_FUNC, + "Transparent_LineCalibration16Bits: scanner not prepared\n"); + return FALSE; + } + + if (g_XDpi < 600) + { + wTAShadingMinus = wTAShadingMinus * g_XDpi / 600; + } + + dwWhiteTotalSize = wCalWidth * wCalHeight * 3 * 2; + dwDarkTotalSize = wCalWidth * wCalHeight * 3 * 2; + lpWhiteData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * dwWhiteTotalSize); + lpDarkData = (SANE_Byte *) malloc (sizeof (SANE_Byte) * dwDarkTotalSize); + if (lpWhiteData == NULL || lpDarkData == NULL) + { + DBG (DBG_FUNC, + "Transparent_LineCalibration16Bits: lpWhiteData or lpDarkData malloc fail\n"); + return FALSE; + } + + /*Read white level data */ + Asic_SetMotorType (&g_chip, TRUE, TRUE); + Asic_SetAFEGainOffset (&g_chip); + Asic_SetCalibrate (&g_chip, 48, g_XDpi, g_YDpi, g_X, 0, wCalWidth, + wCalHeight, TRUE); + Asic_ScanStart (&g_chip); + + /* Read Data */ + Asic_ReadCalibrationData (&g_chip, lpWhiteData, dwWhiteTotalSize, 8); + Asic_ScanStop (&g_chip); + + + /* Read dark level data */ + Asic_SetMotorType (&g_chip, FALSE, TRUE); + Asic_SetAFEGainOffset (&g_chip); + Asic_SetCalibrate (&g_chip, 48, g_XDpi, g_YDpi, g_X, 0, wCalWidth, + wCalHeight, TRUE); + + Asic_TurnLamp (&g_chip, FALSE); + Asic_TurnTA (&g_chip, FALSE); + + usleep (500000); + + Asic_ScanStart (&g_chip); + Asic_ReadCalibrationData (&g_chip, lpDarkData, dwDarkTotalSize, 8); + + Asic_ScanStop (&g_chip); + + Asic_TurnTA (&g_chip, TRUE); + +#ifdef DEBUG_SAVE_IMAGE + FILE *stream = NULL; + SANE_Byte * lpBuf = (SANE_Byte *) malloc (50); + if (NULL == lpBuf) + { + return FALSE; + } + memset (lpBuf, 0, 50); + stream = fopen ("/root/whiteshading(Tra).pnm", "wb+\n"); + sprintf (lpBuf, "P6\n%d %d\n65535\n", wCalWidth, wCalHeight); + fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream); + fwrite (lpWhiteData, sizeof (SANE_Byte), wCalWidth * wCalHeight * 3 * 2, stream); + fclose (stream); + + memset (lpBuf, 0, 50); + stream = fopen ("/root/darkshading(Tra).pnm", "wb+\n"); + sprintf (lpBuf, "P6\n%d %d\n65535\n", wCalWidth * wCalHeight); + fwrite (lpBuf, sizeof (SANE_Byte), strlen (lpBuf), stream); + fwrite (lpDarkData, sizeof (SANE_Byte), wCalWidth * wCalHeight * 3 * 2, stream); + fclose (stream); + free (lpBuf); +#endif + + lpWhiteShading = (unsigned short *) malloc (sizeof (unsigned short) * wCalWidth * 3); + lpDarkShading = (unsigned short *) malloc (sizeof (unsigned short) * wCalWidth * 3); + + lpRWhiteSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight); + lpGWhiteSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight); + lpBWhiteSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight); + lpRDarkSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight); + lpGDarkSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight); + lpBDarkSort = (unsigned short *) malloc (sizeof (unsigned short) * wCalHeight); + + if (lpWhiteShading == NULL || lpDarkShading == NULL + || lpRWhiteSort == NULL || lpGWhiteSort == NULL || lpBWhiteSort == NULL + || lpRDarkSort == NULL || lpGDarkSort == NULL || lpBDarkSort == NULL) + { + DBG (DBG_FUNC, "Transparent_LineCalibration16Bits: malloc fail\n"); + + free (lpWhiteData); + free (lpDarkData); + return FALSE; + } + + DBG (DBG_FUNC, + "Transparent_LineCalibration16Bits: wCalWidth = %d, wCalHeight = %d\n", + wCalWidth, wCalHeight); + + /* create dark level shading */ + dwRDarkLevel = 0; + dwGDarkLevel = 0; + dwBDarkLevel = 0; + dwREvenDarkLevel = 0; + dwGEvenDarkLevel = 0; + dwBEvenDarkLevel = 0; + + for (i = 0; i < wCalWidth; i++) + + { + for (j = 0; j < wCalHeight; j++) + { + lpRDarkSort[j] = + (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 0)); + lpRDarkSort[j] += + (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 1) << 8); + + lpGDarkSort[j] = + (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 2)); + lpGDarkSort[j] += + (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 3) << 8); + + lpBDarkSort[j] = + (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 4)); + lpBDarkSort[j] += + (unsigned short) (*(lpDarkData + j * wCalWidth * 6 + i * 6 + 5) << 8); + } + + /* sum of dark level for all pixels */ + if (g_XDpi == 1200) + { + /* do dark shading table with mean */ + if (i % 2) + { + dwRDarkLevel += + (unsigned int) MustScanner_FiltLower (lpRDarkSort, wCalHeight, 20, + 30); + dwGDarkLevel += + (unsigned int) MustScanner_FiltLower (lpGDarkSort, wCalHeight, 20, + 30); + dwBDarkLevel += + (unsigned int) MustScanner_FiltLower (lpBDarkSort, wCalHeight, 20, + 30); + } + else + { + dwREvenDarkLevel += + (unsigned int) MustScanner_FiltLower (lpRDarkSort, wCalHeight, 20, + 30); + dwGEvenDarkLevel += + (unsigned int) MustScanner_FiltLower (lpGDarkSort, wCalHeight, 20, + 30); + dwBEvenDarkLevel += + (unsigned int) MustScanner_FiltLower (lpBDarkSort, wCalHeight, 20, + 30); + } + } + else + { + dwRDarkLevel += + (unsigned int) MustScanner_FiltLower (lpRDarkSort, wCalHeight, 20, 30); + dwGDarkLevel += + (unsigned int) MustScanner_FiltLower (lpGDarkSort, wCalHeight, 20, 30); + dwBDarkLevel += + (unsigned int) MustScanner_FiltLower (lpBDarkSort, wCalHeight, 20, 30); + } + } + + if (g_XDpi == 1200) + { + dwRDarkLevel = (unsigned int) (dwRDarkLevel / (wCalWidth / 2)) - 512; + dwGDarkLevel = (unsigned int) (dwGDarkLevel / (wCalWidth / 2)) - 512; + dwBDarkLevel = (unsigned int) (dwBDarkLevel / (wCalWidth / 2)) - 512; + + dwREvenDarkLevel = (unsigned int) (dwREvenDarkLevel / (wCalWidth / 2)) - 512; + dwGEvenDarkLevel = (unsigned int) (dwGEvenDarkLevel / (wCalWidth / 2)) - 512; + dwBEvenDarkLevel = (unsigned int) (dwBEvenDarkLevel / (wCalWidth / 2)) - 512; + } + else + { + dwRDarkLevel = (unsigned int) (dwRDarkLevel / wCalWidth) - 512; + dwGDarkLevel = (unsigned int) (dwGDarkLevel / wCalWidth) - 512; + dwBDarkLevel = (unsigned int) (dwBDarkLevel / wCalWidth) - 512; + } + + /* Create white shading */ + for (i = 0; i < wCalWidth; i++) + { + wRWhiteLevel = 0; + wGWhiteLevel = 0; + wBWhiteLevel = 0; + + for (j = 0; j < wCalHeight; j++) + { + lpRWhiteSort[j] = + (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 0)); + lpRWhiteSort[j] += + (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 1) << 8); + + lpGWhiteSort[j] = + (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 2)); + lpGWhiteSort[j] += + (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 3) << 8); + + lpBWhiteSort[j] = + (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 4)); + lpBWhiteSort[j] += + (unsigned short) (*(lpWhiteData + j * wCalWidth * 2 * 3 + i * 6 + 5) << 8); + } + + if (1200 == g_XDpi) + { + if (i % 2) + { + if (SS_Negative == g_ssScanSource) + { + *(lpDarkShading + i * 3 + 0) = (unsigned short) dwRDarkLevel; + *(lpDarkShading + i * 3 + 1) = (unsigned short) dwGDarkLevel; + *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBDarkLevel; + } + else + { + *(lpDarkShading + i * 3 + 0) = (unsigned short) dwRDarkLevel; + *(lpDarkShading + i * 3 + 1) = (unsigned short) (dwGDarkLevel * 0.78); + *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBDarkLevel; + } + } + else + { + if (SS_Negative == g_ssScanSource) + { + *(lpDarkShading + i * 3 + 0) = (unsigned short) dwREvenDarkLevel; + *(lpDarkShading + i * 3 + 1) = (unsigned short) dwGEvenDarkLevel; + *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBEvenDarkLevel; + } + else + { + *(lpDarkShading + i * 3 + 0) = (unsigned short) dwREvenDarkLevel; + *(lpDarkShading + i * 3 + 1) = + (unsigned short) (dwGEvenDarkLevel * 0.78); + *(lpDarkShading + i * 3 + 2) = (unsigned short) dwBEvenDarkLevel; + } + } + } + else + { + if (SS_Negative == g_ssScanSource) + { + *(lpDarkShading + i * 3 + 0) = (unsigned short) dwRDarkLevel; + *(lpDarkShading + i * 3 + 1) = (unsigned short) dwRDarkLevel; + *(lpDarkShading + i * 3 + 2) = (unsigned short) dwRDarkLevel; + } + else + { + *(lpDarkShading + i * 3 + 0) = (unsigned short) dwRDarkLevel; + *(lpDarkShading + i * 3 + 1) = (unsigned short) (dwRDarkLevel * 0.78); + *(lpDarkShading + i * 3 + 2) = (unsigned short) dwRDarkLevel; + } + } + + /* Create white shading */ + wRWhiteLevel = + (double) (MustScanner_FiltLower (lpRWhiteSort, wCalHeight, 20, 30) - + *(lpDarkShading + i * 3 + 0)); + wGWhiteLevel = + (double) (MustScanner_FiltLower (lpGWhiteSort, wCalHeight, 20, 30) - + *(lpDarkShading + i * 3 + 1)); + wBWhiteLevel = + (double) (MustScanner_FiltLower (lpBWhiteSort, wCalHeight, 20, 30) - + *(lpDarkShading + i * 3 + 2)); + + if (g_ssScanSource == SS_Negative) + { + if (wRWhiteLevel > 0) + *(lpWhiteShading + i * 3 + 0) = + (unsigned short) ((float) 65536 / wRWhiteLevel * 0x1000); + else + *(lpWhiteShading + i * 3 + 0) = 0x1000; + + if (wGWhiteLevel > 0) + *(lpWhiteShading + i * 3 + 1) = + (unsigned short) ((float) (65536 * 1.5) / wGWhiteLevel * 0x1000); + else + *(lpWhiteShading + i * 3 + 1) = 0x1000; + + if (wBWhiteLevel > 0) + *(lpWhiteShading + i * 3 + 2) = + (unsigned short) ((float) (65536 * 2.0) / wBWhiteLevel * 0x1000); + else + *(lpWhiteShading + i * 3 + 2) = 0x1000; + } + else + { + if (wRWhiteLevel > 0) + *(lpWhiteShading + i * 3 + 0) = + (unsigned short) ((float) 65536 / wRWhiteLevel * 0x1000); + else + *(lpWhiteShading + i * 3 + 0) = 0x1000; + + if (wGWhiteLevel > 0) + *(lpWhiteShading + i * 3 + 1) = + (unsigned short) ((float) (65536 * 1.04) / wGWhiteLevel * 0x1000); + else + *(lpWhiteShading + i * 3 + 1) = 0x1000; + + if (wBWhiteLevel > 0) + *(lpWhiteShading + i * 3 + 2) = + (unsigned short) ((float) 65536 / wBWhiteLevel * 0x1000); + else + *(lpWhiteShading + i * 3 + 2) = 0x1000; + } + } + + free (lpWhiteData); + free (lpDarkData); + free (lpRWhiteSort); + free (lpGWhiteSort); + free (lpBWhiteSort); + free (lpRDarkSort); + free (lpGDarkSort); + free (lpBDarkSort); + + Asic_SetShadingTable (&g_chip, lpWhiteShading, lpDarkShading, g_XDpi, + wCalWidth, 0); + + free (lpWhiteShading); + free (lpDarkShading); + + DBG (DBG_FUNC, + "Transparent_LineCalibration16Bits: leave Transparent_LineCalibration16Bits\n"); + return TRUE; +} + +/********************************************************************** +Author: Jack Date: 2005/05/14 +Routine Description: + Prepare scan image +Parameters: + none +Return value: + if operation is success + return TRUE + else + return FALSE +***********************************************************************/ +static SANE_Bool +Transparent_PrepareScan () +{ + DBG (DBG_FUNC, "Transparent_PrepareScan: call in\n"); + + g_wScanLinesPerBlock = g_dwBufferSize / g_BytesPerRow; + g_wMaxScanLines = g_dwImageBufferSize / g_BytesPerRow; + g_wMaxScanLines = + (g_wMaxScanLines / g_wScanLinesPerBlock) * g_wScanLinesPerBlock; + g_isCanceled = FALSE; + + g_dwScannedTotalLines = 0; + g_wReadedLines = 0; + g_wtheReadyLines = 0; + g_wReadImageLines = 0; + + g_wReadyShadingLine = 0; + g_wStartShadingLinePos = 0; + + switch (g_ScanMode) + { + + case CM_RGB48: + + g_wtheReadyLines = g_wLineDistance * 2 + g_wPixelDistance; + + g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize); + if (g_lpReadImageHead == NULL) + { + DBG (DBG_FUNC, "Transparent_PrepareScan:malloc fail\n"); + return FALSE; + } + break; + + case CM_RGB24ext: + g_wtheReadyLines = g_wLineDistance * 2 + g_wPixelDistance; + g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize); + + if (g_lpReadImageHead == NULL) + { + DBG (DBG_FUNC, "Transparent_PrepareScan:malloc fail\n"); + return FALSE; + } + break; + + case CM_GRAY16ext: + g_wtheReadyLines = g_wPixelDistance; + g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize); + if (g_lpReadImageHead == NULL) + { + DBG (DBG_FUNC, "Transparent_PrepareScan:malloc fail\n"); + return FALSE; + } + break; + + case CM_GRAY8ext: + g_wtheReadyLines = g_wPixelDistance; + g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize); + if (g_lpReadImageHead == NULL) + { + DBG (DBG_FUNC, "Transparent_PrepareScan:malloc fail\n"); + return FALSE; + } + break; + + case CM_TEXT: + g_wtheReadyLines = g_wPixelDistance; + g_lpReadImageHead = (SANE_Byte *) malloc (g_dwImageBufferSize); + if (g_lpReadImageHead == NULL) + { + DBG (DBG_FUNC, "Transparent_PrepareScan:malloc fail\n"); + return FALSE; + } + break; + default: + return FALSE; + } + + Asic_ScanStart (&g_chip); + + DBG (DBG_FUNC, "Transparent_PrepareScan: leave Transparent_PrepareScan\n"); + return TRUE; +} /* end of the file ScannerTransparent.c */ |