diff options
Diffstat (limited to 'backend/plustek-usbimg.c')
| -rw-r--r-- | backend/plustek-usbimg.c | 1984 |
1 files changed, 1984 insertions, 0 deletions
diff --git a/backend/plustek-usbimg.c b/backend/plustek-usbimg.c new file mode 100644 index 0000000..41c0207 --- /dev/null +++ b/backend/plustek-usbimg.c @@ -0,0 +1,1984 @@ +/*............................................................................. + * Project : SANE library for Plustek flatbed scanners. + *............................................................................. + */ + +/** @file plustek-usbimg.c + * @brief Image processing functions for copying and scaling image lines. + * + * Based on sources acquired from Plustek Inc.<br> + * Copyright (C) 2001-2007 Gerhard Jaeger <gerhard@gjaeger.de> + * + * History: + * - 0.40 - starting version of the USB support + * - 0.41 - fixed the 14bit problem for LM9831 devices + * - 0.42 - no changes + * - 0.43 - no changes + * - 0.44 - added CIS parts and dumpPic function + * - 0.45 - added gray scaling functions for CIS devices + * - fixed usb_GrayScale16 function + * - fixed a bug in usb_ColorScale16_2 function + * - fixed endless loop bug + * - fixed a bug in usb_GrayScalePseudo16 function + * - fixed a bug in usb_GrayDuplicatePseudo16 function + * - removed the scaler stuff for CIS devices + * - 0.46 - minor fixes + * - 0.47 - added big-endian/little endian stuff + * - 0.48 - fixed usb_ColorDuplicateGray16() and + * usb_ColorScaleGray16() + * - added usb_BWScaleFromColor() and usb_BWDuplicateFromColor() + * - cleanup + * - 0.49 - a_bRegs is now part of the device structure + * - 0.50 - cleanup + * - 0.51 - added usb_ColorDuplicateGray16_2(), usb_ColorScaleGray16_2() + * usb_BWScaleFromColor_2() and usb_BWDuplicateFromColor_2() + * - 0.52 - cleanup + * . + * <hr> + * 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. + * <hr> + */ + +#define _SCALER 1000 + +static u_char bShift, Shift; +static u_short wSum, Mask; + +/* + */ +static u_char BitTable[8] = { + 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 +}; + +static u_char BitsReverseTable[256] = { + 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, + 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, + 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, + 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, + 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, + 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, + 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, + 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, + 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, + 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, + 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, + 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, + 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, + 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, + 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, + 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, + 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, + 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, + 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, + 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, + 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, + 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, + 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, + 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, + 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, + 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, + 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, + 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, + 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, + 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, + 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, + 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff +}; + +/************************ some helper functions ******************************/ + +static void ReverseBits( int b, u_char **pTar, int *iByte, int *iWeightSum, + int iSrcWeight, int iTarWeight, int cMax ) +{ + int bit; + + cMax = (1 << cMax); + if(iSrcWeight == iTarWeight) { + for( bit = 1; bit < cMax; bit <<= 1) { + *iByte <<= 1; + if(b & bit) + *iByte |= 1; + if(*iByte >= 0x100) { + **pTar++ = (u_char)*iByte; + *iByte = 1; + } + } + } else { + for( bit = 1; bit < cMax; bit <<= 1 ) { + + *iWeightSum += iTarWeight; + while(*iWeightSum >= iSrcWeight) + { + *iWeightSum -= iSrcWeight; + *iByte <<= 1; + if(b & bit) + *iByte |= 1; + if(*iByte >= 0x100) + { + **pTar++ = (u_char)*iByte; + *iByte = 1; + } + } + } + } +} + +static void usb_ReverseBitStream( u_char *pSrc, u_char *pTar, int iPixels, + int iBufSize, int iSrcWeight/* = 0*/, + int iTarWeight/* = 0*/, int iPadBit/* = 1*/) +{ + int i; + int iByte = 1; + int cBytes = iPixels / 8; + int cBits = iPixels % 8; + u_char bPad = iPadBit? 0xff: 0; + u_char *pTarget = pTar; + int iWeightSum = 0; + + if(iSrcWeight == iTarWeight) { + if(cBits) + { + int cShift = 8 - cBits; + for(i = cBytes, pSrc = pSrc + cBytes - 1; i > 0; i--, pSrc--, pTar++) + *pTar = BitsReverseTable[(u_char)((*pSrc << cBits) | (*(pSrc+1) >> cShift))]; + ReverseBits(*(pSrc+1) >> cShift, &pTar, &iByte, &iWeightSum, iSrcWeight, iTarWeight, cBits); + } + else /* byte boundary */ + { + for(i = cBytes, pSrc = pSrc + cBytes - 1; i > 0; i--, pSrc--, pTar++) + *pTar = BitsReverseTable[*pSrc]; + } + } + else /* To shrink or enlarge */ + { + if(cBits) { + int cShift = 8 - cBits; + for(i = cBytes, pSrc = pSrc + cBytes - 1; i > 0; i--, pSrc--) + ReverseBits((*pSrc << cBits) | (*(pSrc+1) >> cShift), &pTar, &iByte, &iWeightSum, iSrcWeight, iTarWeight, 8); + ReverseBits(*(pSrc+1) >> cShift, &pTar, &iByte, &iWeightSum, iSrcWeight, iTarWeight, cBits); + } + else /* byte boundary */ + { + for(i = cBytes, pSrc = pSrc + cBytes - 1; i > 0; i--, pSrc--) + ReverseBits(*pSrc, &pTar, &iByte, &iWeightSum, iSrcWeight, iTarWeight, 8); + } + } + + if(iByte != 1) { + while(iByte < 0x100) + { + iByte <<= 1; + iByte |= iPadBit; + } + *pTar++ = (u_char)iByte; + } + + cBytes = (int)(pTar - pTarget); + + for(i = iBufSize - cBytes; i > 0; i--, pTar++) + *pTar = bPad; +} + +/** + */ +static void usb_AverageColorByte( Plustek_Device *dev ) +{ + u_long dw; + ScanDef *scan = &dev->scanning; + + if((scan->sParam.bSource == SOURCE_Negative || + scan->sParam.bSource == SOURCE_Transparency) && + scan->sParam.PhyDpi.x > 800) { + + for (dw = 0; dw < (scan->sParam.Size.dwPhyPixels - 1); dw++) + { + scan->Red.pcb[dw].a_bColor[0] = + (u_char)(((u_short)scan->Red.pcb[dw].a_bColor[0] + + (u_short)scan->Red.pcb[dw + 1].a_bColor[0]) / 2); + + scan->Green.pcb[dw].a_bColor[0] = + (u_char)(((u_short)scan->Green.pcb[dw].a_bColor[0] + + (u_short)scan->Green.pcb[dw + 1].a_bColor[0]) / 2); + + scan->Blue.pcb[dw].a_bColor[0] = + (u_char)(((u_short)scan->Blue.pcb[dw].a_bColor[0] + + (u_short)scan->Blue.pcb[dw + 1].a_bColor[0]) / 2); + } + } +} + +/** + */ +static void usb_AverageColorWord( Plustek_Device *dev ) +{ + u_char ls = 2; + u_long dw; + ScanDef *scan = &dev->scanning; + + if((scan->sParam.bSource == SOURCE_Negative || + scan->sParam.bSource == SOURCE_Transparency) && + scan->sParam.PhyDpi.x > 800) { + + scan->Red.pcw[0].Colors[0] = _HILO2WORD(scan->Red.pcw[0].HiLo[0]) >> ls; + scan->Green.pcw[0].Colors[0] = _HILO2WORD(scan->Green.pcw[0].HiLo[0]) >> ls; + scan->Blue.pcw[0].Colors[0] = _HILO2WORD(scan->Blue.pcw[0].HiLo[0]) >> ls; + + for (dw = 0; dw < (scan->sParam.Size.dwPhyPixels - 1); dw++) + { + scan->Red.pcw[dw + 1].Colors[0] = _HILO2WORD(scan->Red.pcw[dw + 1].HiLo[0]) >> ls; + scan->Green.pcw[dw + 1].Colors[0] = _HILO2WORD(scan->Green.pcw[dw + 1].HiLo[0]) >> ls; + scan->Blue.pcw[dw + 1].Colors[0] = _HILO2WORD(scan->Blue.pcw[dw + 1].HiLo[0]) >> ls; + + scan->Red.pcw[dw].Colors[0] = (u_short)(((u_long)scan->Red.pcw[dw].Colors[0] + + (u_long)scan->Red.pcw[dw + 1].Colors[0]) / 2); + scan->Green.pcw[dw].Colors[0] = (u_short)(((u_long)scan->Green.pcw[dw].Colors[0] + + (u_long)scan->Green.pcw[dw + 1].Colors[0]) / 2); + scan->Blue.pcw[dw].Colors[0] = (u_short)(((u_long)scan->Blue.pcw[dw].Colors[0] + + (u_long)scan->Blue.pcw[dw + 1].Colors[0]) / 2); + + scan->Red.pcw[dw].Colors[0] = _HILO2WORD(scan->Red.pcw[dw].HiLo[0]) << ls; + scan->Green.pcw[dw].Colors[0] = _HILO2WORD(scan->Green.pcw[dw].HiLo[0]) << ls; + scan->Blue.pcw[dw].Colors[0] = _HILO2WORD(scan->Blue.pcw[dw].HiLo[0]) << ls; + } + + scan->Red.pcw[dw].Colors[0] = _HILO2WORD(scan->Red.pcw[dw].HiLo[0]) << ls; + scan->Green.pcw[dw].Colors[0] = _HILO2WORD(scan->Green.pcw[dw].HiLo[0]) << ls; + scan->Blue.pcw[dw].Colors[0] = _HILO2WORD(scan->Blue.pcw[dw].HiLo[0]) << ls; + } +} + +/** + */ +static void usb_AverageGrayByte( Plustek_Device *dev ) +{ + u_long dw; + ScanDef *scan = &dev->scanning; + + if((scan->sParam.bSource == SOURCE_Negative || + scan->sParam.bSource == SOURCE_Transparency) && + scan->sParam.PhyDpi.x > 800) + { + for (dw = 0; dw < (scan->sParam.Size.dwPhyPixels - 1); dw++) + scan->Green.pb[dw] = (u_char)(((u_short)scan->Green.pb[dw]+ + (u_short)scan->Green.pb[dw+1]) / 2); + } +} + +/** + */ +static void usb_AverageGrayWord( Plustek_Device *dev ) +{ + u_long dw; + ScanDef *scan = &dev->scanning; + + if((scan->sParam.bSource == SOURCE_Negative || + scan->sParam.bSource == SOURCE_Transparency) && + scan->sParam.PhyDpi.x > 800) + { + scan->Green.pw[0] = _HILO2WORD(scan->Green.philo[0]) >> 2; + + for (dw = 0; dw < (scan->sParam.Size.dwPhyPixels - 1); dw++) + { + scan->Green.pw[dw + 1] = _HILO2WORD(scan->Green.philo[dw+1]) >> 2; + scan->Green.pw[dw] = (u_short)(((u_long)scan->Green.pw[dw]+ + (u_long)scan->Green.pw[dw+1]) / 2); + scan->Green.pw[dw] = _HILO2WORD(scan->Green.philo[dw]) << 2; + } + + scan->Green.pw[dw] = _HILO2WORD(scan->Green.philo[dw]) << 2; + } +} + +/** + * returns the zoom value, used for our scaling algorithm (DDA algo + * digital differential analyzer). + */ +static int usb_GetScaler( ScanDef *scan ) +{ + double ratio; + + ratio = (double)scan->sParam.UserDpi.x/ + (double)scan->sParam.PhyDpi.x; + + return (int)(1.0/ratio * _SCALER); +} + +/******************************* the copy functions **************************/ + +/** do a simple memcopy from scan-buffer to user buffer + */ +static void usb_ColorDuplicate8( Plustek_Device *dev ) +{ + int next; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + for( dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next ) { + + scan->UserBuf.pb_rgb[pixels].Red = scan->Red.pcb[dw].a_bColor[0]; + scan->UserBuf.pb_rgb[pixels].Green = scan->Green.pcb[dw].a_bColor[0]; + scan->UserBuf.pb_rgb[pixels].Blue = scan->Blue.pcb[dw].a_bColor[0]; + } +} + +/** reorder from rgb line to rgb pixel (CIS scanner) + */ +static void usb_ColorDuplicate8_2( Plustek_Device *dev ) +{ + int next; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + for( dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next ) { + + scan->UserBuf.pb_rgb[pixels].Red = (u_char)scan->Red.pb[dw]; + scan->UserBuf.pb_rgb[pixels].Green = (u_char)scan->Green.pb[dw]; + scan->UserBuf.pb_rgb[pixels].Blue = (u_char)scan->Blue.pb[dw]; + } +} + +/** + */ +static void usb_ColorDuplicate16( Plustek_Device *dev ) +{ + int next; + u_char ls; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + SANE_Bool swap = usb_HostSwap(); + + usb_AverageColorWord( dev ); + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + + if( swap ) { + scan->UserBuf.pw_rgb[pixels].Red = + _HILO2WORD(scan->Red.pcw[dw].HiLo[0]) >> ls; + scan->UserBuf.pw_rgb[pixels].Green = + _HILO2WORD(scan->Green.pcw[dw].HiLo[0]) >> ls; + scan->UserBuf.pw_rgb[pixels].Blue = + _HILO2WORD(scan->Blue.pcw[dw].HiLo[0]) >> ls; + } else { + scan->UserBuf.pw_rgb[pixels].Red = scan->Red.pw[dw] >> ls; + scan->UserBuf.pw_rgb[pixels].Green= scan->Green.pw[dw] >> ls; + scan->UserBuf.pw_rgb[pixels].Blue = scan->Blue.pw[dw] >> ls; + } + } +} + +/** + */ +static void usb_ColorDuplicate16_2( Plustek_Device *dev ) +{ + int next; + u_char ls; + HiLoDef tmp; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + SANE_Bool swap = usb_HostSwap(); + + usb_AverageColorWord( dev ); + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + for( dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + + if( swap ) { + tmp = *((HiLoDef*)&scan->Red.pw[dw]); + scan->UserBuf.pw_rgb[pixels].Red = _HILO2WORD(tmp) >> ls; + + tmp = *((HiLoDef*)&scan->Green.pw[dw]); + scan->UserBuf.pw_rgb[pixels].Green = _HILO2WORD(tmp) >> ls; + + tmp = *((HiLoDef*)&scan->Blue.pw[dw]); + scan->UserBuf.pw_rgb[pixels].Blue = _HILO2WORD(tmp) >> ls; + + } else { + + scan->UserBuf.pw_rgb[pixels].Red = scan->Red.pw[dw] >> ls; + scan->UserBuf.pw_rgb[pixels].Green = scan->Green.pw[dw] >> ls; + scan->UserBuf.pw_rgb[pixels].Blue = scan->Blue.pw[dw] >> ls; + } + } +} + +/** + */ +static void usb_ColorDuplicatePseudo16( Plustek_Device *dev ) +{ + int next; + u_short wR, wG, wB; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + if (scan->sParam.bSource == SOURCE_ADF) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + wR = (u_short)scan->Red.pcb[0].a_bColor[0]; + wG = (u_short)scan->Green.pcb[0].a_bColor[0]; + wB = (u_short)scan->Blue.pcb[0].a_bColor[0]; + + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + + scan->UserBuf.pw_rgb[pixels].Red = + (wR + scan->Red.pcb[dw].a_bColor[0]) << bShift; + scan->UserBuf.pw_rgb[pixels].Green = + (wG + scan->Green.pcb[dw].a_bColor[0]) << bShift; + scan->UserBuf.pw_rgb[pixels].Blue = + (wB + scan->Blue.pcb[dw].a_bColor[0]) << bShift; + + wR = (u_short)scan->Red.pcb[dw].a_bColor[0]; + wG = (u_short)scan->Green.pcb[dw].a_bColor[0]; + wB = (u_short)scan->Blue.pcb[dw].a_bColor[0]; + } +} + +/** + */ +static void usb_ColorDuplicateGray( Plustek_Device *dev ) +{ + int next; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + if (scan->sParam.bSource == SOURCE_ADF) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + switch(scan->fGrayFromColor) { + + case 1: + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pb[pixels] = scan->Red.pcb[dw].a_bColor[0]; + break; + case 2: + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pb[pixels] = scan->Green.pcb[dw].a_bColor[0]; + break; + case 3: + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pb[pixels] = scan->Blue.pcb[dw].a_bColor[0]; + break; + } +} + +/** + */ +static void usb_ColorDuplicateGray_2( Plustek_Device *dev ) +{ + int next; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + if (scan->sParam.bSource == SOURCE_ADF) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + switch(scan->fGrayFromColor) + { + case 1: + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pb[pixels] = scan->Red.pb[dw]; + break; + case 3: + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pb[pixels] = scan->Blue.pb[dw]; + break; + default: + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pb[pixels] = scan->Green.pb[dw]; + break; + } +} + +/** + */ +static void usb_ColorDuplicateGray16( Plustek_Device *dev ) +{ + int next; + u_char ls; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + SANE_Bool swap = usb_HostSwap(); + + usb_AverageColorWord( dev ); + + if (scan->sParam.bSource == SOURCE_ADF) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + switch(scan->fGrayFromColor) { + + case 1: + if( swap ) { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pw[pixels] = + _HILO2WORD(scan->Red.pcw[dw].HiLo[0]) >> ls; + } else { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pw[pixels] = scan->Red.pw[dw] >> ls; + } + break; + case 2: + if( swap ) { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pw[pixels] = + _HILO2WORD(scan->Green.pcw[dw].HiLo[0]) >> ls; + } else { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pw[pixels] = scan->Green.pw[dw] >> ls; + } + break; + case 3: + if( swap ) { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pw[pixels] = + _HILO2WORD(scan->Blue.pcw[dw].HiLo[0]) >> ls; + } else { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) + scan->UserBuf.pw[pixels] = scan->Blue.pw[dw] >> ls; + } + break; + } +} + +/** + */ +static void usb_ColorDuplicateGray16_2( Plustek_Device *dev ) +{ + int next; + u_char ls; + u_long dw, pixels; + HiLoDef tmp; + ScanDef *scan = &dev->scanning; + SANE_Bool swap = usb_HostSwap(); + + usb_AverageColorWord( dev ); + + if (scan->sParam.bSource == SOURCE_ADF) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + switch(scan->fGrayFromColor) { + case 1: + if( swap ) { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + tmp = *((HiLoDef*)&scan->Red.pw[dw]); + scan->UserBuf.pw[pixels] = _HILO2WORD(tmp) >> ls; + } + } else { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + scan->UserBuf.pw[pixels] = scan->Red.pw[dw] >> ls; + } + } + break; + case 2: + if( swap ) { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + tmp = *((HiLoDef*)&scan->Green.pw[dw]); + scan->UserBuf.pw[pixels] = _HILO2WORD(tmp) >> ls; + } + } else { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + scan->UserBuf.pw[pixels] = scan->Green.pw[dw] >> ls; + } + } + break; + case 3: + if( swap ) { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + tmp = *((HiLoDef*)&scan->Blue.pw[dw]); + scan->UserBuf.pw[pixels] = _HILO2WORD(tmp) >> ls; + } + } else { + for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, pixels += next) { + scan->UserBuf.pw[pixels] = scan->Blue.pw[dw] >> ls; + } + } + break; + } +} + +/** + */ +static void usb_GrayDuplicate8( Plustek_Device *dev ) +{ + u_char *dest, *src; + u_long pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageGrayByte( dev ); + + if( scan->sParam.bSource == SOURCE_ADF ) { + + pixels = scan->sParam.Size.dwPixels; + src = scan->Green.pb; + dest = scan->UserBuf.pb + pixels - 1; + + for(; pixels; pixels--, src++, dest--) + *dest = *src; + } else { + memcpy( scan->UserBuf.pb, scan->Green.pb, scan->sParam.Size.dwBytes ); + } +} + +/** + */ +static void usb_GrayDuplicate16( Plustek_Device *dev ) +{ + int next; + u_char ls; + u_short *dest; + u_long pixels; + HiLoDef *pwm; + ScanDef *scan = &dev->scanning; + SANE_Bool swap = usb_HostSwap(); + + usb_AverageGrayWord( dev ); + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + dest = scan->UserBuf.pw + scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + dest = scan->UserBuf.pw; + } + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + pwm = scan->Green.philo; + for( pixels=scan->sParam.Size.dwPixels; pixels--; pwm++, dest += next ) { + if( swap ) + *dest = (_PHILO2WORD(pwm)) >> ls; + else + *dest = (_PLOHI2WORD(pwm)) >> ls; + } +} + +/** + */ +static void usb_GrayDuplicatePseudo16( Plustek_Device *dev ) +{ + u_char *src; + int next; + u_short g; + u_short *dest; + u_long pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageGrayByte( dev ); + + if (scan->sParam.bSource == SOURCE_ADF) { + next = -1; + dest = scan->UserBuf.pw + scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + dest = scan->UserBuf.pw; + } + + src = scan->Green.pb; + g = (u_short)*src; + + for( pixels=scan->sParam.Size.dwPixels; pixels--; src++, dest += next ) { + + *dest = (g + *src) << bShift; + g = (u_short)*src; + } +} + +/** copy binary data to the user buffer + */ +static void usb_BWDuplicate( Plustek_Device *dev ) +{ + ScanDef *scan = &dev->scanning; + + if(scan->sParam.bSource == SOURCE_ADF) + { + usb_ReverseBitStream( scan->Green.pb, scan->UserBuf.pb, + scan->sParam.Size.dwValidPixels, + scan->dwBytesLine, 0, 0, 1 ); + } else { + memcpy( scan->UserBuf.pb, scan->Green.pb, scan->sParam.Size.dwBytes ); + } +} + +/** generate binary data from one of the three color inputs according to the + * value in fGrayFromColor (CCD version) + */ +static void usb_BWDuplicateFromColor( Plustek_Device *dev ) +{ + int next; + u_char d, s, *dest; + u_short j; + u_long pixels; + ColorByteDef *src; + ScanDef *scan = &dev->scanning; + + if( scan->sParam.bSource == SOURCE_ADF ) { + dest = scan->UserBuf.pb + scan->sParam.Size.dwPixels - 1; + next = -1; + } else { + dest = scan->UserBuf.pb; + next = 1; + } + + switch(scan->fGrayFromColor) { + case 1: src = scan->Red.pcb; break; + case 3: src = scan->Blue.pcb; break; + default: src = scan->Green.pcb; break; + } + + d = j = 0; + for( pixels = scan->sParam.Size.dwPixels; pixels; pixels--, src++ ) { + + s = src->a_bColor[0]; + if( s != 0 ) + d |= BitTable[j]; + j++; + if( j == 8 ) { + *dest = d; + dest += next; + + d = j = 0; + } + } +} + +/** generate binary data from one of the three color inputs according to the + * value in fGrayFromColor (CIS version) + */ +static void usb_BWDuplicateFromColor_2( Plustek_Device *dev ) +{ + int next; + u_char d, *dest, *src; + u_short j; + u_long pixels; + ScanDef *scan = &dev->scanning; + + if( scan->sParam.bSource == SOURCE_ADF ) { + dest = scan->UserBuf.pb + scan->sParam.Size.dwPixels - 1; + next = -1; + } else { + dest = scan->UserBuf.pb; + next = 1; + } + + switch(scan->fGrayFromColor) { + case 1: src = scan->Red.pb; break; + case 3: src = scan->Blue.pb; break; + default: src = scan->Green.pb; break; + } + + d = j = 0; + for( pixels = scan->sParam.Size.dwPixels; pixels; pixels--, src++ ) { + + if( *src != 0 ) + d |= BitTable[j]; + j++; + if( j == 8 ) { + *dest = d; + dest += next; + + d = j = 0; + } + } +} + +/************************** the scaling functions ****************************/ + +/** + */ +static void usb_ColorScaleGray( Plustek_Device *dev ) +{ + int izoom, ddax, next; + u_long dw, pixels; + ColorByteDef *src; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + switch(scan->fGrayFromColor) { + case 1: src = scan->Red.pcb; break; + case 3: src = scan->Blue.pcb; break; + default: src = scan->Green.pcb; break; + } + + izoom = usb_GetScaler( scan ); + + for( ddax = 0; dw; src++ ) { + + ddax -= _SCALER; + while((ddax < 0) && (dw > 0)) { + + scan->UserBuf.pb[pixels] = src->a_bColor[0]; + + pixels += next; + ddax += izoom; + dw--; + } + } +} + +/** + */ +static void usb_ColorScaleGray_2( Plustek_Device *dev ) +{ + u_char *src; + int izoom, ddax, next; + u_long dw, pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + switch(scan->fGrayFromColor) { + case 1: src = scan->Red.pb; break; + case 3: src = scan->Blue.pb; break; + default: src = scan->Green.pb; break; + } + + izoom = usb_GetScaler( scan ); + + for( ddax = 0; dw; src++ ) { + + ddax -= _SCALER; + while((ddax < 0) && (dw > 0)) { + + scan->UserBuf.pb[pixels] = *src; + + pixels += next; + ddax += izoom; + dw--; + } + } +} + +/** + */ +static void usb_ColorScaleGray16( Plustek_Device *dev ) +{ + u_char ls; + int izoom, ddax, next; + u_long dw, pixels, bitsput; + SANE_Bool swap = usb_HostSwap(); + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + switch( scan->fGrayFromColor ) { + + case 1: + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + if( swap ) { + scan->UserBuf.pw[pixels] = + _HILO2WORD(scan->Red.pcw[bitsput].HiLo[0]) >> ls; + } else { + scan->UserBuf.pw[pixels] = scan->Red.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } + break; + + case 2: + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + if( swap ) { + scan->UserBuf.pw[pixels] = + _HILO2WORD(scan->Green.pcw[bitsput].HiLo[0]) >> ls; + } else { + scan->UserBuf.pw[pixels] = scan->Green.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } + break; + + case 3: + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + if( swap ) { + scan->UserBuf.pw[pixels] = + _HILO2WORD(scan->Blue.pcw[bitsput].HiLo[0]) >> ls; + } else { + scan->UserBuf.pw[pixels] = scan->Blue.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } + break; + } +} + +/** + */ +static void usb_ColorScaleGray16_2( Plustek_Device *dev ) +{ + u_char ls; + int izoom, ddax, next; + u_long dw, pixels, bitsput; + HiLoDef tmp; + SANE_Bool swap = usb_HostSwap(); + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + switch( scan->fGrayFromColor ) { + + case 1: + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + if( swap ) { + tmp = *((HiLoDef*)&scan->Red.pw[bitsput]); + scan->UserBuf.pw[pixels] = _HILO2WORD(tmp) >> ls; + } else { + scan->UserBuf.pw[pixels] = scan->Red.pw[dw] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } + break; + + case 2: + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + if( swap ) { + tmp = *((HiLoDef*)&scan->Green.pw[bitsput]); + scan->UserBuf.pw[pixels] = _HILO2WORD(tmp) >> ls; + } else { + scan->UserBuf.pw[pixels] = scan->Green.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } + break; + + case 3: + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + if( swap ) { + tmp = *((HiLoDef*)&scan->Blue.pw[bitsput]); + scan->UserBuf.pw[pixels] = _HILO2WORD(tmp) >> ls; + } else { + scan->UserBuf.pw[pixels] = scan->Blue.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } + break; + } +} + +/** here we copy and scale from scanner world to user world... + */ +static void usb_ColorScale8( Plustek_Device *dev ) +{ + int izoom, ddax, next; + u_long dw, pixels, bitsput; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + + scan->UserBuf.pb_rgb[pixels].Red = + scan->Red.pcb[bitsput].a_bColor[0]; + scan->UserBuf.pb_rgb[pixels].Green = + scan->Green.pcb[bitsput].a_bColor[0]; + scan->UserBuf.pb_rgb[pixels].Blue = + scan->Blue.pcb[bitsput].a_bColor[0]; + pixels += next; + ddax += izoom; + dw--; + } + } +} + +static void usb_ColorScale8_2( Plustek_Device *dev ) +{ + int izoom, ddax, next; + u_long dw, pixels, bitsput; + ScanDef *scan = &dev->scanning; + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + + scan->UserBuf.pb_rgb[pixels].Red = scan->Red.pb[bitsput]; + scan->UserBuf.pb_rgb[pixels].Green = scan->Green.pb[bitsput]; + scan->UserBuf.pb_rgb[pixels].Blue = scan->Blue.pb[bitsput]; + + pixels += next; + ddax += izoom; + dw--; + } + } +} + +/** + */ +static void usb_ColorScale16( Plustek_Device *dev ) +{ + u_char ls; + int izoom, ddax, next; + u_long dw, pixels, bitsput; + SANE_Bool swap = usb_HostSwap(); + ScanDef *scan = &dev->scanning; + + usb_AverageColorWord( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + + if( swap ) { + + scan->UserBuf.pw_rgb[pixels].Red = + _HILO2WORD(scan->Red.pcw[bitsput].HiLo[0]) >> ls; + + scan->UserBuf.pw_rgb[pixels].Green = + _HILO2WORD(scan->Green.pcw[bitsput].HiLo[0]) >> ls; + + scan->UserBuf.pw_rgb[pixels].Blue = + _HILO2WORD(scan->Blue.pcw[bitsput].HiLo[0]) >> ls; + + } else { + + scan->UserBuf.pw_rgb[pixels].Red = scan->Red.pw[bitsput]>>ls; + scan->UserBuf.pw_rgb[pixels].Green = scan->Green.pw[bitsput] >> ls; + scan->UserBuf.pw_rgb[pixels].Blue = scan->Blue.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } +} + +/** + */ +static void usb_ColorScale16_2( Plustek_Device *dev ) +{ + u_char ls; + HiLoDef tmp; + int izoom, ddax, next; + u_long dw, pixels, bitsput; + SANE_Bool swap = usb_HostSwap(); + ScanDef *scan = &dev->scanning; + + usb_AverageColorWord( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + + if( swap ) { + + tmp = *((HiLoDef*)&scan->Red.pw[bitsput]); + scan->UserBuf.pw_rgb[pixels].Red = _HILO2WORD(tmp) >> ls; + + tmp = *((HiLoDef*)&scan->Green.pw[bitsput]); + scan->UserBuf.pw_rgb[pixels].Green = _HILO2WORD(tmp) >> ls; + + tmp = *((HiLoDef*)&scan->Blue.pw[bitsput]); + scan->UserBuf.pw_rgb[pixels].Blue = _HILO2WORD(tmp) >> ls; + + } else { + + scan->UserBuf.pw_rgb[pixels].Red = scan->Red.pw[bitsput] >> ls; + scan->UserBuf.pw_rgb[pixels].Green = scan->Green.pw[bitsput] >> ls; + scan->UserBuf.pw_rgb[pixels].Blue = scan->Blue.pw[bitsput] >> ls; + } + pixels += next; + ddax += izoom; + dw--; + } + } +} + +/** + */ +static void usb_ColorScalePseudo16( Plustek_Device *dev ) +{ + int izoom, ddax, next; + u_short wR, wG, wB; + u_long dw, pixels, bitsput; + ScanDef *scan = &dev->scanning; + + usb_AverageColorByte( dev ); + + dw = scan->sParam.Size.dwPixels; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + pixels = scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + pixels = 0; + } + + izoom = usb_GetScaler( scan ); + + wR = (u_short)scan->Red.pcb[0].a_bColor[0]; + wG = (u_short)scan->Green.pcb[0].a_bColor[1]; + wB = (u_short)scan->Blue.pcb[0].a_bColor[2]; + + for( bitsput = 0, ddax = 0; dw; bitsput++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (dw > 0)) { + + scan->UserBuf.pw_rgb[pixels].Red = + (wR + scan->Red.pcb[bitsput].a_bColor[0]) << bShift; + + scan->UserBuf.pw_rgb[pixels].Green = + (wG + scan->Green.pcb[bitsput].a_bColor[0]) << bShift; + + scan->UserBuf.pw_rgb[pixels].Blue = + (wB + scan->Blue.pcb[bitsput].a_bColor[0]) << bShift; + + pixels += next; + ddax += izoom; + dw--; + } + + wR = (u_short)scan->Red.pcb[bitsput].a_bColor[0]; + wG = (u_short)scan->Green.pcb[bitsput].a_bColor[0]; + wB = (u_short)scan->Blue.pcb[bitsput].a_bColor[0]; + } +} + +/** + */ +static void usb_BWScale( Plustek_Device *dev ) +{ + u_char tmp, *dest, *src; + int izoom, ddax; + u_long i, dw; + ScanDef *scan = &dev->scanning; + + src = scan->Green.pb; + if( scan->sParam.bSource == SOURCE_ADF ) { + int iSum = wSum; + usb_ReverseBitStream(scan->Green.pb, scan->UserBuf.pb, + scan->sParam.Size.dwValidPixels, + scan->dwBytesLine, scan->sParam.PhyDpi.x, + scan->sParam.UserDpi.x, 1 ); + wSum = iSum; + return; + } else { + dest = scan->UserBuf.pb; + } + + izoom = usb_GetScaler( scan ); + + memset( dest, 0, scan->dwBytesLine ); + ddax = 0; + dw = 0; + + for( i = 0; i < scan->sParam.Size.dwValidPixels; i++ ) { + + ddax -= _SCALER; + + while( ddax < 0 ) { + + tmp = src[(i>>3)]; + + if((dw>>3) < scan->sParam.Size.dwValidPixels ) { + + if( 0 != (tmp &= (1 << ((~(i & 0x7))&0x7)))) + dest[dw>>3] |= (1 << ((~(dw & 0x7))&0x7)); + } + dw++; + ddax += izoom; + } + } +} + +/** + */ +static void usb_BWScaleFromColor( Plustek_Device *dev ) +{ + u_char d, s, *dest; + u_short j; + u_long pixels; + int izoom, ddax, next; + ColorByteDef *src; + ScanDef *scan = &dev->scanning; + + if (scan->sParam.bSource == SOURCE_ADF) { + dest = scan->UserBuf.pb + scan->sParam.Size.dwPixels - 1; + next = -1; + } else { + dest = scan->UserBuf.pb; + next = 1; + } + + /* setup the source buffer */ + switch(scan->fGrayFromColor) { + case 1: src = scan->Red.pcb; break; + case 3: src = scan->Blue.pcb; break; + default: src = scan->Green.pcb; break; + } + + izoom = usb_GetScaler( scan ); + ddax = 0; + + d = j = 0; + for( pixels = scan->sParam.Size.dwPixels; pixels; src++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (pixels > 0)) { + + s = src->a_bColor[0]; + if( s != 0 ) + d |= BitTable[j]; + j++; + if( j == 8 ) { + *dest = d; + dest += next; + d = j = 0; + } + ddax += izoom; + pixels--; + } + } +} + +/** + */ +static void usb_BWScaleFromColor_2( Plustek_Device *dev ) +{ + u_char d, *dest, *src; + u_short j; + u_long pixels; + int izoom, ddax, next; + ScanDef *scan = &dev->scanning; + + if (scan->sParam.bSource == SOURCE_ADF) { + dest = scan->UserBuf.pb + scan->sParam.Size.dwPixels - 1; + next = -1; + } else { + dest = scan->UserBuf.pb; + next = 1; + } + + /* setup the source buffer */ + switch(scan->fGrayFromColor) { + case 1: src = scan->Red.pb; break; + case 3: src = scan->Blue.pb; break; + default: src = scan->Green.pb; break; + } + + izoom = usb_GetScaler( scan ); + ddax = 0; + + d = j = 0; + for( pixels = scan->sParam.Size.dwPixels; pixels; src++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (pixels > 0)) { + + if( *src != 0 ) + d |= BitTable[j]; + j++; + if( j == 8 ) { + *dest = d; + dest += next; + d = j = 0; + } + ddax += izoom; + pixels--; + } + } +} + +/** + */ +static void usb_GrayScale8( Plustek_Device *dev ) +{ + u_char *dest, *src; + int izoom, ddax, next; + u_long pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageGrayByte( dev ); + + src = scan->Green.pb; + if( scan->sParam.bSource == SOURCE_ADF ) { + dest = scan->UserBuf.pb + scan->sParam.Size.dwPixels - 1; + next = -1; + } else { + dest = scan->UserBuf.pb; + next = 1; + } + + izoom = usb_GetScaler( scan ); + ddax = 0; + + for( pixels = scan->sParam.Size.dwPixels; pixels; src++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (pixels > 0)) { + + *dest = *src; + dest += next; + ddax += izoom; + pixels--; + } + } +} + +/** + */ +static void usb_GrayScale16( Plustek_Device *dev ) +{ + u_char ls; + int izoom, ddax, next; + u_short *dest; + u_long pixels; + HiLoDef *pwm; + ScanDef *scan = &dev->scanning; + SANE_Bool swap = usb_HostSwap(); + + usb_AverageGrayWord( dev); + + pwm = scan->Green.philo; + wSum = scan->sParam.PhyDpi.x; + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + dest = scan->UserBuf.pw + scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + dest = scan->UserBuf.pw; + } + + izoom = usb_GetScaler( scan ); + ddax = 0; + + if( scan->dwFlag & SCANFLAG_RightAlign ) + ls = Shift; + else + ls = 0; + + for( pixels = scan->sParam.Size.dwPixels; pixels; pwm++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (pixels > 0)) { + + if( swap ) + *dest = _PHILO2WORD(pwm) >> ls; + else + *dest = _PLOHI2WORD(pwm) >> ls; + + dest += next; + ddax += izoom; + pixels--; + } + } +} + +/** + */ +static void usb_GrayScalePseudo16( Plustek_Device *dev ) +{ + u_char *src; + int izoom, ddax, next; + u_short *dest, g; + u_long pixels; + ScanDef *scan = &dev->scanning; + + usb_AverageGrayByte( dev ); + + if( scan->sParam.bSource == SOURCE_ADF ) { + next = -1; + dest = scan->UserBuf.pw + scan->sParam.Size.dwPixels - 1; + } else { + next = 1; + dest = scan->UserBuf.pw; + } + + src = scan->Green.pb; + g = (u_short)*src; + + izoom = usb_GetScaler( scan ); + ddax = 0; + + for( pixels = scan->sParam.Size.dwPixels; pixels; src++ ) { + + ddax -= _SCALER; + + while((ddax < 0) && (pixels > 0)) { + + *dest = (g + *src) << bShift; + dest += next; + ddax += izoom; + pixels--; + } + g = (u_short)*src; + } +} + +/** function to select the apropriate pixel copy function + */ +static void usb_GetImageProc( Plustek_Device *dev ) +{ + ScanDef *scan = &dev->scanning; + DCapsDef *sc = &dev->usbDev.Caps; + HWDef *hw = &dev->usbDev.HwSetting; + + bShift = 0; + + if( scan->sParam.UserDpi.x != scan->sParam.PhyDpi.x ) { + + /* Pixel scaling... */ + switch( scan->sParam.bDataType ) { + + case SCANDATATYPE_Color: + if (scan->sParam.bBitDepth > 8) { + + if( usb_IsCISDevice(dev)){ + scan->pfnProcess = usb_ColorScale16_2; + DBG( _DBG_INFO, "ImageProc is: ColorScale16_2\n" ); + } else { + scan->pfnProcess = usb_ColorScale16; + DBG( _DBG_INFO, "ImageProc is: ColorScale16\n" ); + } + if (scan->fGrayFromColor) { + if( usb_IsCISDevice(dev)){ + scan->pfnProcess = usb_ColorScaleGray16_2; + DBG( _DBG_INFO, "ImageProc is: ColorScaleGray16_2\n" ); + } else { + scan->pfnProcess = usb_ColorScaleGray16; + DBG( _DBG_INFO, "ImageProc is: ColorScaleGray16\n" ); + } + } + } else if (scan->dwFlag & SCANFLAG_Pseudo48) { + scan->pfnProcess = usb_ColorScalePseudo16; + DBG( _DBG_INFO, "ImageProc is: ColorScalePseudo16\n" ); + + } else if (scan->fGrayFromColor) { + + if( usb_IsCISDevice(dev)){ + if (scan->fGrayFromColor > 7 ) { + scan->pfnProcess = usb_BWScaleFromColor_2; + DBG( _DBG_INFO, "ImageProc is: BWScaleFromColor_2\n" ); + } else { + scan->pfnProcess = usb_ColorScaleGray_2; + DBG( _DBG_INFO, "ImageProc is: ColorScaleGray_2\n" ); + } + } else { + if (scan->fGrayFromColor > 7 ) { + scan->pfnProcess = usb_BWScaleFromColor; + DBG( _DBG_INFO, "ImageProc is: BWScaleFromColor\n" ); + } else { + scan->pfnProcess = usb_ColorScaleGray; + DBG( _DBG_INFO, "ImageProc is: ColorScaleGray\n" ); + } + } + } else { + + if( usb_IsCISDevice(dev)){ + scan->pfnProcess = usb_ColorScale8_2; + DBG( _DBG_INFO, "ImageProc is: ColorScale8_2\n" ); + } else { + scan->pfnProcess = usb_ColorScale8; + DBG( _DBG_INFO, "ImageProc is: ColorScale8\n" ); + } + } + break; + + case SCANDATATYPE_Gray: + if (scan->sParam.bBitDepth > 8) { + scan->pfnProcess = usb_GrayScale16; + DBG( _DBG_INFO, "ImageProc is: GrayScale16\n" ); + } else { + + if (scan->dwFlag & SCANFLAG_Pseudo48) { + scan->pfnProcess = usb_GrayScalePseudo16; + DBG( _DBG_INFO, "ImageProc is: GrayScalePseudo16\n" ); + } else { + scan->pfnProcess = usb_GrayScale8; + DBG( _DBG_INFO, "ImageProc is: GrayScale8\n" ); + } + } + break; + + default: + scan->pfnProcess = usb_BWScale; + DBG( _DBG_INFO, "ImageProc is: BWScale\n" ); + break; + } + + } else { + + /* Pixel copy */ + switch( scan->sParam.bDataType ) { + + case SCANDATATYPE_Color: + if (scan->sParam.bBitDepth > 8) { + if( usb_IsCISDevice(dev)){ + scan->pfnProcess = usb_ColorDuplicate16_2; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicate16_2\n" ); + } else { + scan->pfnProcess = usb_ColorDuplicate16; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicate16\n" ); + } + if (scan->fGrayFromColor) { + if( usb_IsCISDevice(dev)){ + scan->pfnProcess = usb_ColorDuplicateGray16_2; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicateGray16_2\n" ); + } else { + scan->pfnProcess = usb_ColorDuplicateGray16; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicateGray16\n" ); + } + } + } else if (scan->dwFlag & SCANFLAG_Pseudo48) { + scan->pfnProcess = usb_ColorDuplicatePseudo16; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicatePseudo16\n" ); + } else if (scan->fGrayFromColor) { + if( usb_IsCISDevice(dev)){ + if (scan->fGrayFromColor > 7 ) { + scan->pfnProcess = usb_BWDuplicateFromColor_2; + DBG( _DBG_INFO, "ImageProc is: BWDuplicateFromColor_2\n" ); + } else { + scan->pfnProcess = usb_ColorDuplicateGray_2; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicateGray_2\n" ); + } + } else { + if (scan->fGrayFromColor > 7 ) { + scan->pfnProcess = usb_BWDuplicateFromColor; + DBG( _DBG_INFO, "ImageProc is: BWDuplicateFromColor\n" ); + } else { + scan->pfnProcess = usb_ColorDuplicateGray; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicateGray\n" ); + } + } + } else { + if( usb_IsCISDevice(dev)){ + scan->pfnProcess = usb_ColorDuplicate8_2; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicate8_2\n" ); + } else { + scan->pfnProcess = usb_ColorDuplicate8; + DBG( _DBG_INFO, "ImageProc is: ColorDuplicate8\n" ); + } + } + break; + + case SCANDATATYPE_Gray: + if (scan->sParam.bBitDepth > 8) { + scan->pfnProcess = usb_GrayDuplicate16; + DBG( _DBG_INFO, "ImageProc is: GrayDuplicate16\n" ); + } else { + if (scan->dwFlag & SCANFLAG_Pseudo48) { + scan->pfnProcess = usb_GrayDuplicatePseudo16; + DBG( _DBG_INFO, "ImageProc is: GrayDuplicatePseudo16\n" ); + } else { + scan->pfnProcess = usb_GrayDuplicate8; + DBG( _DBG_INFO, "ImageProc is: GrayDuplicate8\n" ); + } + } + break; + + default: + scan->pfnProcess = usb_BWDuplicate; + DBG( _DBG_INFO, "ImageProc is: BWDuplicate\n" ); + break; + } + } + + if( scan->sParam.bBitDepth == 8 ) { + + if( scan->dwFlag & SCANFLAG_Pseudo48 ) { + if( scan->dwFlag & SCANFLAG_RightAlign ) { + bShift = 5; + } else { + + /* this should fix the Bearpaw/U12 discrepancy + * in general the fix is needed, but not for the U12 + * why? - no idea! + */ + if(_WAF_BSHIFT7_BUG == (_WAF_BSHIFT7_BUG & sc->workaroundFlag)) + bShift = 0; /* Holger Bischof 16.12.2001 */ + else + bShift = 7; + } + DBG( _DBG_INFO, "bShift adjusted: %u\n", bShift ); + } + } + + if( _LM9833 == hw->chip ) { + Shift = 0; + Mask = 0xFFFF; + } else { + Shift = 2; + Mask = 0xFFFC; + } +} + +/** + * here we read the image data into our intermediate buffer (in the NT version + * the function was implemented as thread) + */ +static SANE_Int usb_ReadData( Plustek_Device *dev ) +{ + u_long dw, dwRet, dwBytes, pl; + ScanDef *scan = &dev->scanning; + HWDef *hw = &dev->usbDev.HwSetting; + + DBG( _DBG_READ, "usb_ReadData()\n" ); + + pl = dev->usbDev.a_bRegs[0x4e] * hw->wDRAMSize/128; + + while( scan->sParam.Size.dwTotalBytes ) { + + if( usb_IsEscPressed()) { + DBG( _DBG_INFO, "usb_ReadData() - Cancel detected...\n" ); + return 0; + } + + if( scan->sParam.Size.dwTotalBytes > scan->dwBytesScanBuf ) + dw = scan->dwBytesScanBuf; + else + dw = scan->sParam.Size.dwTotalBytes; + + scan->sParam.Size.dwTotalBytes -= dw; + + if(!scan->sParam.Size.dwTotalBytes && dw < (pl * 1024)) + { + if(!(dev->usbDev.a_bRegs[0x4e] = (u_char)ceil((double)dw / + (4.0 * hw->wDRAMSize)))) { + dev->usbDev.a_bRegs[0x4e] = 1; + } + dev->usbDev.a_bRegs[0x4f] = 0; + + sanei_lm983x_write( dev->fd, 0x4e, &dev->usbDev.a_bRegs[0x4e], 2, SANE_TRUE ); + } + + while( scan->bLinesToSkip ) { + + DBG( _DBG_READ, "Skipping %u lines\n", scan->bLinesToSkip ); + + dwBytes = scan->bLinesToSkip * scan->sParam.Size.dwPhyBytes; + + if (dwBytes > scan->dwBytesScanBuf) { + + dwBytes = scan->dwBytesScanBuf; + scan->bLinesToSkip -= scan->dwLinesScanBuf; + } else { + scan->bLinesToSkip = 0; + } + + if( !usb_ScanReadImage( dev, scan->pbGetDataBuf, dwBytes )) + return 0; + } + + if( usb_ScanReadImage( dev, scan->pbGetDataBuf, dw )) { + + dumpPic("plustek-pic.raw", scan->pbGetDataBuf, dw, 0); + + if( scan->dwLinesDiscard ) { + + DBG(_DBG_READ, "Discarding %lu lines\n", scan->dwLinesDiscard); + + dwRet = dw / scan->sParam.Size.dwPhyBytes; + + if (scan->dwLinesDiscard > dwRet) { + scan->dwLinesDiscard -= dwRet; + dwRet = 0; + } else { + dwRet -= scan->dwLinesDiscard; + scan->dwLinesDiscard = 0; + } + } else { + + dwRet = dw / scan->sParam.Size.dwPhyBytes; + } + + scan->pbGetDataBuf += scan->dwBytesScanBuf; + if( scan->pbGetDataBuf >= scan->pbScanBufEnd ) { + scan->pbGetDataBuf = scan->pbScanBufBegin; + } + + if( dwRet ) + return dwRet; + } + } + return 0; +} + +/* END PLUSTEK-USBIMG.C .....................................................*/ |