mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Major update, see doc/plustek/Plustek-USB.changes.

merge-requests/1/head
Gerhard Jaeger 2004-07-02 13:09:36 +00:00
rodzic f0292c1adf
commit 51549b4570
14 zmienionych plików z 2005 dodań i 1534 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

286
backend/plustek-usb.c
Wyświetl plik

@ -37,6 +37,7 @@
* - removed PATH_MAX
* - change usbDev_stopScan and usbDev_open prototype
* - cleanup
* - 0.48 - added function usb_CheckAndCopyAdjs()
* .
* <hr>
* This file is part of the SANE package.
@ -115,10 +116,10 @@ static SANE_Char USB_devname[1024];
static SANE_Bool usb_normFileName( char *fname, char* buffer, u_long max_len )
{
char *src, *dst;
if( NULL == fname )
return SANE_FALSE;
if( strlen( fname ) >= max_len )
return SANE_FALSE;
@ -135,10 +136,35 @@ static SANE_Bool usb_normFileName( char *fname, char* buffer, u_long max_len )
*src++;
}
*dst = '\0';
return SANE_TRUE;
}
/** do some range checking and copy the adjustment values from the
* frontend to our internal structures, so that the backend can take
* care of them.
*/
static void usb_CheckAndCopyAdjs( Plustek_Device *dev )
{
if( dev->adj.lampOff >= 0 )
dev->usbDev.dwLampOnPeriod = dev->adj.lampOff;
if( dev->adj.lampOffOnEnd >= 0 )
dev->usbDev.bLampOffOnEnd = dev->adj.lampOffOnEnd;
if( dev->adj.skipCalibration > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_BYPASS_CALIBRATION;
if( dev->adj.skipFine > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_SKIP_FINE;
if( dev->adj.skipFineWhite > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_SKIP_WHITEFINE;
if( dev->adj.invertNegatives > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_INV_NEGATIVE_MAP;
}
/**
* assign the values to the structures used by the currently found scanner
*/
@ -167,27 +193,7 @@ static void usb_initDev( pPlustek_Device dev, int idx, int handle, int vendor )
dev->usbDev.Caps.wFlags |= tmp;
}
if( dev->adj.warmup >= 0 )
dev->usbDev.dwWarmup = dev->adj.warmup;
if( dev->adj.lampOff >= 0 )
dev->usbDev.dwLampOnPeriod = dev->adj.lampOff;
if( dev->adj.lampOffOnEnd >= 0 )
dev->usbDev.bLampOffOnEnd = dev->adj.lampOffOnEnd;
if( dev->adj.skipCalibration > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_BYPASS_CALIBRATION;
if( dev->adj.skipFine > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_SKIP_FINE;
if( dev->adj.skipFineWhite > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_SKIP_WHITEFINE;
if( dev->adj.invertNegatives > 0 )
dev->usbDev.Caps.workaroundFlag |= _WAF_INV_NEGATIVE_MAP;
usb_CheckAndCopyAdjs( dev );
DBG( _DBG_INFO, "Device WAF: 0x%08lx\n", dev->usbDev.Caps.workaroundFlag );
/* adjust data origin
@ -222,18 +228,6 @@ static void usb_initDev( pPlustek_Device dev, int idx, int handle, int vendor )
if( dev->adj.graygamma == 1.0 )
dev->adj.graygamma = dev->usbDev.HwSetting.gamma;
/* FIXME: not needed here??? */
#if 0
if( dev->adj.rlampoff > 0 )
dev->usbDev.HwSetting.red_lamp_off = dev->adj.rlampoff;
if( dev->adj.glampoff > 0 )
dev->usbDev.HwSetting.green_lamp_off = dev->adj.glampoff;
if( dev->adj.blampoff > 0 )
dev->usbDev.HwSetting.blue_lamp_off = dev->adj.blampoff;
#endif
/* the following you normally get from the registry...
*/
bMaxITA = 0; /* Maximum integration time adjust */
@ -242,32 +236,11 @@ static void usb_initDev( pPlustek_Device dev, int idx, int handle, int vendor )
dev->fd = handle;
/* check for TPA on EPSON device
*/
if((dev->initialized < 0) && vendor == 0x04B8 ) {
u_char t;
usb_switchLampX( dev, SANE_FALSE, SANE_TRUE );
usbio_WriteReg ( handle, 0x58, 0x1d );
usbio_WriteReg ( handle, 0x59, 0x49 );
usbio_ReadReg ( handle, 0x02, &t );
usbio_WriteReg ( handle, 0x58, dev->usbDev.HwSetting.bReg_0x58 );
usbio_WriteReg ( handle, 0x59, dev->usbDev.HwSetting.bReg_0x59 );
DBG( _DBG_INFO, "REG[0x02] = 0x%02x\n", t );
if( t & 0x02 ) {
DBG( _DBG_INFO, "TPA detected\n" );
if( dev->initialized < 0 ) {
if( usb_HasTPA( dev ))
dev->usbDev.Caps.wFlags |= DEVCAPSFLAG_TPA;
} else
DBG( _DBG_INFO, "TPA NOT detected\n" );
if( dev->adj.enableTpa ) {
DBG( _DBG_INFO, "Enabled TPA for EPSON (override)\n" );
dev->usbDev.Caps.wFlags |= DEVCAPSFLAG_TPA;
}
}
DBG( _DBG_INFO, "Device Flags: 0x%08x\n", dev->usbDev.Caps.wFlags );
/* well now we patch the vendor string...
* if not found, the default vendor will be Plustek
@ -281,13 +254,14 @@ static void usb_initDev( pPlustek_Device dev, int idx, int handle, int vendor )
}
}
dev->usbDev.currentLamp = usb_GetLampStatus( dev );
dev->usbDev.dwTicksLampOn = 0;
dev->usbDev.currentLamp = usb_GetLampStatus( dev );
usb_ResetRegisters( dev );
if( dev->initialized >= 0 )
return;
usbio_ResetLM983x ( dev );
usbio_ResetLM983x ( dev );
usb_IsScannerReady( dev );
sParam.bBitDepth = 8;
@ -587,7 +561,7 @@ static int usbDev_open( Plustek_Device *dev )
} else {
sprintf( dev->usbId, "0x%04X-0x%04X", vendor, product );
was_empty = SANE_TRUE;
}
}
} else {
@ -711,9 +685,9 @@ static int usbDev_getCaps( Plustek_Device *dev )
dev->caps.dwFlag = 0;
if(((DEVCAPSFLAG_Positive == scaps->wFlags) &&
(DEVCAPSFLAG_Negative == scaps->wFlags)) ||
(DEVCAPSFLAG_TPA == scaps->wFlags)) {
if(((DEVCAPSFLAG_Positive & scaps->wFlags) &&
(DEVCAPSFLAG_Negative & scaps->wFlags)) ||
(DEVCAPSFLAG_TPA & scaps->wFlags)) {
dev->caps.dwFlag |= SFLAG_TPA;
}
@ -746,7 +720,7 @@ static int usbDev_getCropInfo( Plustek_Device *dev, pCropInfo ci )
DBG( _DBG_INFO, "LPA = %lu\n", ci->dwLinesPerArea );
DBG( _DBG_INFO, "BPL = %lu\n", ci->dwBytesPerLine );
return 0;
return 0;
}
/**
@ -825,13 +799,14 @@ static int usbDev_setScanEnv( Plustek_Device *dev, pScanInfo si )
}
}
usb_SaveImageInfo( dev, &si->ImgDef );
usb_GetImageInfo ( &si->ImgDef, &dev->scanning.sParam.Size );
usb_SaveImageInfo( dev, &si->ImgDef );
usb_GetImageInfo ( &si->ImgDef, &dev->scanning.sParam.Size );
/* Flags */
dev->scanning.dwFlag = si->ImgDef.dwFlag & (SCANFLAG_bgr | SCANFLAG_BottomUp | SCANFLAG_Invert |
SCANFLAG_DWORDBoundary | SCANFLAG_RightAlign |
SCANFLAG_StillModule | SCANDEF_Adf | SCANDEF_ContinuousScan);
/* Flags */
dev->scanning.dwFlag = si->ImgDef.dwFlag &
(SCANFLAG_bgr | SCANFLAG_BottomUp | SCANFLAG_Invert |
SCANFLAG_DWORDBoundary | SCANFLAG_RightAlign |
SCANFLAG_StillModule | SCANDEF_Adf | SCANDEF_ContinuousScan);
if( !(SCANDEF_QualityScan & si->ImgDef.dwFlag)) {
DBG( _DBG_INFO, "* Preview Mode set!\n" );
@ -840,14 +815,14 @@ static int usbDev_setScanEnv( Plustek_Device *dev, pScanInfo si )
dev->scanning.dwFlag |= SCANDEF_QualityScan;
}
dev->scanning.sParam.siThreshold = si->siBrightness;
dev->scanning.sParam.brightness = si->siBrightness;
dev->scanning.sParam.contrast = si->siContrast;
dev->scanning.sParam.siThreshold = si->siBrightness;
dev->scanning.sParam.brightness = si->siBrightness;
dev->scanning.sParam.contrast = si->siContrast;
if( dev->scanning.sParam.bBitDepth <= 8 )
dev->scanning.dwFlag &= ~SCANFLAG_RightAlign;
if( dev->scanning.sParam.bBitDepth <= 8 )
dev->scanning.dwFlag &= ~SCANFLAG_RightAlign;
if( dev->scanning.dwFlag & SCANFLAG_DWORDBoundary ) {
if( dev->scanning.dwFlag & SCANFLAG_DWORDBoundary ) {
if( dev->scanning.fGrayFromColor )
dev->scanning.dwBytesLine = (dev->scanning.sParam.Size.dwBytes / 3 + 3) & 0xfffffffcUL;
else
@ -862,8 +837,8 @@ static int usbDev_setScanEnv( Plustek_Device *dev, pScanInfo si )
}
/* on CIS based devices we have to reconfigure the illumination
* settings for the gray modes
*/
* settings for the gray modes
*/
usb_AdjustCISLampSettings( dev, SANE_TRUE );
if( dev->scanning.dwFlag & SCANFLAG_BottomUp)
@ -872,7 +847,7 @@ static int usbDev_setScanEnv( Plustek_Device *dev, pScanInfo si )
dev->scanning.lBufAdjust = dev->scanning.dwBytesLine;
/* LM9831 has a BUG in 16-bit mode,
* so we generate pseudo 16-bit data from 8-bit
* so we generate pseudo 16-bit data from 8-bit
*/
if( dev->scanning.sParam.bBitDepth > 8 ) {
@ -884,38 +859,38 @@ static int usbDev_setScanEnv( Plustek_Device *dev, pScanInfo si )
}
}
/* Source selection */
if( dev->scanning.sParam.bSource == SOURCE_Reflection ) {
/* Source selection */
if( dev->scanning.sParam.bSource == SOURCE_Reflection ) {
dev->usbDev.pSource = &dev->usbDev.Caps.Normal;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Normal.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Normal.lUp;
dev->usbDev.pSource = &dev->usbDev.Caps.Normal;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Normal.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Normal.lUp;
} else if( dev->scanning.sParam.bSource == SOURCE_Transparency ) {
} else if( dev->scanning.sParam.bSource == SOURCE_Transparency ) {
dev->usbDev.pSource = &dev->usbDev.Caps.Positive;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Positive.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Positive.lUp;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Positive.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Positive.lUp;
} else if( dev->scanning.sParam.bSource == SOURCE_Negative ) {
dev->usbDev.pSource = &dev->usbDev.Caps.Negative;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Negative.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Negative.lUp;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Negative.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Negative.lUp;
} else {
dev->usbDev.pSource = &dev->usbDev.Caps.Adf;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Normal.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Normal.lUp;
dev->scanning.sParam.Origin.x += dev->usbDev.pSource->DataOrigin.x +
(u_long)dev->usbDev.Normal.lLeft;
dev->scanning.sParam.Origin.y += dev->usbDev.pSource->DataOrigin.y +
(u_long)dev->usbDev.Normal.lUp;
}
if( dev->scanning.sParam.bSource == SOURCE_ADF ) {
@ -1001,7 +976,7 @@ static int usbDev_startScan( Plustek_Device *dev )
* first we perform the calibration step, and then we read the image
* line for line
*/
static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
static int usbDev_Prepare( Plustek_Device *dev, SANE_Byte *buf )
{
int result;
SANE_Bool use_alt_cal = SANE_FALSE;
@ -1040,7 +1015,7 @@ static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
}
if( SANE_TRUE != result ) {
DBG( _DBG_INFO, "calibration failed!!!\n" );
DBG( _DBG_ERROR, "calibration failed!!!\n" );
return result;
}
@ -1078,63 +1053,63 @@ static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
/* gives faster feedback to the frontend ! */
scanning->dwLinesScanBuf = 2;
scanning->dwBytesScanBuf = scanning->dwLinesScanBuf *
scanning->sParam.Size.dwPhyBytes;
scanning->dwBytesScanBuf = scanning->dwLinesScanBuf *
scanning->sParam.Size.dwPhyBytes;
scanning->dwNumberOfScanBufs = _SCANBUF_SIZE /
scanning->dwBytesScanBuf;
scanning->dwLinesPerScanBufs = scanning->dwNumberOfScanBufs *
scanning->dwLinesScanBuf;
scanning->pbScanBufEnd = scanning->pbScanBufBegin +
scanning->dwLinesPerScanBufs *
scanning->sParam.Size.dwPhyBytes;
scanning->dwNumberOfScanBufs = _SCANBUF_SIZE /
scanning->dwBytesScanBuf;
scanning->dwLinesPerScanBufs = scanning->dwNumberOfScanBufs *
scanning->dwLinesScanBuf;
scanning->pbScanBufEnd = scanning->pbScanBufBegin +
scanning->dwLinesPerScanBufs *
scanning->sParam.Size.dwPhyBytes;
scanning->dwRedShift = 0;
scanning->dwBlueShift = 0;
scanning->dwGreenShift = 0;
/* CCD scanner */
if( scanning->sParam.bChannels == 3 ) {
if( scanning->sParam.bChannels == 3 ) {
scanning->dwLinesDiscard = (u_long)scaps->bSensorDistance *
scanning->sParam.PhyDpi.y / scaps->OpticDpi.y;
scanning->dwLinesDiscard = (u_long)scaps->bSensorDistance *
scanning->sParam.PhyDpi.y / scaps->OpticDpi.y;
switch( scaps->bSensorOrder ) {
switch( scaps->bSensorOrder ) {
case SENSORORDER_rgb:
scanning->Red.pb = scanning->pbScanBufBegin;
scanning->Green.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
break;
case SENSORORDER_rgb:
scanning->Red.pb = scanning->pbScanBufBegin;
scanning->Green.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
break;
case SENSORORDER_rbg:
scanning->Red.pb = scanning->pbScanBufBegin;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Green.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
break;
case SENSORORDER_rbg:
scanning->Red.pb = scanning->pbScanBufBegin;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Green.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
break;
case SENSORORDER_gbr:
scanning->Green.pb = scanning->pbScanBufBegin;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Red.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
break;
case SENSORORDER_gbr:
scanning->Green.pb = scanning->pbScanBufBegin;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Red.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
break;
case SENSORORDER_grb:
scanning->Green.pb = scanning->pbScanBufBegin;
scanning->Red.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
case SENSORORDER_grb:
scanning->Green.pb = scanning->pbScanBufBegin;
scanning->Red.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes;
scanning->Blue.pb = scanning->pbScanBufBegin +
scanning->dwLinesDiscard *
scanning->sParam.Size.dwPhyBytes * 2UL;
@ -1200,10 +1175,11 @@ static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
usb_GetImageProc( dev );
scanning->bLinesToSkip = (u_char)(scanning->sParam.PhyDpi.y / 50);
if( scanning->sParam.bSource == SOURCE_ADF )
scanning->dwFlag |= SCANFLAG_StillModule;
DBG( _DBG_INFO, "* scanning->dwFlag=0x%08lx\n", scanning->dwFlag );
if( !usb_ScanBegin( dev,
(scanning->dwFlag&SCANFLAG_StillModule) ? SANE_FALSE:SANE_TRUE)) {
@ -1222,7 +1198,7 @@ static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
DBG( _DBG_INFO, "SampleY Flag set (%u != %u, wSumY=%u)\n",
scanning->sParam.UserDpi.y,
scanning->sParam.PhyDpi.y, scanning->wSumY );
}
}
}
}
@ -1245,7 +1221,7 @@ static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
scanning->sParam.Size.dwLines -= scanning->dwLinesUser;
if( scanning->dwFlag & SCANFLAG_BottomUp )
scanning->UserBuf.pb = buf + (scanning->dwLinesUser - 1) *
scanning->dwBytesLine;
scanning->dwBytesLine;
else
scanning->UserBuf.pb = buf;
@ -1277,9 +1253,9 @@ static int usbDev_Prepare( struct Plustek_Device *dev, SANE_Byte *buf )
return 0;
}
/**
/** as the name says, read one line...
*/
static int usbDev_readLine( struct Plustek_Device *dev )
static int usbDev_ReadLine( Plustek_Device *dev )
{
int wrap;
u_long cur;

143
backend/plustek-usb.h
Wyświetl plik

@ -30,6 +30,8 @@
* - added additional defines for cis and epson-ccd sensor
* - 0.47 - cleanup work
* - added gamma to struct HWDefault
* - 0.48 - added DEVCAPSFLAG_LargeTPA
* - added min_ffstep to ClkMotorDef
* .
* <hr>
* This file is part of the SANE package.
@ -74,33 +76,33 @@
#ifndef __PLUSTEK_USB_H__
#define __PLUSTEK_USB_H__
/** CCD ID (PCB ID): total 3 bits */
#define kNEC3799 0
#define kSONY518 1
#define kSONY548 2
#define kNEC8861 3
#define kNEC3778 4
#define kNECSLIM 5
#define kCIS650 6
#define kCIS670 7
#define kCIS1220 8
#define kCIS1240 9
#define kEPSON 10
/** CCD ID (PCB ID): total 3 bits (on Plustek devices) */
#define kNEC3799 0
#define kSONY518 1
#define kSONY548 2
#define kNEC8861 3
#define kNEC3778 4
#define kNECSLIM 5
#define kCIS650 6
#define kCIS670 7
#define kCIS1220 8
#define kCIS1240 9
#define kEPSON 10
/*********************************** plustek_types.h!!! ************************/
/* makes trouble with gcc3
#define _SWAP(x,y) (x)^=(y)^=(x)^=(y)
#define _SWAP(x,y) (x)^=(y)^=(x)^=(y)
*/
#define _SWAP(x,y) {(x)^=(y); (x)^=((y)^=(x));}
#define _SWAP(x,y) { (x)^=(y); (x)^=((y)^=(x));}
#define _LOWORD(x) ((u_short)(x & 0xffff))
#define _HIWORD(x) ((u_short)(x >> 16))
#define _LOWORD(x) ((u_short)(x & 0xffff))
#define _HIWORD(x) ((u_short)(x >> 16))
#define _LOBYTE(x) ((u_char)((x) & 0xFF))
#define _HIBYTE(x) ((u_char)((x) >> 8))
#define _HILO2WORD(x) ((u_short)x.bHi * 256U + x.bLo)
#define _PHILO2WORD(x) ((u_short)x->bHi * 256U + x->bLo)
#define _HILO2WORD(x) ((u_short)x.bHi * 256U + x.bLo)
#define _PHILO2WORD(x) ((u_short)x->bHi * 256U + x->bLo)
/* useful for RGB-values */
typedef struct {
@ -142,14 +144,14 @@ typedef union {
typedef union {
u_char *pb;
u_char *pb;
u_short *pw;
pMonoWordDef pmw;
pColorByteDef pcb;
pColorWordDef pcw;
pRGBByteDef pb_rgb;
pRGBUShortDef pw_rgb;
pHiLoDef philo;
pHiLoDef philo;
} AnyPtr, *pAnyPtr;
@ -158,18 +160,18 @@ typedef struct {
unsigned short y;
} XY, *pXY;
#define _VAR_NOT_USED(x) ((x)=(x))
#define _VAR_NOT_USED(x) ((x)=(x))
/*****************************************************************************/
#define IDEAL_GainNormal 0xf000UL /* 240 */
#define IDEAL_GainPositive 0xfe00UL /* 254 */
#define IDEAL_Offset 0x1000UL /* 20 */
#define IDEAL_GainNormal 0xf000UL /* 240 */
#define IDEAL_GainPositive 0xfe00UL /* 254 */
#define IDEAL_Offset 0x1000UL /* 20 */
#define GAIN_Target 65535UL
#define GAIN_Target 65535UL
#define DRAM_UsedByAsic8BitMode 216 /* in KB */
#define DRAM_UsedByAsic16BitMode 196 /*192*/ /* in KB */
#define DRAM_UsedByAsic8BitMode 216 /* in KB */
#define DRAM_UsedByAsic16BitMode 196 /*192*/ /* in KB */
/** Chip-types */
typedef enum _CHIPSET
@ -211,11 +213,12 @@ enum _SENSORCOLOR
/** DCapsDef.wFlags */
enum _DEVCAPSFLAG
{
DEVCAPSFLAG_Normal = 0x0001,
DEVCAPSFLAG_Positive = 0x0002,
DEVCAPSFLAG_Negative = 0x0004,
DEVCAPSFLAG_TPA = 0x0006,
DEVCAPSFLAG_Adf = 0x0008
DEVCAPSFLAG_Normal = 0x0001,
DEVCAPSFLAG_Positive = 0x0002,
DEVCAPSFLAG_Negative = 0x0004,
DEVCAPSFLAG_TPA = 0x0006,
DEVCAPSFLAG_Adf = 0x0008,
DEVCAPSFLAG_LargeTPA = 0x0010
};
/** to allow some workarounds */
@ -244,13 +247,13 @@ enum _LAMPS
};
/** for encoding a misc I/O register as TPA */
#define _TPA(register) ((u_long)(register << 16))
#define _TPA(register) ((u_long)(register << 16))
/** Mask to check for available TPA */
#define _HAS_TPA(flag) (flag & 0xFFFF0000)
#define _HAS_TPA(flag) (flag & 0xFFFF0000)
/** Get the TPA misc I/O register */
#define _GET_TPALAMP(flag) (flag >> 16)
#define _GET_TPALAMP(flag) (flag >> 16)
/** motor types */
typedef enum
@ -297,16 +300,22 @@ enum MODULEMOVE
/** SCANDEF.dwFlags */
enum SCANFLAG
{
SCANFLAG_bgr = 0x00000010,
SCANFLAG_BottomUp = 0x00000020,
SCANFLAG_Invert = 0x00000040,
SCANFLAG_DWORDBoundary = 0x00000080,
SCANFLAG_RightAlign = 0x00000100,
SCANFLAG_StillModule = 0x00000200,
SCANFLAG_StartScan = 0x40000000,
SCANFLAG_Scanning = 0x20000080,
SCANFLAG_Pseudo48 = 0x08000000,
SCANFLAG_SampleY = 0x04000000
SCANDEF_Transparency = 0x00000100, /* Scanning from transparency*/
SCANDEF_Negative = 0x00000200, /* Scanning from negative */
SCANDEF_QualityScan = 0x00000400, /* Scanning in quality mode */
SCANDEF_ContinuousScan = 0x00001000,
SCANDEF_Adf = 0x00002000, /* Scan from ADF tray */
SCANFLAG_bgr = 0x00004000,
SCANFLAG_BottomUp = 0x00008000,
SCANFLAG_Invert = 0x00010000,
SCANFLAG_DWORDBoundary = 0x00020000,
SCANFLAG_RightAlign = 0x00040000,
SCANFLAG_StillModule = 0x00080000,
SCANFLAG_StartScan = 0x40000000,
SCANFLAG_Scanning = 0x20020000,
SCANFLAG_Pseudo48 = 0x08000000,
SCANFLAG_SampleY = 0x04000000
};
typedef struct Origins
@ -317,15 +326,15 @@ typedef struct Origins
typedef struct SrcAttr
{
XY DataOrigin; /**< The origin x is from visible pixel not CCD */
XY DataOrigin; /**< The origin x is from visible pixel not CCD */
/* pixel 0, in 300 DPI base. */
/* The origin y is from visible top */
/* The origin y is from visible top */
/* (glass area), in 300 DPI */
short ShadingOriginY; /**< The origin y is from top of scanner body */
short ShadingOriginY; /**< The origin y is from top of scanner body */
short DarkShadOrgY; /**< if the device has a dark calibration strip */
XY Size; /**< Scanning width/height, in 300 DPI base. */
XY MinDpi; /**< Minimum dpi supported for scanning */
u_char bMinDataType; /**< Minimum data type supports */
XY Size; /**< Scanning width/height, in 300 DPI base. */
XY MinDpi; /**< Minimum dpi supported for scanning */
u_char bMinDataType; /**< Minimum data type supports */
} SrcAttrDef, *pSrcAttrDef;
@ -456,16 +465,15 @@ typedef struct DeviceDef
DCapsDef Caps; /**< pointer to the attribute of current dev */
HWDef HwSetting; /**< Pointer to the characteristics of device */
pSrcAttrDef pSource; /**< Scanning src, it's equal to Caps.Normal */
/**< on the source that the user specified. */
OrgDef Normal; /**< Reflection - Pix to adjust scanning orgs */
OrgDef Positive; /**< Pos film - Pix to adjust scanning orgs */
OrgDef Negative; /**< Neg film - Pix to adjust scanning orgs */
OrgDef Adf; /**< Adf - Pixels to adjust scanning origins */
u_long dwWarmup; /**< Ticks to wait for lamp stable, in ms. */
u_long dwTicksLampOn; /**< The ticks when lamp turns on */
u_long dwLampOnPeriod;/**< How many seconds to keep lamp on */
SANE_Bool bLampOffOnEnd; /**< switch lamp off on end or keep cur. state*/
int currentLamp; /**< The lamp ID of the currently used lamp */
/**< on the source that the user specified. */
OrgDef Normal; /**< Reflection - Pix to adjust scanning orgs */
OrgDef Positive; /**< Pos film - Pix to adjust scanning orgs */
OrgDef Negative; /**< Neg film - Pix to adjust scanning orgs */
OrgDef Adf; /**< Adf - Pixels to adjust scanning origins */
u_long dwTicksLampOn; /**< The ticks when lamp turns on */
u_long dwLampOnPeriod;/**< How many seconds to keep lamp on */
SANE_Bool bLampOffOnEnd; /**< switch lamp off on end or keep cur. state*/
int currentLamp; /**< The lamp ID of the currently used lamp */
} DeviceDef, *pDeviceDef;
@ -518,7 +526,7 @@ typedef struct
* unit based on 300 DPI
*/
XY UserDpi; /**< User specified DPI */
XY Origin; /**> Scanning origin in optic dpi */
XY Origin; /**< Scanning origin in optic dpi */
double dMCLK; /**< for positive & negative & Adf */
short brightness;
short contrast;
@ -609,12 +617,13 @@ typedef struct
*/
typedef struct {
eModelDef motorModel; /**< the motor ID */
u_char pwm_fast; /**< PWM during fast movement */
u_char pwm_duty_fast; /**< PWM duty during fast movement */
u_char mclk_fast; /**< MCLK during fast movement */
eModelDef motorModel; /**< the motor ID */
u_char pwm_fast; /**< PWM during fast movement */
u_char pwm_duty_fast; /**< PWM duty during fast movement */
u_char mclk_fast; /**< MCLK during fast movement */
u_short min_ffstep; /**< minimal ffstep size for speedup,
0xffff disables the stuff */
/**
* here we define some ranges for better supporting
* non-Plustek devices with it's different hardware

99
backend/plustek-usbcal.c
Wyświetl plik

@ -37,6 +37,7 @@
* - 0.47 - moved usb_HostSwap() to plustek_usbhw.c
* - fixed problem in cano_AdjustLightsource(), so that it won't
* stop too early.
* - 0.48 - cleanup
*
* This file is part of the SANE package.
*
@ -203,7 +204,7 @@ static int cano_adjLampSetting( u_short *min,
* for this channel to recalibrate.
*/
if( *off > 0x3FFF ) {
DBG( _DBG_INFO2, "* lamp off limited (0x%04x --> 0x3FFF)\n", *off);
DBG( _DBG_INFO, "* lamp off limited (0x%04x --> 0x3FFF)\n", *off);
*off = 0x3FFF;
return 0;
}
@ -237,10 +238,10 @@ static int cano_AdjustLightsource( pPlustek_Device dev )
if( usb_IsEscPressed())
return SANE_FALSE;
DBG( _DBG_INFO2, "cano_AdjustLightsource()\n" );
DBG( _DBG_INFO, "cano_AdjustLightsource()\n" );
if( !(hw->bReg_0x26 & _ONE_CH_COLOR)) {
DBG( _DBG_INFO2, "- function skipped, CCD device!\n" );
DBG( _DBG_INFO, "- function skipped, CCD device!\n" );
if( !usb_Wait4Warmup( dev )) {
DBG( _DBG_ERROR, "cano_AdjustLightsource() - CANCEL detected\n" );
@ -274,6 +275,12 @@ static int cano_AdjustLightsource( pPlustek_Device dev )
min_rgb.Green = hw->green_lamp_on;
min_rgb.Blue = hw->blue_lamp_on;
if((dev->adj.rlampoff != -1) &&
(dev->adj.glampoff != -1) && (dev->adj.rlampoff != -1)) {
DBG( _DBG_INFO, "- function skipped, using frontend values!\n" );
return SANE_TRUE;
}
for( i = 0; ; i++ ) {
m_ScanParam.dMCLK = dMCLK;
@ -346,20 +353,20 @@ static int cano_AdjustLightsource( pPlustek_Device dev )
if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
DBG( _DBG_INFO2, "red_lamp_off = %u/%u/%u\n",
min_rgb.Red ,hw->red_lamp_off, max_rgb.Red );
min_rgb.Red ,hw->red_lamp_off, max_rgb.Red );
}
DBG( _DBG_INFO2, "green_lamp_off = %u/%u/%u\n",
min_rgb.Green, hw->green_lamp_off, max_rgb.Green );
min_rgb.Green, hw->green_lamp_off, max_rgb.Green );
if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
DBG( _DBG_INFO2, "blue_lamp_off = %u/%u/%u\n",
min_rgb.Blue, hw->blue_lamp_off, max_rgb.Blue );
min_rgb.Blue, hw->blue_lamp_off, max_rgb.Blue );
}
DBG(_DBG_INFO2, "CUR(R,G,B)= 0x%04x(%u), 0x%04x(%u), 0x%04x(%u)\n",
tmp_rgb.Red, tmp_rgb.Red, tmp_rgb.Green,
tmp_rgb.Green, tmp_rgb.Blue, tmp_rgb.Blue );
tmp_rgb.Red, tmp_rgb.Red, tmp_rgb.Green,
tmp_rgb.Green, tmp_rgb.Blue, tmp_rgb.Blue );
res_r = 0;
res_g = 0;
res_b = 0;
@ -367,13 +374,13 @@ static int cano_AdjustLightsource( pPlustek_Device dev )
/* bisect */
if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
res_r = cano_adjLampSetting( &min_rgb.Red, &max_rgb.Red,
&hw->red_lamp_off, tmp_rgb.Red );
&hw->red_lamp_off, tmp_rgb.Red );
res_b = cano_adjLampSetting( &min_rgb.Blue, &max_rgb.Blue,
&hw->blue_lamp_off,tmp_rgb.Blue );
&hw->blue_lamp_off,tmp_rgb.Blue );
}
res_g = cano_adjLampSetting( &min_rgb.Green, &max_rgb.Green,
&hw->green_lamp_off, tmp_rgb.Green );
&hw->green_lamp_off, tmp_rgb.Green );
/* nothing adjusted, so stop here */
if((res_r == 0) && (res_g == 0) && (res_b == 0))
@ -396,14 +403,14 @@ static int cano_AdjustLightsource( pPlustek_Device dev )
usb_AdjustLamps(dev);
}
DBG( _DBG_INFO2, "* red_lamp_on = %u\n", hw->red_lamp_on );
DBG( _DBG_INFO2, "* red_lamp_off = %u\n", hw->red_lamp_off );
DBG( _DBG_INFO2, "* green_lamp_on = %u\n", hw->green_lamp_on );
DBG( _DBG_INFO2, "* green_lamp_off = %u\n", hw->green_lamp_off );
DBG( _DBG_INFO2, "* blue_lamp_on = %u\n", hw->blue_lamp_on );
DBG( _DBG_INFO2, "* blue_lamp_off = %u\n", hw->blue_lamp_off );
DBG( _DBG_INFO, "* red_lamp_on = %u\n", hw->red_lamp_on );
DBG( _DBG_INFO, "* red_lamp_off = %u\n", hw->red_lamp_off );
DBG( _DBG_INFO, "* green_lamp_on = %u\n", hw->green_lamp_on );
DBG( _DBG_INFO, "* green_lamp_off = %u\n", hw->green_lamp_off );
DBG( _DBG_INFO, "* blue_lamp_on = %u\n", hw->blue_lamp_on );
DBG( _DBG_INFO, "* blue_lamp_off = %u\n", hw->blue_lamp_off );
DBG( _DBG_INFO2, "cano_AdjustLightsource() done.\n" );
DBG( _DBG_INFO, "cano_AdjustLightsource() done.\n" );
return SANE_TRUE;
}
@ -458,19 +465,25 @@ static SANE_Bool cano_AdjustGain( pPlustek_Device dev )
bMaxITA = 0xff;
max[0] = max[1] = max[2] = 0x3f;
min[0] = min[1] = min[2] = 1;
max[0] = max[1] = max[2] = 0x3f;
min[0] = min[1] = min[2] = 1;
DBG( _DBG_INFO2, "cano_AdjustGain()\n" );
DBG( _DBG_INFO, "cano_AdjustGain()\n" );
if((dev->adj.rgain != -1) &&
(dev->adj.ggain != -1) && (dev->adj.bgain != -1)) {
setAdjGain( dev->adj.rgain, &a_bRegs[0x3b] );
setAdjGain( dev->adj.ggain, &a_bRegs[0x3c] );
setAdjGain( dev->adj.bgain, &a_bRegs[0x3d] );
DBG( _DBG_INFO, "- function skipped, using frontend values!\n" );
return SANE_TRUE;
}
/*
* define the strip to scan for coarse calibration
/* define the strip to scan for coarse calibration
* done at 300dpi
*/
m_ScanParam.Size.dwLines = 1; /* for gain */
m_ScanParam.Size.dwLines = 1; /* for gain */
m_ScanParam.Size.dwPixels = scaps->Normal.Size.x *
scaps->OpticDpi.x / 300UL;
scaps->OpticDpi.x / 300UL;
m_ScanParam.Size.dwBytes = m_ScanParam.Size.dwPixels * 2;
@ -480,7 +493,7 @@ static SANE_Bool cano_AdjustGain( pPlustek_Device dev )
}
m_ScanParam.Origin.x = (u_short)((u_long) hw->wActivePixelsStart *
300UL / scaps->OpticDpi.x);
300UL / scaps->OpticDpi.x);
m_ScanParam.bCalibration = PARAM_Gain;
DBG( _DBG_INFO2, "Coarse Calibration Strip:\n" );
@ -583,7 +596,7 @@ static SANE_Bool cano_AdjustGain( pPlustek_Device dev )
}
DBG( _DBG_INFO2, "cano_AdjustGain() done.\n" );
DBG( _DBG_INFO, "cano_AdjustGain() done.\n" );
return SANE_TRUE;
}
@ -648,9 +661,17 @@ static int cano_AdjustOffset( pPlustek_Device dev )
if( usb_IsEscPressed())
return SANE_FALSE;
DBG( _DBG_INFO2, "cano_AdjustOffset()\n" );
DBG( _DBG_INFO, "cano_AdjustOffset()\n" );
if((dev->adj.rofs != -1) &&
(dev->adj.gofs != -1) && (dev->adj.bofs != -1)) {
a_bRegs[0x38] = (dev->adj.rofs & 0x3f);
a_bRegs[0x39] = (dev->adj.gofs & 0x3f);
a_bRegs[0x3a] = (dev->adj.bofs & 0x3f);
DBG( _DBG_INFO, "- function skipped, using frontend values!\n" );
return SANE_TRUE;
}
m_ScanParam.Size.dwLines = 1; /* for gain */
m_ScanParam.Size.dwLines = 1;
m_ScanParam.Size.dwPixels = scaps->Normal.Size.x*scaps->OpticDpi.x/300UL;
if( hw->bReg_0x26 & _ONE_CH_COLOR )
@ -775,7 +796,7 @@ static int cano_AdjustOffset( pPlustek_Device dev )
a_bRegs[0x38] = a_bRegs[0x39] = a_bRegs[0x3a] = now[0];
}
DBG( _DBG_INFO2, "cano_AdjustOffset() done.\n" );
DBG( _DBG_INFO, "cano_AdjustOffset() done.\n" );
return SANE_TRUE;
}
@ -795,7 +816,7 @@ static SANE_Bool cano_AdjustDarkShading( pPlustek_Device dev )
int step, stepW, val;
u_long red, green, blue, gray;
DBG( _DBG_INFO2, "cano_AdjustDarkShading()\n" );
DBG( _DBG_INFO, "cano_AdjustDarkShading()\n" );
if( usb_IsEscPressed())
return SANE_FALSE;
@ -915,7 +936,7 @@ static SANE_Bool cano_AdjustDarkShading( pPlustek_Device dev )
a_wDarkShading, m_ScanParam.Size.dwPhyPixels * 2);
}
DBG( _DBG_INFO2, "cano_AdjustDarkShading() done\n" );
DBG( _DBG_INFO, "cano_AdjustDarkShading() done\n" );
return SANE_TRUE;
}
@ -935,7 +956,7 @@ static SANE_Bool cano_AdjustWhiteShading( pPlustek_Device dev )
int step, stepW;
u_long red, green, blue, gray;
DBG( _DBG_INFO2, "cano_AdjustWhiteShading()\n" );
DBG( _DBG_INFO, "cano_AdjustWhiteShading()\n" );
if( usb_IsEscPressed())
return SANE_FALSE;
@ -950,7 +971,7 @@ static SANE_Bool cano_AdjustWhiteShading( pPlustek_Device dev )
m_ScanParam.Origin.y = 0;
m_ScanParam.bBitDepth = 16;
m_ScanParam.UserDpi.y = scaps->OpticDpi.y;
m_ScanParam.UserDpi.y = scaps->OpticDpi.y;
m_ScanParam.Size.dwBytes = m_ScanParam.Size.dwPixels * 2;
if( hw->bReg_0x26 & _ONE_CH_COLOR &&
@ -1042,12 +1063,12 @@ static SANE_Bool cano_AdjustWhiteShading( pPlustek_Device dev )
usb_Swap(a_wWhiteShading, m_ScanParam.Size.dwPhyPixels * 2 );
memcpy(a_wWhiteShading+ m_ScanParam.Size.dwPhyPixels * 2,
a_wWhiteShading, m_ScanParam.Size.dwPhyPixels * 2);
a_wWhiteShading, m_ScanParam.Size.dwPhyPixels * 2);
memcpy(a_wWhiteShading+ m_ScanParam.Size.dwPhyPixels * 4,
a_wWhiteShading, m_ScanParam.Size.dwPhyPixels * 2);
a_wWhiteShading, m_ScanParam.Size.dwPhyPixels * 2);
}
DBG( _DBG_INFO2, "cano_AdjustWhiteShading() done\n" );
DBG( _DBG_INFO, "cano_AdjustWhiteShading() done\n" );
return SANE_TRUE;
}
@ -1062,7 +1083,7 @@ static int cano_DoCalibration( pPlustek_Device dev )
if( SANE_TRUE == scanning->fCalibrated )
return SANE_TRUE;
DBG( _DBG_INFO2, "cano_DoCalibration()\n" );
DBG( _DBG_INFO, "cano_DoCalibration()\n" );
if( _IS_PLUSTEKMOTOR(hw->motorModel)){
DBG( _DBG_ERROR, "altCalibration can't work with this Plustek motor control setup\n" );

1
backend/plustek-usbcalfile.c
Wyświetl plik

@ -11,6 +11,7 @@
* History:
* - 0.46 - first version
* - 0.47 - no changes
* - 0.48 - no changes
* .
* <hr>
* This file is part of the SANE package.

778
backend/plustek-usbdevs.c
Wyświetl plik

Plik diff jest za duży Load Diff

350
backend/plustek-usbhw.c
Wyświetl plik

@ -34,6 +34,11 @@
* - 0.47 - moved usb_HostSwap() and usb_Swap() to this file.
* - fixed lampOff timer for systems w/o setitimer
* - added lamp off adjustment for CIS devices
* - 0.48 - added usb_IsCISDevice()
* - added usb_HasTPA()
* - changed usb_Wait4Warmup()
* - added usb_WaitPos()
* - added usb_FillLampRegs() - sets also PWMDutyCylce now
* .
* <hr>
* This file is part of the SANE package.
@ -93,7 +98,6 @@ static SANE_Bool fModuleFirstHome; /* HEINER: this has to be initialized */
static SANE_Bool fLastScanIsAdf;
static u_char a_bRegs[0x80]; /**< our global register file */
/** the NatSemi 983x is a big endian chip, and the line protocol data all
* arrives big-endian. This determines if we need to swap to host-order
*/
@ -107,7 +111,7 @@ static SANE_Bool usb_HostSwap( void )
return 0;
}
DBG( _DBG_READ, "We're little-endian! NatSemi LM983x is big!\n" );
DBG( _DBG_READ, "--> Must swap calibration data!\n" );
DBG( _DBG_READ, "--> Must swap data!\n" );
return 1;
}
@ -153,12 +157,19 @@ static SANE_Bool usb_MotorOn( int handle, SANE_Bool fOn )
return SANE_TRUE;
}
/**
*/
static SANE_Bool usb_IsCISDevice( Plustek_Device *dev )
{
return ( dev->usbDev.HwSetting.bReg_0x26 & _ONE_CH_COLOR );
}
/** check if scanner is ready
*/
static SANE_Bool usb_IsScannerReady( pPlustek_Device dev )
static SANE_Bool usb_IsScannerReady( Plustek_Device *dev )
{
u_char value;
double len;
u_char value;
double len;
long timeout;
struct timeval t;
@ -170,7 +181,7 @@ static SANE_Bool usb_IsScannerReady( pPlustek_Device dev )
/* wait at least 10 seconds... */
if( len < 10 )
len = 10;
gettimeofday( &t, NULL);
timeout = t.tv_sec + len;
@ -222,6 +233,63 @@ static SANE_Bool usb_SensorPaper( int handle )
return (value & 0x02);
}
/** function to move the sensor and to speed it up to a certain speed until
* the position is reached
*/
static SANE_Bool usb_WaitPos( Plustek_Device *dev, u_long to, SANE_Bool stay )
{
u_char value;
u_short ffs, step;
long dwTicks;
double fac;
struct timeval start_time, t2;
pClkMotorDef clk = usb_GetMotorSet( dev->usbDev.HwSetting.motorModel );
gettimeofday( &start_time, NULL );
dwTicks = start_time.tv_sec + to;
step = 1;
ffs = a_bRegs[0x48] * 256 + a_bRegs[0x49];
DBG( _DBG_INFO2, "# FSS=%u (0x%04x)\n", ffs, ffs );
for(;;) {
usleep( 1000 );
_UIO( usbio_ReadReg( dev->fd, 0x07, &value ));
if (!value)
return SANE_TRUE;
gettimeofday(&t2, NULL);
if( t2.tv_sec > dwTicks )
break;
fac = 100.0/step;
if((u_short)fac < ffs )
ffs -= fac;
else
ffs = 0;
if( ffs > clk->min_ffstep ) {
if((int)fac > 25 )
usleep( 150 * 1000 );
a_bRegs[0x48] = (u_char)((u_short)ffs >> 8);
a_bRegs[0x49] = (u_char)((u_short)ffs & 0xFF);
sanei_lm983x_write(dev->fd, 0x48, &a_bRegs[0x48], 2, SANE_TRUE);
} else {
if( !stay )
return SANE_TRUE;
}
step++;
}
return SANE_FALSE;
}
/**
* Home sensor always on when backward move.
* dwStep is steps to move and based on 300 dpi, but
@ -229,10 +297,11 @@ static SANE_Bool usb_SensorPaper( int handle )
* to repeatly move the module around the scanner and
* 0 means forever.
*/
static SANE_Bool usb_ModuleMove( pPlustek_Device dev,
u_char bAction, u_long dwStep )
static SANE_Bool usb_ModuleMove( Plustek_Device *dev,
u_char bAction, u_long dwStep )
{
SANE_Status res;
SANE_Bool retval;
u_char bReg2, reg7, mclk_div;
u_short wFastFeedStepSize;
double dMaxMoveSpeed;
@ -373,6 +442,8 @@ static SANE_Bool usb_ModuleMove( pPlustek_Device dev,
} else {
return SANE_TRUE;
}
retval = SANE_FALSE;
if( usbio_WriteReg( dev->fd, 0x07, reg7 )) {
@ -416,34 +487,21 @@ static SANE_Bool usb_ModuleMove( pPlustek_Device dev,
}
} else {
for(;;) {
usleep(10 * 1000);
_UIO( usbio_ReadReg( dev->fd, 0x07, &reg7));
if( !reg7 ) {
usbio_WriteReg( dev->fd, 0x58, a_bRegs[0x58] );
usbio_ReadReg( dev->fd, 0x02, &bReg2 );
return SANE_TRUE;
}
gettimeofday(&t2, NULL);
if( t2.tv_sec > dwTicks )
break;
}
retval = usb_WaitPos( dev, 200, SANE_TRUE );
}
usbio_WriteReg( dev->fd, 0x58, a_bRegs[0x58] );
usbio_ReadReg ( dev->fd, 0x02, &bReg2 );
}
DBG( _DBG_ERROR, "Position NOT reached\n" );
return SANE_FALSE;
if( !retval )
DBG( _DBG_ERROR, "Position NOT reached\n" );
return retval;
}
/**
*/
static SANE_Bool usb_ModuleToHome( pPlustek_Device dev, SANE_Bool fWait )
static SANE_Bool usb_ModuleToHome( Plustek_Device *dev, SANE_Bool fWait )
{
u_char mclk_div;
u_char value;
@ -596,9 +654,9 @@ static SANE_Bool usb_ModuleToHome( pPlustek_Device dev, SANE_Bool fWait )
return SANE_FALSE;
#if 0
if(Device.HwSetting.motorModel == MODEL_Tokyo600)
{
DWORD dwSpeedUp = GetTickCount () + 250;
if( hw->motorModel == MODEL_Tokyo600) {
u_long dwSpeedUp = GetTickCount () + 250;
//while(GetTickCount () < dwSpeedUp)
while((int)(dwSpeedUp - GetTickCount ()) > 0)
@ -617,37 +675,12 @@ static SANE_Bool usb_ModuleToHome( pPlustek_Device dev, SANE_Bool fWait )
}
#endif
}
if( fWait ) {
long dwTicks;
struct timeval start_time, t2;
gettimeofday( &start_time, NULL );
dwTicks = start_time.tv_sec + 150;
for(;;) {
usleep( 20 * 1000 );
_UIO( usbio_ReadReg( dev->fd, 0x07, &value ));
if (!value)
return SANE_TRUE;
gettimeofday(&t2, NULL);
if( t2.tv_sec > dwTicks )
break;
}
return SANE_FALSE;
}
return SANE_TRUE;
return usb_WaitPos( dev, 150, fWait );
}
/**
*/
static SANE_Bool usb_MotorSelect( pPlustek_Device dev, SANE_Bool fADF )
static SANE_Bool usb_MotorSelect( Plustek_Device *dev, SANE_Bool fADF )
{
pDCapsDef sCaps = &dev->usbDev.Caps;
pHWDef hw = &dev->usbDev.HwSetting;
@ -689,7 +722,7 @@ static SANE_Bool usb_MotorSelect( pPlustek_Device dev, SANE_Bool fADF )
/** function to adjust the lamp settings of a device
*/
static SANE_Bool usb_AdjustLamps( pPlustek_Device dev )
static SANE_Bool usb_AdjustLamps( Plustek_Device *dev )
{
pHWDef hw = &dev->usbDev.HwSetting;
@ -822,7 +855,7 @@ static void usb_GetLampRegAndMask( u_long flag, SANE_Byte *reg, SANE_Byte *msk )
}
}
/** usb_Get
/** usb_GetLampStatus
* This function returns the current lamp in use.
* For non Plustek devices, it always returns DEV_LampReflection.
* @param dev - pointer to our device structure,
@ -831,7 +864,7 @@ static void usb_GetLampRegAndMask( u_long flag, SANE_Byte *reg, SANE_Byte *msk )
* for the normal lamp, or DEV_LampTPA for negative/transparency
* lamp
*/
static int usb_GetLampStatus( pPlustek_Device dev )
static int usb_GetLampStatus( Plustek_Device *dev )
{
int iLampStatus = 0;
pHWDef hw = &dev->usbDev.HwSetting;
@ -844,7 +877,15 @@ static int usb_GetLampStatus( pPlustek_Device dev )
return -1;
}
/* do we use the misc I/O pins for switching the lamp ? */
#if 0
/* on the CanoScan D660U switch always... */
if((dev->usbDev.vendor == 0x04A9) && (dev->usbDev.product==0x2208)) {
DBG( _DBG_INFO, "CanoScan D660U -> Lamp is off!!!\n" );
return 0;
}
#endif
/* do we use the misc I/O pins for switching the lamp ? */
if( _WAF_MISC_IO_LAMPS & sc->workaroundFlag ) {
usb_GetLampRegAndMask( sc->lamp, &reg, &msk );
@ -864,24 +905,29 @@ static int usb_GetLampStatus( pPlustek_Device dev )
/* check if the lamp is on */
usbio_ReadReg( dev->fd, reg, &val );
DBG( _DBG_INFO, "REG[0x%02x] = 0x%02x (msk=0x%02x)\n",reg,val,msk);
DBG( _DBG_INFO2, "REG[0x%02x] = 0x%02x (msk=0x%02x)\n",reg,val,msk);
if( val & msk )
iLampStatus |= DEV_LampReflection;
/* if the device supports a TPA, we check this here */
if( sc->wFlags & DEVCAPSFLAG_TPA ) {
/* if the device supports a TPA, we check this here */
if( sc->wFlags & DEVCAPSFLAG_TPA ) {
usb_GetLampRegAndMask( _GET_TPALAMP(sc->lamp), &reg, &msk );
usbio_ReadReg( dev->fd, reg, &val );
DBG( _DBG_INFO, "REG[0x%02x] = 0x%02x (msk=0x%02x)\n",
reg,val,msk);
DBG( _DBG_INFO2, "REG[0x%02x] = 0x%02x (msk=0x%02x)\n",
reg,val,msk);
if( val & msk )
iLampStatus |= DEV_LampTPA;
}
if((dev->usbDev.vendor == 0x04A9) && (dev->usbDev.product==0x2208)) {
/* DBG( _DBG_INFO, "CanoScan D660U -> Lamp is off!!! (STATUS=%i)\n", iLampStatus );*/
sanei_lm983x_read( dev->fd, 0x29, &a_bRegs[0x29], 3, SANE_TRUE );
DBG( _DBG_INFO, "[29]=0x%02x, [2A]=0x%02x, [2B]=0x%02x\n", a_bRegs[0x29], a_bRegs[0x2a], a_bRegs[0x2b] );
/*return 0;*/
}
}
} else {
sanei_lm983x_read(dev->fd, 0x29,&a_bRegs[0x29],0x37-0x29+1,SANE_TRUE);
if((a_bRegs[0x29] & 3) == 1) {
@ -909,7 +955,7 @@ static int usb_GetLampStatus( pPlustek_Device dev )
/** usb_switchLampX
* used for all devices that use some misc I/O pins to switch the lamp
*/
static SANE_Bool usb_switchLampX( pPlustek_Device dev,
static SANE_Bool usb_switchLampX( Plustek_Device *dev,
SANE_Bool on, SANE_Bool tpa )
{
SANE_Byte reg, msk;
@ -939,7 +985,7 @@ static SANE_Bool usb_switchLampX( pPlustek_Device dev,
/** usb_switchLamp
* used for all devices that use some misc I/O pins to switch the lamp
*/
static SANE_Bool usb_switchLamp( pPlustek_Device dev, SANE_Bool on )
static SANE_Bool usb_switchLamp( Plustek_Device *dev, SANE_Bool on )
{
SANE_Bool result;
@ -953,9 +999,8 @@ static SANE_Bool usb_switchLamp( pPlustek_Device dev, SANE_Bool on )
}
/** usb_LedOn
*
*/
static void usb_LedOn( pPlustek_Device dev, SANE_Bool fOn )
static void usb_LedOn( Plustek_Device *dev, SANE_Bool fOn )
{
u_char value;
@ -964,21 +1009,44 @@ static void usb_LedOn( pPlustek_Device dev, SANE_Bool fOn )
value = a_bRegs[0x0d];
/* if(ReadRegister(0x0d, &value)) */
{
if( fOn )
value |= 0x10;
else
value &= ~0x10;
if( fOn )
value |= 0x10;
else
value &= ~0x10;
a_bRegs[0x0d] = value;
usbio_WriteReg( dev->fd, 0x0d, value );
}
a_bRegs[0x0d] = value;
usbio_WriteReg( dev->fd, 0x0d, value );
}
/** usb_FillLampRegs
* set all the registers controlling the lamps
*/
static void usb_FillLampRegs( Plustek_Device *dev )
{
pHWDef hw = &dev->usbDev.HwSetting;
a_bRegs[0x2a] = _HIBYTE( hw->wGreenPWMDutyCycleLow );
a_bRegs[0x2b] = _LOBYTE( hw->wGreenPWMDutyCycleLow );
a_bRegs[0x2c] = _HIBYTE( hw->red_lamp_on );
a_bRegs[0x2d] = _LOBYTE( hw->red_lamp_on );
a_bRegs[0x2e] = _HIBYTE( hw->red_lamp_off);
a_bRegs[0x2f] = _LOBYTE( hw->red_lamp_off);
a_bRegs[0x30] = _HIBYTE( hw->green_lamp_on );
a_bRegs[0x31] = _LOBYTE( hw->green_lamp_on );
a_bRegs[0x32] = _HIBYTE( hw->green_lamp_off);
a_bRegs[0x33] = _LOBYTE( hw->green_lamp_off);
a_bRegs[0x34] = _HIBYTE( hw->blue_lamp_on );
a_bRegs[0x35] = _LOBYTE( hw->blue_lamp_on );
a_bRegs[0x36] = _HIBYTE( hw->blue_lamp_off);
a_bRegs[0x37] = _LOBYTE( hw->blue_lamp_off);
}
/** usb_LampOn
*/
static SANE_Bool usb_LampOn( pPlustek_Device dev,
static SANE_Bool usb_LampOn( Plustek_Device *dev,
SANE_Bool fOn, SANE_Bool fResetTimer )
{
pDCapsDef sc = &dev->usbDev.Caps;
@ -1007,7 +1075,7 @@ static SANE_Bool usb_LampOn( pPlustek_Device dev,
}
if( fOn ) {
if( iLampStatus != lampId ) {
DBG( _DBG_INFO, "Switching Lamp on\n" );
@ -1016,7 +1084,6 @@ static SANE_Bool usb_LampOn( pPlustek_Device dev,
* using the other one
*/
if( lampId != dev->usbDev.currentLamp ) {
if( dev->usbDev.currentLamp == DEV_LampReflection )
usb_switchLampX( dev, SANE_FALSE, SANE_FALSE );
else
@ -1040,27 +1107,11 @@ static SANE_Bool usb_LampOn( pPlustek_Device dev,
}
}
if( _WAF_MISC_IO_LAMPS & sc->workaroundFlag ) {
a_bRegs[0x2c] = hw->red_lamp_on / 256;
a_bRegs[0x2d] = hw->red_lamp_on & 0xFF;
a_bRegs[0x2e] = hw->red_lamp_off / 256;
a_bRegs[0x2f] = hw->red_lamp_off & 0xFF;
if( _WAF_MISC_IO_LAMPS & sc->workaroundFlag )
usb_FillLampRegs( dev );
a_bRegs[0x30] = hw->green_lamp_on / 256;
a_bRegs[0x31] = hw->green_lamp_on & 0xFF;
a_bRegs[0x32] = hw->green_lamp_off / 256;
a_bRegs[0x33] = hw->green_lamp_off & 0xFF;
a_bRegs[0x34] = hw->blue_lamp_on / 256;
a_bRegs[0x35] = hw->blue_lamp_on & 0xFF;
a_bRegs[0x36] = hw->blue_lamp_off / 256;
a_bRegs[0x37] = hw->blue_lamp_off & 0xFF;
}
sanei_lm983x_write( dev->fd, 0x29,
&a_bRegs[0x29], 0x37-0x29+1, SANE_TRUE );
if( lampId != dev->usbDev.currentLamp ) {
dev->usbDev.currentLamp = lampId;
@ -1083,7 +1134,6 @@ static SANE_Bool usb_LampOn( pPlustek_Device dev,
DBG( _DBG_INFO, "Switching Lamp off\n" );
memset( &a_bRegs[0x29], 0, 0x37-0x29+1 );
if( !usb_switchLamp(dev, SANE_FALSE )) {
if( iStatusChange & DEV_LampReflection ) {
@ -1097,34 +1147,17 @@ static SANE_Bool usb_LampOn( pPlustek_Device dev,
}
}
if( _WAF_MISC_IO_LAMPS & sc->workaroundFlag ) {
a_bRegs[0x2c] = hw->red_lamp_on / 256;
a_bRegs[0x2d] = hw->red_lamp_on & 0xFF;
a_bRegs[0x2e] = hw->red_lamp_off / 256;
a_bRegs[0x2f] = hw->red_lamp_off & 0xFF;
if( _WAF_MISC_IO_LAMPS & sc->workaroundFlag )
usb_FillLampRegs( dev );
a_bRegs[0x30] = hw->green_lamp_on / 256;
a_bRegs[0x31] = hw->green_lamp_on & 0xFF;
a_bRegs[0x32] = hw->green_lamp_off / 256;
a_bRegs[0x33] = hw->green_lamp_off & 0xFF;
a_bRegs[0x34] = hw->blue_lamp_on / 256;
a_bRegs[0x35] = hw->blue_lamp_on & 0xFF;
a_bRegs[0x36] = hw->blue_lamp_off / 256;
a_bRegs[0x37] = hw->blue_lamp_off & 0xFF;
}
sanei_lm983x_write( dev->fd, 0x29,
&a_bRegs[0x29], 0x37-0x29+1, SANE_TRUE );
}
}
if( usb_GetLampStatus(dev))
usb_LedOn( dev, SANE_TRUE );
else
usb_LedOn( dev, SANE_FALSE );
return SANE_TRUE;
}
@ -1147,7 +1180,7 @@ static SANE_Bool usb_LampOn( pPlustek_Device dev,
* it should contain all we need
* @return - Nothing
*/
static void usb_ResetRegisters( pPlustek_Device dev )
static void usb_ResetRegisters( Plustek_Device *dev )
{
int linend;
@ -1187,8 +1220,8 @@ static void usb_ResetRegisters( pPlustek_Device dev )
a_bRegs[0x51] = hw->bReg_0x51;
/* if already initialized, we ignore the MISC I/O settings as
* they are used to determine the current lamp settings...
*/
* they are used to determine the current lamp settings...
*/
if( dev->initialized >= 0 ) {
DBG( _DBG_INFO2, "USING MISC I/O settings\n" );
@ -1204,12 +1237,12 @@ static void usb_ResetRegisters( pPlustek_Device dev )
sanei_lm983x_write( dev->fd, 0x59, &a_bRegs[0x59], 3, SANE_TRUE );
}
DBG( _DBG_INFO, "MISC I/O after RESET: 0x%02x, 0x%02x, 0x%02x\n",
a_bRegs[0x59], a_bRegs[0x5a], a_bRegs[0x5b] );
a_bRegs[0x59], a_bRegs[0x5a], a_bRegs[0x5b] );
}
/** usb_ModuleStatus
*/
static SANE_Bool usb_ModuleStatus( pPlustek_Device dev )
static SANE_Bool usb_ModuleStatus( Plustek_Device *dev )
{
u_char value;
pHWDef hw = &dev->usbDev.HwSetting;
@ -1275,9 +1308,8 @@ static void usb_LampSwitch( Plustek_Device *dev, SANE_Bool sw )
}
}
/* HEINER: replace!!! */
static pPlustek_Device dev_xxx = NULL;
static Plustek_Device *dev_xxx = NULL;
/** ISR to switch lamp off after time has elapsed
*/
@ -1294,7 +1326,7 @@ static void usb_LampTimerIrq( int sig )
/** usb_StartLampTimer
*/
static void usb_StartLampTimer( pPlustek_Device dev )
static void usb_StartLampTimer( Plustek_Device *dev )
{
sigset_t block, pause_mask;
struct sigaction s;
@ -1340,7 +1372,7 @@ static void usb_StartLampTimer( pPlustek_Device dev )
/** usb_StopLampTimer
*/
static void usb_StopLampTimer( pPlustek_Device dev )
static void usb_StopLampTimer( Plustek_Device *dev )
{
sigset_t block, pause_mask;
@ -1383,10 +1415,9 @@ static SANE_Bool usb_IsEscPressed( void )
return SANE_FALSE;
}
/**
* wait until warmup has been done
/** wait until warmup has been done
*/
static SANE_Bool usb_Wait4Warmup( pPlustek_Device dev )
static SANE_Bool usb_Wait4Warmup( Plustek_Device *dev )
{
u_long dw;
struct timeval t;
@ -1397,14 +1428,17 @@ static SANE_Bool usb_Wait4Warmup( pPlustek_Device dev )
DBG(_DBG_INFO,"Warmup: skipped for CIS devices\n" );
return SANE_TRUE;
}
if( dev->adj.warmup < 0 )
return SANE_TRUE;
/*
* wait until warmup period has been elapsed
*/
gettimeofday( &t, NULL);
dw = t.tv_sec - dev->usbDev.dwTicksLampOn;
if( dw < dev->usbDev.dwWarmup )
DBG(_DBG_INFO,"Warmup: Waiting %lu seconds\n",dev->usbDev.dwWarmup );
if( dw < (u_long)dev->adj.warmup )
DBG(_DBG_INFO,"Warmup: Waiting %d seconds\n", dev->adj.warmup );
do {
@ -1416,8 +1450,52 @@ static SANE_Bool usb_Wait4Warmup( pPlustek_Device dev )
return SANE_FALSE;
}
} while( dw < dev->usbDev.dwWarmup );
} while( dw < (u_long)dev->adj.warmup );
return SANE_TRUE;
}
/** function for TPA autodection (EPSON & UMAX devices)
*/
static SANE_Bool usb_HasTPA( Plustek_Device *dev )
{
static char model[] = { "3450" };
u_char val;
if( dev->usbDev.vendor == 0x04B8 ) { /* the EPSON section */
usb_switchLampX( dev, SANE_FALSE, SANE_TRUE );
usbio_WriteReg ( dev->fd, 0x58, 0x1d );
usbio_WriteReg ( dev->fd, 0x59, 0x49 );
usbio_ReadReg ( dev->fd, 0x02, &val );
usbio_WriteReg ( dev->fd, 0x58, dev->usbDev.HwSetting.bReg_0x58 );
usbio_WriteReg ( dev->fd, 0x59, dev->usbDev.HwSetting.bReg_0x59 );
DBG( _DBG_INFO, "REG[0x02] = 0x%02x\n", val );
if( val & 0x02 ) {
DBG( _DBG_INFO, "EPSON-TPA detected\n" );
return SANE_TRUE;
} else
DBG( _DBG_INFO, "EPSON-TPA NOT detected\n" );
if( dev->adj.enableTpa ) {
DBG( _DBG_INFO, "EPSON-TPA usage forced\n" );
return SANE_TRUE;
}
} else if( dev->usbDev.vendor == 0x1606 ) { /* the UMAX section */
if((dev->usbDev.product == 0x0050) || (dev->usbDev.product == 0x0060)) {
if( dev->adj.enableTpa ) {
DBG( _DBG_INFO, "UMAX-TPA usage forced\n" );
dev->usbDev.ModelStr = model;
return SANE_TRUE;
}
}
}
return SANE_FALSE;
}
/* END PLUSTEK-USBHW.C ......................................................*/

115
backend/plustek-usbimg.c
Wyświetl plik

@ -24,6 +24,9 @@
* - 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()
* - cleanup
* .
* <hr>
* This file is part of the SANE package.
@ -341,7 +344,7 @@ static void usb_ColorScaleGray( struct Plustek_Device *dev )
pScanDef scanning = &dev->scanning;
usb_AverageColorByte( dev );
dw = scanning->sParam.Size.dwPixels;
if( scanning->sParam.bSource == SOURCE_ADF ) {
@ -352,7 +355,7 @@ static void usb_ColorScaleGray( struct Plustek_Device *dev )
dwPixels = 0;
}
izoom = usb_GetScaler( scanning );
izoom = usb_GetScaler( scanning );
switch( scanning->fGrayFromColor ) {
@ -518,17 +521,17 @@ static void usb_ColorScaleGray16( struct Plustek_Device *dev )
switch( scanning->fGrayFromColor ) {
case 1:
for( dwBitsPut = 0, ddax = 0; dw; dwBitsPut++ ) {
for( dwBitsPut = 0, ddax = 0; dw; dwBitsPut++ ) {
ddax -= _SCALER;
ddax -= _SCALER;
while((ddax < 0) && (dw > 0)) {
if( swap ) {
scanning->UserBuf.pw_rgb[dwBitsPut].Red =
_HILO2WORD(scanning->Red.pcw[dwBitsPut].HiLo[0]) >> ls;
scanning->UserBuf.pw[dwPixels] =
_HILO2WORD(scanning->Red.pcw[dwBitsPut].HiLo[0]) >> ls;
} else {
scanning->UserBuf.pw_rgb[dwPixels].Red =
scanning->Red.pw[dwBitsPut] >> ls;
scanning->UserBuf.pw[dwPixels] =
scanning->Red.pw[dwBitsPut] >> ls;
}
dwPixels = dwPixels + iNext;
ddax += izoom;
@ -538,17 +541,17 @@ static void usb_ColorScaleGray16( struct Plustek_Device *dev )
break;
case 2:
for( dwBitsPut = 0, ddax = 0; dw; dwBitsPut++ ) {
for( dwBitsPut = 0, ddax = 0; dw; dwBitsPut++ ) {
ddax -= _SCALER;
ddax -= _SCALER;
while((ddax < 0) && (dw > 0)) {
if( swap ) {
scanning->UserBuf.pw_rgb[dwBitsPut].Green =
_HILO2WORD(scanning->Green.pcw[dwBitsPut].HiLo[0]) >> ls;
scanning->UserBuf.pw[dwPixels] =
_HILO2WORD(scanning->Green.pcw[dwBitsPut].HiLo[0]) >> ls;
} else {
scanning->UserBuf.pw_rgb[dwPixels].Green =
scanning->Green.pw[dwBitsPut] >> ls;
scanning->UserBuf.pw[dwPixels] =
scanning->Green.pw[dwBitsPut] >> ls;
}
dwPixels = dwPixels + iNext;
ddax += izoom;
@ -558,17 +561,17 @@ static void usb_ColorScaleGray16( struct Plustek_Device *dev )
break;
case 3:
for( dwBitsPut = 0, ddax = 0; dw; dwBitsPut++ ) {
for( dwBitsPut = 0, ddax = 0; dw; dwBitsPut++ ) {
ddax -= _SCALER;
ddax -= _SCALER;
while((ddax < 0) && (dw > 0)) {
if( swap ) {
scanning->UserBuf.pw_rgb[dwBitsPut].Blue =
_HILO2WORD(scanning->Blue.pcw[dwBitsPut].HiLo[0]) >> ls;
scanning->UserBuf.pw[dwPixels] =
_HILO2WORD(scanning->Blue.pcw[dwBitsPut].HiLo[0]) >> ls;
} else {
scanning->UserBuf.pw_rgb[dwPixels].Blue =
scanning->Blue.pw[dwBitsPut] >> ls;
scanning->UserBuf.pw[dwPixels] =
scanning->Blue.pw[dwBitsPut] >> ls;
}
dwPixels = dwPixels + iNext;
ddax += izoom;
@ -1130,31 +1133,31 @@ static void usb_ColorDuplicateGray16( struct Plustek_Device *dev )
case 1:
if( swap ) {
for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, dwPixels = dwPixels + iNext)
scan->UserBuf.pw_rgb[dwPixels].Red =
scan->UserBuf.pw[dwPixels] =
_HILO2WORD(scan->Red.pcw[dw].HiLo[0]) >> ls;
} else {
for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, dwPixels = dwPixels + iNext)
scan->UserBuf.pw_rgb[dwPixels].Red = scan->Red.pw[dw] >> ls;
scan->UserBuf.pw[dwPixels] = scan->Red.pw[dw] >> ls;
}
break;
case 2:
if( swap ) {
for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, dwPixels = dwPixels + iNext)
scan->UserBuf.pw_rgb[dwPixels].Green =
scan->UserBuf.pw[dwPixels] =
_HILO2WORD(scan->Green.pcw[dw].HiLo[0]) >> ls;
} else {
for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, dwPixels = dwPixels + iNext)
scan->UserBuf.pw_rgb[dwPixels].Green = scan->Green.pw[dw] >> ls;
scan->UserBuf.pw[dwPixels] = scan->Green.pw[dw] >> ls;
}
break;
case 3:
if( swap ) {
for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, dwPixels = dwPixels + iNext)
scan->UserBuf.pw_rgb[dwPixels].Blue =
scan->UserBuf.pw[dwPixels] =
_HILO2WORD(scan->Blue.pcw[dw].HiLo[0]) >> ls;
} else {
for (dw = 0; dw < scan->sParam.Size.dwPixels; dw++, dwPixels = dwPixels + iNext)
scan->UserBuf.pw_rgb[dwPixels].Blue = scan->Blue.pw[dw] >> ls;
scan->UserBuf.pw[dwPixels] = scan->Blue.pw[dw] >> ls;
}
break;
}
@ -1611,28 +1614,28 @@ static void usb_GetImageProc( struct Plustek_Device *dev )
static SANE_Int usb_ReadData( struct Plustek_Device *dev )
{
u_long dw, dwRet, dwBytes, pl;
pScanDef scanning = &dev->scanning;
pHWDef hw = &dev->usbDev.HwSetting;
pScanDef scan = &dev->scanning;
pHWDef hw = &dev->usbDev.HwSetting;
DBG( _DBG_READ, "usb_ReadData()\n" );
pl = a_bRegs[0x4e] * hw->wDRAMSize/128;
while( scanning->sParam.Size.dwTotalBytes ) {
while( scan->sParam.Size.dwTotalBytes ) {
if( usb_IsEscPressed()) {
DBG( _DBG_INFO, "usb_ReadData() - Cancel detected...\n" );
return 0;
}
if( scanning->sParam.Size.dwTotalBytes > scanning->dwBytesScanBuf )
dw = scanning->dwBytesScanBuf;
if( scan->sParam.Size.dwTotalBytes > scan->dwBytesScanBuf )
dw = scan->dwBytesScanBuf;
else
dw = scanning->sParam.Size.dwTotalBytes;
dw = scan->sParam.Size.dwTotalBytes;
scanning->sParam.Size.dwTotalBytes -= dw;
scan->sParam.Size.dwTotalBytes -= dw;
if(!scanning->sParam.Size.dwTotalBytes && dw < (pl * 1024))
if(!scan->sParam.Size.dwTotalBytes && dw < (pl * 1024))
{
if(!(a_bRegs[0x4e] = (u_char)ceil((double)dw /
(4.0 * hw->wDRAMSize)))) {
@ -1644,57 +1647,55 @@ static SANE_Int usb_ReadData( struct Plustek_Device *dev )
sanei_lm983x_write( dev->fd, 0x4e, &a_bRegs[0x4e], 2, SANE_TRUE );
}
while( scanning->bLinesToSkip ) {
while( scan->bLinesToSkip ) {
DBG( _DBG_READ, "Skipping %u lines\n", scanning->bLinesToSkip );
DBG( _DBG_READ, "Skipping %u lines\n", scan->bLinesToSkip );
dwBytes = scanning->bLinesToSkip*scanning->sParam.Size.dwPhyBytes;
dwBytes = scan->bLinesToSkip * scan->sParam.Size.dwPhyBytes;
if (dwBytes > scanning->dwBytesScanBuf) {
if (dwBytes > scan->dwBytesScanBuf) {
dwBytes = scanning->dwBytesScanBuf;
scanning->bLinesToSkip -= scanning->dwLinesScanBuf;
dwBytes = scan->dwBytesScanBuf;
scan->bLinesToSkip -= scan->dwLinesScanBuf;
} else {
scanning->bLinesToSkip = 0;
scan->bLinesToSkip = 0;
}
if( !usb_ScanReadImage( dev, scanning->pbGetDataBuf, dwBytes ))
if( !usb_ScanReadImage( dev, scan->pbGetDataBuf, dwBytes ))
return 0;
}
if( usb_ScanReadImage( dev, scanning->pbGetDataBuf, dw )) {
if( usb_ScanReadImage( dev, scan->pbGetDataBuf, dw )) {
dumpPic( "plustek-pic.raw", scanning->pbGetDataBuf, dw );
dumpPic( "plustek-pic.raw", scan->pbGetDataBuf, dw );
if( scanning->dwLinesDiscard ) {
if( scan->dwLinesDiscard ) {
DBG( _DBG_READ, "Discarding %lu lines\n",
scanning->dwLinesDiscard );
DBG(_DBG_READ, "Discarding %lu lines\n", scan->dwLinesDiscard);
dwRet = dw / scanning->sParam.Size.dwPhyBytes;
dwRet = dw / scan->sParam.Size.dwPhyBytes;
if (scanning->dwLinesDiscard > dwRet) {
scanning->dwLinesDiscard -= dwRet;
if (scan->dwLinesDiscard > dwRet) {
scan->dwLinesDiscard -= dwRet;
dwRet = 0;
} else {
dwRet -= scanning->dwLinesDiscard;
scanning->dwLinesDiscard = 0;
dwRet -= scan->dwLinesDiscard;
scan->dwLinesDiscard = 0;
}
} else {
dwRet = dw / scanning->sParam.Size.dwPhyBytes;
dwRet = dw / scan->sParam.Size.dwPhyBytes;
}
scanning->pbGetDataBuf += scanning->dwBytesScanBuf;
if( scanning->pbGetDataBuf >= scanning->pbScanBufEnd ) {
scanning->pbGetDataBuf = scanning->pbScanBufBegin;
scan->pbGetDataBuf += scan->dwBytesScanBuf;
if( scan->pbGetDataBuf >= scan->pbScanBufEnd ) {
scan->pbGetDataBuf = scan->pbScanBufBegin;
}
if( dwRet )
return dwRet;
}
}
return 0;
}

61
backend/plustek-usbio.c
Wyświetl plik

@ -21,6 +21,7 @@
* - added dimension stuff to dumpPic
* - 0.46 - disabled reset prior to the detection of Merlin
* - 0.47 - no changes
* - 0.48 - cleanup
* .
* <hr>
* This file is part of the SANE package.
@ -94,12 +95,12 @@ static void dumpPic( char* name, SANE_Byte *buffer, u_long len )
{
FILE *fp;
if( DBG_LEVEL < _DBG_DUMP )
if( DBG_LEVEL < _DBG_DPIC )
return;
if( NULL == buffer ) {
DBG( _DBG_DUMP, "Creating file '%s'\n", name );
DBG( _DBG_DPIC, "Creating file '%s'\n", name );
fp = fopen( name, "w+b" );
@ -107,7 +108,7 @@ static void dumpPic( char* name, SANE_Byte *buffer, u_long len )
if( 0 != dPix.x ) {
DBG( _DBG_DUMP, "> X=%lu, Y=%lu, depth=%u\n",
DBG( _DBG_DPIC, "> X=%lu, Y=%lu, depth=%u\n",
dPix.x, dPix.y, dPix.depth );
if( dPix.depth > 8 )
fprintf( fp, "P6\n%lu %lu\n65535\n", dPix.x, dPix.y );
@ -120,7 +121,7 @@ static void dumpPic( char* name, SANE_Byte *buffer, u_long len )
}
if( NULL == fp ) {
DBG( _DBG_DUMP, "Can not open file '%s'\n", name );
DBG( _DBG_DPIC, "Can not open file '%s'\n", name );
return;
}
@ -152,10 +153,10 @@ static void dumpPicInit( pScanParam sd, char* name )
static void dumpregs( int fd, SANE_Byte *cmp )
{
char buf[256], b2[10];
SANE_Byte regs[0x80];
SANE_Byte regs[0x80];
int i;
if( DBG_LEVEL < _DBG_INFO2 )
if( DBG_LEVEL < _DBG_DREGS )
return;
buf[0] = '\0';
@ -170,10 +171,10 @@ static void dumpregs( int fd, SANE_Byte *cmp )
for( i = 0x0; i < 0x80; i++ ) {
if((i%16) ==0 ) {
if((i%16) ==0 ) {
if( buf[0] )
DBG( _DBG_INFO2, "%s\n", buf );
DBG( _DBG_DREGS, "%s\n", buf );
sprintf( buf, "0x%02x:", i );
}
@ -181,28 +182,28 @@ static void dumpregs( int fd, SANE_Byte *cmp )
strcat( buf, " ");
/* the dataport read returns with "0 Bytes read", of course. */
if((i == 0) || (i == 5) || (i == 6))
strcat( buf, "XX ");
else {
if((i == 0) || (i == 5) || (i == 6))
strcat( buf, "XX ");
else {
sprintf( b2, "%02x ", regs[i]);
sprintf( b2, "%02x ", regs[i]);
strcat( buf, b2 );
}
}
DBG( _DBG_INFO2, "%s\n", buf );
DBG( _DBG_DREGS, "%s\n", buf );
if( cmp ) {
buf[0] = '\0';
DBG( _DBG_INFO2, "Internal setting:\n" );
DBG( _DBG_DREGS, "Internal setting:\n" );
for( i = 0x0; i < 0x80; i++ ) {
if((i%16) ==0 ) {
if((i%16) ==0 ) {
if( buf[0] )
DBG( _DBG_INFO2, "%s\n", buf );
DBG( _DBG_DREGS, "%s\n", buf );
sprintf( buf, "0x%02x:", i );
}
@ -210,15 +211,14 @@ static void dumpregs( int fd, SANE_Byte *cmp )
strcat( buf, " ");
if((i == 0) || (i == 5) || (i == 6))
strcat( buf, "XX ");
else {
sprintf( b2, "%02x ", cmp[i]);
strcat( buf, "XX ");
else {
sprintf( b2, "%02x ", cmp[i]);
strcat( buf, b2 );
}
}
DBG( _DBG_INFO2, "%s\n", buf );
DBG( _DBG_DREGS, "%s\n", buf );
}
}
@ -232,7 +232,7 @@ static void dumpregs( int fd, SANE_Byte *cmp )
* @return
*/
static SANE_Bool usbio_WriteReg( SANE_Int handle,
SANE_Byte reg, SANE_Byte value )
SANE_Byte reg, SANE_Byte value )
{
int i;
SANE_Byte data;
@ -243,19 +243,16 @@ static SANE_Bool usbio_WriteReg( SANE_Int handle,
sanei_lm983x_write_byte( handle, reg, value );
/* Flush register 0x02 when register 0x58 is written */
if( 0x58 == reg ) {
if( 0x58 == reg ) {
_UIO( usbio_ReadReg( handle, 2, &data ));
_UIO( usbio_ReadReg( handle, 2, &data ));
}
_UIO( usbio_ReadReg( handle, 2, &data ));
_UIO( usbio_ReadReg( handle, 2, &data ));
}
if( reg != 7 )
if( reg != 7 )
return SANE_TRUE;
/* verify register 7 */
_UIO( usbio_ReadReg( handle, 7, &data ));
if( data == value ) {
return SANE_TRUE;
}
@ -302,7 +299,7 @@ static SANE_Status usbio_DetectLM983x( SANE_Int fd, SANE_Byte *version )
break;
}
DBG( _DBG_INFO, "%s\n", buf );
DBG( _DBG_INFO, "%s\n", buf );
return res;
}

1
backend/plustek-usbmap.c
Wyświetl plik

@ -18,6 +18,7 @@
* - 0.45 - no changes
* - 0.46 - no changes
* - 0.47 - cleanup work
* - 0.48 - no changes
* .
* <hr>
* This file is part of the SANE package.

135
backend/plustek-usbscan.c
Wyświetl plik

@ -23,6 +23,7 @@
* - removed CanoScan specific setting stuff
* - 0.46 - fixed problem in usb_SetScanParameters()
* - 0.47 - no changes
* - 0.48 - minor fixes
* .
* <hr>
* This file is part of the SANE package.
@ -139,7 +140,7 @@ static u_short usb_SetAsicDpiX( pPlustek_Device dev, u_short xdpi )
xdpi < 150 &&
scanning->sParam.bDataType == SCANDATATYPE_BW ) {
xdpi = 150;
DBG( _DBG_INFO, "* LIMIT XDPI to %udpi\n", xdpi );
DBG( _DBG_INFO2, "* LIMIT XDPI to %udpi\n", xdpi );
}
m_dHDPIDivider = (double)scaps->OpticDpi.x / xdpi;
@ -189,10 +190,10 @@ static u_short usb_SetAsicDpiX( pPlustek_Device dev, u_short xdpi )
if( a_bRegs[0x0a] )
a_bRegs[0x09] -= ((a_bRegs[0x0a] >> 2) + 2);
DBG( _DBG_INFO, "* HDPI: %.3f\n", m_dHDPIDivider );
DBG( _DBG_INFO2, "* HDPI: %.3f\n", m_dHDPIDivider );
res = (u_short)((double)scaps->OpticDpi.x / m_dHDPIDivider);
DBG( _DBG_INFO, "* XDPI=%u, HDPI=%.3f\n", res, m_dHDPIDivider );
DBG( _DBG_INFO2, "* XDPI=%u, HDPI=%.3f\n", res, m_dHDPIDivider );
return res;
}
@ -332,7 +333,7 @@ static void usb_GetScanRect( pPlustek_Device dev, pScanParam pParam )
else
#endif
wDataPixelStart = (u_short)((u_long) pParam->Origin.x *
sCaps->OpticDpi.x / 300UL);
sCaps->OpticDpi.x / 300UL);
/* Data output from NS983X should be times of 2-byte and every line
* will append 2 status bytes
@ -371,10 +372,9 @@ static void usb_GetScanRect( pPlustek_Device dev, pScanParam pParam )
/* Compute data start pixel */
wDataPixelStart = (u_short)((u_long)pParam->Origin.x *
sCaps->OpticDpi.x / 300UL);
sCaps->OpticDpi.x / 300UL);
/*
* during the calibration steps, we read the entire CCD data
/* during the calibration steps, we read the entire CCD data
*/
if((pParam->bCalibration != PARAM_Gain) &&
(pParam->bCalibration != PARAM_Offset)) {
@ -389,18 +389,17 @@ static void usb_GetScanRect( pPlustek_Device dev, pScanParam pParam )
}
wLineEnd = wDataPixelStart + (u_short)(m_dHDPIDivider *
pParam->Size.dwPhyPixels + 0.5);
DBG( _DBG_INFO, "* DataPixelStart=%u, LineEnd=%u\n",
wDataPixelStart, wLineEnd );
pParam->Size.dwPhyPixels + 0.5);
DBG( _DBG_INFO2, "* DataPixelStart=%u, LineEnd=%u\n",
wDataPixelStart, wLineEnd );
if( wDataPixelStart & 1 ) {
wDataPixelStart++;
wLineEnd++;
DBG( _DBG_INFO, "* DataPixelStart=%u, LineEnd=%u (ADJ)\n",
wDataPixelStart, wLineEnd );
DBG( _DBG_INFO2, "* DataPixelStart=%u, LineEnd=%u (ADJ)\n",
wDataPixelStart, wLineEnd );
}
a_bRegs[0x22] = _HIBYTE( wDataPixelStart );
@ -410,8 +409,8 @@ static void usb_GetScanRect( pPlustek_Device dev, pScanParam pParam )
a_bRegs[0x24] = _HIBYTE( wLineEnd );
a_bRegs[0x25] = _LOBYTE( wLineEnd );
DBG( _DBG_INFO, ">> End-Start=%u, HDPI=%.2f\n",
wLineEnd-wDataPixelStart, m_dHDPIDivider);
DBG( _DBG_INFO2, ">> End-Start=%u, HDPI=%.2f\n",
wLineEnd-wDataPixelStart, m_dHDPIDivider);
/* Y origin */
if( pParam->bCalibration == PARAM_Scan ) {
@ -461,8 +460,8 @@ static void usb_GetScanRect( pPlustek_Device dev, pScanParam pParam )
}
/* Add gray mode offset (Green offset, we assume the CCD are
* always be RGB or BGR order).
*/
* always be RGB or BGR order).
*/
if (pParam->bDataType != SCANDATATYPE_Color)
pParam->Origin.y += (u_long)(300UL *
sCaps->bSensorDistance / sCaps->OpticDpi.y);
@ -474,7 +473,7 @@ static void usb_GetScanRect( pPlustek_Device dev, pScanParam pParam )
if( hw->motorModel == MODEL_HuaLien && sCaps->OpticDpi.x == 600)
pParam->Origin.y = pParam->Origin.y * 297 / 298;
DBG(_DBG_INFO,"* Full Steps to Skip at Start = 0x%04x\n",pParam->Origin.y);
DBG(_DBG_INFO2,"* Full Steps to Skip at Start = 0x%04x\n",pParam->Origin.y);
a_bRegs[0x4a] = _HIBYTE( pParam->Origin.y );
a_bRegs[0x4b] = _LOBYTE( pParam->Origin.y );
@ -589,7 +588,7 @@ static double usb_GetMCLKDivider( pPlustek_Device dev, pScanParam pParam )
bMaxITA = (u_char)floor((m_dMCLKDivider + 1) / 2.0);
DBG( _DBG_INFO, "* MaxITA (HP) = %u\n", bMaxITA );
DBG( _DBG_INFO2, "* MaxITA (HP) = %u\n", bMaxITA );
if( m_bIntTimeAdjust > bMaxITA ) {
DBG( _DBG_INFO, "* ITA (%u) limited\n", m_bIntTimeAdjust );
m_bIntTimeAdjust = bMaxITA;
@ -597,7 +596,7 @@ static double usb_GetMCLKDivider( pPlustek_Device dev, pScanParam pParam )
}
}
}
DBG( _DBG_INFO, "* Integration Time Adjust = %u (HDPI=%.3f,MCLKD=%.3f)\n",
DBG( _DBG_INFO2, "* Integration Time Adjust = %u (HDPI=%.3f,MCLKD=%.3f)\n",
m_bIntTimeAdjust, m_dHDPIDivider, m_dMCLKDivider );
a_bRegs[0x08] = (u_char)((m_dMCLKDivider - 1) * 2);
@ -614,7 +613,7 @@ static double usb_GetMCLKDivider( pPlustek_Device dev, pScanParam pParam )
a_bRegs[0x47] = _LOBYTE(m_wStepSize);
DBG( _DBG_INFO2, "* Stepsize = %u, 0x46=0x%02x 0x47=0x%02x\n",
m_wStepSize, a_bRegs[0x46], a_bRegs[0x47] );
m_wStepSize, a_bRegs[0x46], a_bRegs[0x47] );
usb_GetDPD( dev );
}
@ -639,8 +638,7 @@ static double usb_GetMCLKDivider( pPlustek_Device dev, pScanParam pParam )
a_bRegs[0x2b] = _LOBYTE( hw->wGreenPWMDutyCycleHigh );
}
DBG( _DBG_INFO, "* Current MCLK Divider = %f\n", m_dMCLKDivider );
DBG( _DBG_INFO2, "* Current MCLK Divider = %f\n", m_dMCLKDivider );
return m_dMCLKDivider;
}
@ -669,7 +667,7 @@ static void usb_GetStepSize( pPlustek_Device dev, pScanParam pParam )
a_bRegs[0x47] = _LOBYTE( m_wStepSize );
DBG( _DBG_INFO2, "* Stepsize = %u, 0x46=0x%02x 0x47=0x%02x\n",
m_wStepSize, a_bRegs[0x46], a_bRegs[0x47] );
m_wStepSize, a_bRegs[0x46], a_bRegs[0x47] );
}
/**
@ -813,7 +811,7 @@ static void usb_GetMotorParam( pPlustek_Device dev, pScanParam pParam )
a_bRegs[0x43] = 0xff;
a_bRegs[0x44] = md[idx].scan_lines_per_line;
DBG( _DBG_INFO, "* Line Skipping : 0x43=0x%02x, 0x44=0x%02x\n",
DBG( _DBG_INFO2, "* Line Skipping : 0x43=0x%02x, 0x44=0x%02x\n",
a_bRegs[0x43], a_bRegs[0x44] );
}
}
@ -922,8 +920,8 @@ static void usb_GetMotorParam( pPlustek_Device dev, pScanParam pParam )
}
}
DBG( _DBG_INFO, "* MOTOR-Settings: PWM=0x%02x, PWM_DUTY=0x%02x\n",
a_bRegs[0x56], a_bRegs[0x57] );
DBG( _DBG_INFO2, "* MOTOR-Settings: PWM=0x%02x, PWM_DUTY=0x%02x\n",
a_bRegs[0x56], a_bRegs[0x57] );
}
/**
@ -962,8 +960,8 @@ static void usb_GetPauseLimit( pPlustek_Device dev, pScanParam pParam )
m_dwPauseLimit -= ((a_bRegs[0x54] & 7) *
(pParam->Size.dwPhyBytes * scaler) + 1023) / 1024;
DBG( _DBG_INFO, "* PL=%lu, coeffsize=%u, scaler=%u\n",
m_dwPauseLimit, coeffsize, scaler );
DBG( _DBG_INFO2, "* PL=%lu, coeffsize=%u, scaler=%u\n",
m_dwPauseLimit, coeffsize, scaler );
m_dwPauseLimit = usb_max( usb_min(m_dwPauseLimit,
(u_long)ceil(pParam->Size.dwTotalBytes / 1024.0)), 2);
@ -982,8 +980,8 @@ static void usb_GetPauseLimit( pPlustek_Device dev, pScanParam pParam )
*/
a_bRegs[0x4f] = 1;
DBG( _DBG_INFO, "* PauseLimit = %lu, [0x4e] = 0x%02x, [0x4f] = 0x%02x\n",
m_dwPauseLimit, a_bRegs[0x4e], a_bRegs[0x4f] );
DBG( _DBG_INFO2, "* PauseLimit = %lu, [0x4e] = 0x%02x, [0x4f] = 0x%02x\n",
m_dwPauseLimit, a_bRegs[0x4e], a_bRegs[0x4f] );
}
/** usb_GetScanLinesAndSize
@ -1120,7 +1118,7 @@ static SANE_Bool usb_SetScanParameters( pPlustek_Device dev, pScanParam pParam )
a_bRegs[0x49] = _LOBYTE( m_wFastFeedStepSize );
DBG( _DBG_INFO2, "* FFStepSize = %u, [0x48] = 0x%02x, [0x49] = 0x%02x\n",
m_wFastFeedStepSize, a_bRegs[0x48], a_bRegs[0x49] );
m_wFastFeedStepSize, a_bRegs[0x48], a_bRegs[0x49] );
/* Compute the number of lines to scan using actual Y resolution */
usb_GetScanLinesAndSize( dev, pParam );
@ -1152,7 +1150,7 @@ static SANE_Bool usb_SetScanParameters( pPlustek_Device dev, pScanParam pParam )
if( !usbio_WriteReg( dev->fd, 0x18, 0x18 ))
return SANE_FALSE;
usleep(200 * 1000); /* Need to delay at least xxx microseconds */
usleep(200 * 1000); /* Need to delay at least xxx microseconds */
if( !usbio_WriteReg( dev->fd, 0x07, 0x20 ))
return SANE_FALSE;
@ -1177,22 +1175,23 @@ static SANE_Bool usb_SetScanParameters( pPlustek_Device dev, pScanParam pParam )
return SANE_FALSE;
DBG( _DBG_INFO, "usb_SetScanParameters() done.\n" );
return SANE_TRUE;
}
/**
*/
static SANE_Bool usb_ScanBegin( pPlustek_Device dev, SANE_Bool fAutoPark )
static SANE_Bool usb_ScanBegin( pPlustek_Device dev, SANE_Bool auto_park )
{
u_char value;
pHWDef hw = &dev->usbDev.HwSetting;
u_char value;
u_short inches;
pHWDef hw = &dev->usbDev.HwSetting;
pDCapsDef sc = &dev->usbDev.Caps;
pClkMotorDef clk = usb_GetMotorSet( hw->motorModel );
DBG( _DBG_INFO, "usb_ScanBegin()\n" );
/* save the request for usb_ScanEnd () */
m_fAutoPark = fAutoPark;
m_fAutoPark = auto_park;
/* Disable home sensor during scan, or the chassis cannot move */
value = ((m_pParam->bCalibration == PARAM_Scan &&
@ -1208,30 +1207,29 @@ static SANE_Bool usb_ScanBegin( pPlustek_Device dev, SANE_Bool fAutoPark )
/* Flush cache - only LM9831 (Source: National Semiconductors */
if( _LM9831 == hw->chip ) {
for(;;) {
for(;;) {
if( SANE_TRUE == cancelRead ) {
DBG( _DBG_INFO, "ScanBegin() - Cancel detected...\n" );
return SANE_FALSE;
}
_UIO(usbio_ReadReg( dev->fd, 0x01, &m_bOldScanData ));
if( SANE_TRUE == cancelRead ) {
DBG( _DBG_INFO, "ScanBegin() - Cancel detected...\n" );
return SANE_FALSE;
}
_UIO(usbio_ReadReg( dev->fd, 0x01, &m_bOldScanData ));
if( m_bOldScanData ) {
if( m_bOldScanData ) {
u_long dwBytesToRead = m_bOldScanData * hw->wDRAMSize * 4;
u_char *pBuffer = malloc( sizeof(u_char) * dwBytesToRead );
u_long dwBytesToRead = m_bOldScanData * hw->wDRAMSize * 4;
u_char *pBuffer = malloc( sizeof(u_char) * dwBytesToRead );
DBG(_DBG_INFO,"Flushing cache - %lu bytes (bOldScanData=%u)\n",
dwBytesToRead, m_bOldScanData );
DBG( _DBG_INFO, "Flushing cache - %lu bytes (bOldScanData=%u)\n",
dwBytesToRead, m_bOldScanData );
_UIO(sanei_lm983x_read( dev->fd, 0x00, pBuffer,
dwBytesToRead, SANE_FALSE ));
free( pBuffer );
_UIO(sanei_lm983x_read( dev->fd, 0x00, pBuffer, dwBytesToRead, SANE_FALSE ));
free( pBuffer );
} else
break;
}
} else
break;
}
}
/* Download map & Shading data */
@ -1245,13 +1243,17 @@ static SANE_Bool usb_ScanBegin( pPlustek_Device dev, SANE_Bool fAutoPark )
return SANE_FALSE;
usbio_ReadReg( dev->fd, 0x01, &m_bOldScanData );
m_bOldScanData = 0; /* No data at all */
m_bOldScanData = 0; /* No data at all */
m_fStart = m_fFirst = SANE_TRUE; /* Prepare to read */
m_fStart = m_fFirst = SANE_TRUE; /* Prepare to read */
DBG( _DBG_INFO2, "Register Dump before reading data:\n" );
DBG( _DBG_DREGS, "Register Dump before reading data:\n" );
dumpregs( dev->fd, NULL );
inches = (u_short)((m_pParam->Origin.y *300UL)/hw->wMotorDpi);
DBG( _DBG_INFO2, ">>> INC=%u, DOY=%u\n", inches, sc->Normal.DataOrigin.y );
if((inches > sc->Normal.DataOrigin.y ) && (clk->min_ffstep != 0xffff))
usb_WaitPos( dev, 150, SANE_FALSE );
return SANE_TRUE;
}
@ -1263,7 +1265,7 @@ static SANE_Bool usb_ScanEnd( pPlustek_Device dev )
u_char value;
DBG( _DBG_INFO, "usbDev_ScanEnd(), start=%u, park=%u\n",
m_fStart, m_fAutoPark );
m_fStart, m_fAutoPark );
usbio_ReadReg( dev->fd, 0x07, &value );
if( value == 3 || value != 2 )
@ -1272,10 +1274,8 @@ static SANE_Bool usb_ScanEnd( pPlustek_Device dev )
if( m_fStart ) {
m_fStart = SANE_FALSE;
if( m_fAutoPark ) {
if( m_fAutoPark )
usb_ModuleToHome( dev, SANE_FALSE );
}
}
else if( SANE_TRUE == cancelRead ) {
@ -1340,7 +1340,7 @@ static SANE_Bool usb_IsDataAvailableInDRAM( pPlustek_Device dev )
/**
*/
static SANE_Bool usb_ScanReadImage( pPlustek_Device dev,
void *pBuf, u_long dwSize )
void *pBuf, u_long dwSize )
{
static u_long dwBytes = 0;
SANE_Status res;
@ -1494,6 +1494,7 @@ static void usb_SaveImageInfo( pPlustek_Device dev, pImgDef pInfo )
case COLOR_GRAY16:
pParam->bBitDepth = 16;
/* fall through... */
case COLOR_256GRAY:
pParam->bDataType = SCANDATATYPE_Gray;
@ -1506,7 +1507,7 @@ static void usb_SaveImageInfo( pPlustek_Device dev, pImgDef pInfo )
pParam->bChannels = 1;
}
DBG( _DBG_INFO, "dwFlag = 0x%08lx\n", pInfo->dwFlag );
DBG( _DBG_INFO, "* dwFlag = 0x%08lx\n", pInfo->dwFlag );
if( pInfo->dwFlag & SCANDEF_Transparency )
pParam->bSource = SOURCE_Transparency;

896
backend/plustek-usbshading.c
Wyświetl plik

Plik diff jest za duży Load Diff

499
backend/plustek.c
Wyświetl plik

@ -69,6 +69,7 @@
* - added call to usb_StartLampTimer, when we're using
* SIGALRM for lamp timer
* - closing now writer pipe, when reader_process is done
* - 0.48 - added additional options
*.
* <hr>
* This file is part of the SANE package.
@ -116,7 +117,7 @@
*/
#ifdef _AIX
# include "../include/lalloca.h" /* MUST come first for AIX! */
# include "../include/lalloca.h"
#endif
#include "../include/sane/config.h"
@ -144,7 +145,7 @@
#include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h"
#define BACKEND_VERSION "0.47-11"
#define BACKEND_VERSION "0.48-1"
#define BACKEND_NAME plustek
#include "../include/sane/sanei_backend.h"
#include "../include/sane/sanei_config.h"
@ -161,9 +162,10 @@
#define _DBG_INFO 5
#define _DBG_PROC 7
#define _DBG_SANE_INIT 10
#define _DBG_INFO2 13
#define _DBG_DUMP 20
#define _DBG_READ 25
#define _DBG_INFO2 15
#define _DBG_DREGS 20
#define _DBG_DPIC 25
#define _DBG_READ 30
/*****************************************************************************/
@ -232,12 +234,10 @@ static const SANE_Range percentage_range =
1 << SANE_FIXED_SCALE_SHIFT /* quantization */
};
static const SANE_Range warmup_range =
{
0, /* minimum */
999, /* maximum */
1 /* quantization */
};
static const SANE_Range warmup_range = { -1, 999, 1 };
static const SANE_Range offtimer_range = { 0, 999, 1 };
static const SANE_Range gain_range = { -1, 63, 1 };
static const SANE_Range loff_range = { -1, 16363, 1 };
/* authorization stuff */
static SANE_Auth_Callback auth = NULL;
@ -277,6 +277,9 @@ static void show_cnf( pCnfDef cnf )
DBG( _DBG_SANE_INIT,"red gain : %d\n", cnf->adj.rgain );
DBG( _DBG_SANE_INIT,"green gain : %d\n", cnf->adj.ggain );
DBG( _DBG_SANE_INIT,"blue gain : %d\n", cnf->adj.bgain );
DBG( _DBG_SANE_INIT,"red offset : %d\n", cnf->adj.rofs );
DBG( _DBG_SANE_INIT,"green offset : %d\n", cnf->adj.gofs );
DBG( _DBG_SANE_INIT,"blue offset : %d\n", cnf->adj.bofs );
DBG( _DBG_SANE_INIT,"red lampoff : %d\n", cnf->adj.rlampoff );
DBG( _DBG_SANE_INIT,"green lampoff: %d\n", cnf->adj.glampoff );
DBG( _DBG_SANE_INIT,"blue lampoff : %d\n", cnf->adj.blampoff );
@ -302,8 +305,8 @@ static SANE_Status drvclose( Plustek_Device *dev )
}
/* don't check the return values, simply do it */
dev->stopScan( dev );
dev->close ( dev );
usbDev_stopScan( dev );
usbDev_close ( dev );
}
dev->fd = -1;
@ -316,10 +319,10 @@ static pModeParam getModeList( Plustek_Scanner *scanner )
{
pModeParam mp= mode_params;
/* the transparency/negative mode supports only GRAY/COLOR/COLOR32/COLOR48
/* the transparency/negative mode supports only COLOR_TRUE24 & COLOR_TRUE48
*/
if( 0 != scanner->val[OPT_EXT_MODE].w ) {
mp = &mp[_TPAModeSupportMin];
mp = &mp[scanner->hw->usbDev.Caps.Positive.bMinDataType];
}
return mp;
@ -427,13 +430,13 @@ static int reader_process( void *args )
/* here we read all data from the driver... */
buf = scanner->buf;
status = scanner->hw->prepare( scanner->hw, buf );
status = usbDev_Prepare( scanner->hw, buf );
if( 0 == status ) {
for( line = 0; line < scanner->params.lines; line++ ) {
status = scanner->hw->readLine( scanner->hw );
status = usbDev_ReadLine( scanner->hw );
if((int)status < 0 ) {
break;
}
@ -451,7 +454,7 @@ static int reader_process( void *args )
if((int)status < 0 ) {
DBG( _DBG_ERROR, "read failed, status = %i, errno %i\n",
(int)status, lerrn );
if( -9009 == (int)status )
if( _E_ABORT == (int)status )
return SANE_STATUS_CANCELLED;
if( lerrn == EBUSY )
@ -817,7 +820,7 @@ static SANE_Status init_options( Plustek_Scanner *s )
s->opt[OPT_EXT_MODE].cap |= SANE_CAP_INACTIVE;
}
/* "Enhancement" group: */
/* "Device settings" group: */
s->opt[OPT_DEVICE_GROUP].name = "device-settings";
s->opt[OPT_DEVICE_GROUP].title = SANE_I18N("Device-Settings");
s->opt[OPT_DEVICE_GROUP].desc = "";
@ -831,14 +834,120 @@ static SANE_Status init_options( Plustek_Scanner *s )
s->opt[OPT_LAMPSWITCH].type = SANE_TYPE_BOOL;
s->val[OPT_LAMPSWITCH].w = SANE_FALSE;
s->opt[OPT_CACHECAL].name = "calibration-cache";
s->opt[OPT_CACHECAL].title = SANE_I18N("Calibration data cache");;
s->opt[OPT_CACHECAL].desc = SANE_I18N("Enables or disables calibration data cache.");
s->opt[OPT_CACHECAL].type = SANE_TYPE_BOOL;
s->val[OPT_CACHECAL].w = adj->cacheCalData;
s->opt[OPT_LAMPOFF_ONEND].name = "lampoff_onend";
s->opt[OPT_LAMPOFF_ONEND].title = SANE_I18N("Lamp off on shutdown");;
s->opt[OPT_LAMPOFF_ONEND].desc = SANE_I18N("Switch lamp off when leaving the backend.");
s->opt[OPT_LAMPOFF_ONEND].type = SANE_TYPE_BOOL;
s->val[OPT_LAMPOFF_ONEND].w = adj->lampOffOnEnd;
s->opt[OPT_WARMUPTIME].name = "warmup-time";
s->opt[OPT_WARMUPTIME].title = SANE_I18N("Warmup-Time");;
s->opt[OPT_WARMUPTIME].desc = SANE_I18N("Warmup-Time in seconds.");
s->opt[OPT_WARMUPTIME].title = SANE_I18N("Warmup-time");;
s->opt[OPT_WARMUPTIME].desc = SANE_I18N("Warmup-time in seconds.");
s->opt[OPT_WARMUPTIME].type = SANE_TYPE_INT;
s->opt[OPT_WARMUPTIME].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_WARMUPTIME].constraint.range = &warmup_range;
s->val[OPT_WARMUPTIME].w = adj->warmup;
s->opt[OPT_LAMPOFF_TIMER].name = "lampoff-time";
s->opt[OPT_LAMPOFF_TIMER].title = SANE_I18N("Lampoff-time");;
s->opt[OPT_LAMPOFF_TIMER].desc = SANE_I18N("Lampoff-time in seconds.");
s->opt[OPT_LAMPOFF_TIMER].type = SANE_TYPE_INT;
s->opt[OPT_LAMPOFF_TIMER].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_LAMPOFF_TIMER].constraint.range = &offtimer_range;
s->val[OPT_LAMPOFF_TIMER].w = adj->lampOff;
/* "Analog Frontend" group*/
s->opt[OPT_AFE_GROUP].name = "afe-group";
s->opt[OPT_AFE_GROUP].title = SANE_I18N("Analog frontend");
s->opt[OPT_AFE_GROUP].desc = "";
s->opt[OPT_AFE_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_AFE_GROUP].cap = 0;
s->opt[OPT_OVR_REDGAIN].name = "red-gain";
s->opt[OPT_OVR_REDGAIN].title = SANE_I18N("Red-gain");
s->opt[OPT_OVR_REDGAIN].desc = SANE_I18N("Red-gain value of the AFE");
s->opt[OPT_OVR_REDGAIN].type = SANE_TYPE_INT;
s->opt[OPT_OVR_REDGAIN].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_REDGAIN].constraint.range = &gain_range;
s->val[OPT_OVR_REDGAIN].w = adj->rgain;
s->opt[OPT_OVR_REDOFS].name = "red-offset";
s->opt[OPT_OVR_REDOFS].title = SANE_I18N("Red-offset");
s->opt[OPT_OVR_REDOFS].desc = SANE_I18N("Red-offset value of the AFE");
s->opt[OPT_OVR_REDOFS].type = SANE_TYPE_INT;
s->opt[OPT_OVR_REDOFS].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_REDOFS].constraint.range = &gain_range;
s->val[OPT_OVR_REDOFS].w = adj->rofs;
s->opt[OPT_OVR_GREENGAIN].name = "green-gain";
s->opt[OPT_OVR_GREENGAIN].title = SANE_I18N("Green-gain");
s->opt[OPT_OVR_GREENGAIN].desc = SANE_I18N("Green-gain value of the AFE");
s->opt[OPT_OVR_GREENGAIN].type = SANE_TYPE_INT;
s->opt[OPT_OVR_GREENGAIN].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_GREENGAIN].constraint.range = &gain_range;
s->val[OPT_OVR_GREENGAIN].w = adj->ggain;
s->opt[OPT_OVR_GREENOFS].name = "green-offset";
s->opt[OPT_OVR_GREENOFS].title = SANE_I18N("Green-offset");
s->opt[OPT_OVR_GREENOFS].desc = SANE_I18N("Green-offset value of the AFE");
s->opt[OPT_OVR_GREENOFS].type = SANE_TYPE_INT;
s->opt[OPT_OVR_GREENOFS].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_GREENOFS].constraint.range = &gain_range;
s->val[OPT_OVR_GREENOFS].w = adj->gofs;
s->opt[OPT_OVR_BLUEGAIN].name = "blue-gain";
s->opt[OPT_OVR_BLUEGAIN].title = SANE_I18N("Blue-gain");
s->opt[OPT_OVR_BLUEGAIN].desc = SANE_I18N("Blue-gain value of the AFE");
s->opt[OPT_OVR_BLUEGAIN].type = SANE_TYPE_INT;
s->opt[OPT_OVR_BLUEGAIN].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_BLUEGAIN].constraint.range = &gain_range;
s->val[OPT_OVR_BLUEGAIN].w = adj->bgain;
s->opt[OPT_OVR_BLUEOFS].name = "blue-offset";
s->opt[OPT_OVR_BLUEOFS].title = SANE_I18N("Blue-offset");
s->opt[OPT_OVR_BLUEOFS].desc = SANE_I18N("Blue-offset value of the AFE");
s->opt[OPT_OVR_BLUEOFS].type = SANE_TYPE_INT;
s->opt[OPT_OVR_BLUEOFS].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_BLUEOFS].constraint.range = &gain_range;
s->val[OPT_OVR_BLUEOFS].w = adj->bofs;
s->opt[OPT_OVR_RED_LOFF].name = "redlamp-off";
s->opt[OPT_OVR_RED_LOFF].title = SANE_I18N("Red lamp off");
s->opt[OPT_OVR_RED_LOFF].desc = SANE_I18N("Defines red lamp off parameter");
s->opt[OPT_OVR_RED_LOFF].type = SANE_TYPE_INT;
s->opt[OPT_OVR_RED_LOFF].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_RED_LOFF].constraint.range = &loff_range;
s->val[OPT_OVR_RED_LOFF].w = adj->rlampoff;
s->opt[OPT_OVR_GREEN_LOFF].name = "greenlamp-off";
s->opt[OPT_OVR_GREEN_LOFF].title = SANE_I18N("Green lamp off");
s->opt[OPT_OVR_GREEN_LOFF].desc = SANE_I18N("Defines green lamp off parameter");
s->opt[OPT_OVR_GREEN_LOFF].type = SANE_TYPE_INT;
s->opt[OPT_OVR_GREEN_LOFF].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_GREEN_LOFF].constraint.range = &loff_range;
s->val[OPT_OVR_GREEN_LOFF].w = adj->glampoff;
s->opt[OPT_OVR_BLUE_LOFF].name = "bluelamp-off";
s->opt[OPT_OVR_BLUE_LOFF].title = SANE_I18N("Blue lamp off");
s->opt[OPT_OVR_BLUE_LOFF].desc = SANE_I18N("Defines blue lamp off parameter");
s->opt[OPT_OVR_BLUE_LOFF].type = SANE_TYPE_INT;
s->opt[OPT_OVR_BLUE_LOFF].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_OVR_BLUE_LOFF].constraint.range = &loff_range;
s->val[OPT_OVR_BLUE_LOFF].w = adj->blampoff;
/* only available for CIS devices*/
if( !usb_IsCISDevice( dev )) {
s->opt[OPT_OVR_RED_LOFF].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_OVR_GREEN_LOFF].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_OVR_BLUE_LOFF].cap |= SANE_CAP_INACTIVE;
}
return SANE_STATUS_GOOD;
}
@ -866,7 +975,7 @@ static void decodeUsbIDs( char *src, char **dest )
u_short pi = 0, vi = 0;
if( *name ) {
if( *name ) {
name = sanei_config_get_string( name, &tmp );
if( tmp ) {
@ -1029,12 +1138,12 @@ static SANE_Status attach( const char *dev_name,
memset(dev, 0, sizeof (*dev));
dev->fd = -1;
dev->name = strdup(dev_name); /* hold it double to avoid */
dev->sane.name = dev->name; /* compiler warnings */
dev->sane.vendor = "Plustek";
dev->initialized = -1; /* will be used as index too */
dev->calFile = NULL;
dev->fd = -1;
dev->name = strdup(dev_name); /* hold it double to avoid */
dev->sane.name = dev->name; /* compiler warnings */
dev->sane.vendor = "Plustek";
dev->initialized = -1; /* will be used as index too */
dev->calFile = NULL;
memcpy( &dev->adj, &cnf->adj, sizeof(AdjDef));
@ -1043,22 +1152,8 @@ static SANE_Status attach( const char *dev_name,
dev->sane.type = "USB flatbed scanner";
#ifdef _PLUSTEK_USB
dev->close = usbDev_close;
dev->getCaps = usbDev_getCaps;
dev->getCropInfo = usbDev_getCropInfo;
dev->setScanEnv = usbDev_setScanEnv;
dev->startScan = usbDev_startScan;
dev->stopScan = usbDev_stopScan;
dev->setMap = usbDev_setMap;
dev->readLine = usbDev_readLine;
dev->prepare = usbDev_Prepare;
dev->shutdown = usbDev_shutdown;
strncpy( dev->usbId, cnf->usbId, _MAX_ID_LEN );
if( cnf->adj.warmup >= 0 )
dev->usbDev.dwWarmup = cnf->adj.warmup;
if( cnf->adj.lampOff >= 0 )
dev->usbDev.dwLampOnPeriod = cnf->adj.lampOff;
@ -1081,10 +1176,10 @@ static SANE_Status attach( const char *dev_name,
/* okay, so assign the handle... */
dev->fd = handle;
result = dev->getCaps( dev );
result = usbDev_getCaps( dev );
if( result < 0 ) {
DBG( _DBG_ERROR, "dev->getCaps() failed(%d)\n", result);
dev->close(dev);
DBG( _DBG_ERROR, "usbDev_getCaps() failed(%d)\n", result);
usbDev_close(dev);
return SANE_STATUS_IO_ERROR;
}
@ -1113,7 +1208,7 @@ static SANE_Status attach( const char *dev_name,
if (NULL == dev->res_list) {
DBG( _DBG_ERROR, "alloc fail, resolution problem\n" );
dev->close(dev);
usbDev_close(dev);
return SANE_STATUS_INVAL;
}
@ -1158,6 +1253,9 @@ static void init_config_struct( pCnfDef cnf )
cnf->adj.rgain = -1;
cnf->adj.ggain = -1;
cnf->adj.bgain = -1;
cnf->adj.rofs = -1;
cnf->adj.gofs = -1;
cnf->adj.bofs = -1;
cnf->adj.rlampoff = -1;
cnf->adj.glampoff = -1;
cnf->adj.blampoff = -1;
@ -1238,6 +1336,9 @@ sane_init( SANE_Int *version_code, SANE_Auth_Callback authorize )
decodeVal( str, "red_gain", _INT, &config.adj.rgain, &ival);
decodeVal( str, "green_gain", _INT, &config.adj.ggain, &ival);
decodeVal( str, "blue_gain", _INT, &config.adj.bgain, &ival);
decodeVal( str, "red_offset", _INT, &config.adj.rofs, &ival);
decodeVal( str, "green_offset" , _INT, &config.adj.gofs, &ival);
decodeVal( str, "blue_offset", _INT, &config.adj.bofs, &ival);
decodeVal( str, "red_lampoff", _INT, &config.adj.rlampoff,&ival);
decodeVal( str, "green_lampoff", _INT, &config.adj.glampoff,&ival);
decodeVal( str, "blue_lampoff", _INT, &config.adj.blampoff,&ival);
@ -1329,8 +1430,7 @@ sane_exit( void )
next = dev->next;
/* call the shutdown function of each device... */
if( dev->shutdown )
dev->shutdown( dev );
usbDev_shutdown( dev );
/* we're doin' this to avoid compiler warnings as dev->sane.name
* is defined as const char*
@ -1529,9 +1629,18 @@ sane_control_option( SANE_Handle handle, SANE_Int option,
case OPT_BR_Y:
case OPT_LAMPSWITCH:
case OPT_CUSTOM_GAMMA:
*(SANE_Word *)value = s->val[option].w;
break;
case OPT_LAMPOFF_ONEND:
case OPT_CACHECAL:
case OPT_OVR_REDGAIN:
case OPT_OVR_GREENGAIN:
case OPT_OVR_BLUEGAIN:
case OPT_OVR_REDOFS:
case OPT_OVR_GREENOFS:
case OPT_OVR_BLUEOFS:
case OPT_OVR_RED_LOFF:
case OPT_OVR_GREEN_LOFF:
case OPT_OVR_BLUE_LOFF:
case OPT_LAMPOFF_TIMER:
case OPT_WARMUPTIME:
*(SANE_Word *)value = s->val[option].w;
break;
@ -1592,16 +1701,16 @@ sane_control_option( SANE_Handle handle, SANE_Int option,
case OPT_RESOLUTION: {
int n;
int min_d = s->hw->res_list[s->hw->res_list_size - 1];
int min_d = dev->res_list[dev->res_list_size - 1];
int v = *(SANE_Word *)value;
int best = v;
for( n = 0; n < s->hw->res_list_size; n++ ) {
int d = abs(v - s->hw->res_list[n]);
for( n = 0; n < dev->res_list_size; n++ ) {
int d = abs(v - dev->res_list[n]);
if( d < min_d ) {
min_d = d;
best = s->hw->res_list[n];
best = dev->res_list[n];
}
}
@ -1628,9 +1737,24 @@ sane_control_option( SANE_Handle handle, SANE_Int option,
*info |= SANE_INFO_RELOAD_PARAMS;
break;
case OPT_CACHECAL:
s->val[option].w = *(SANE_Word *)value;
dev->adj.cacheCalData = s->val[option].w;
break;
case OPT_LAMPSWITCH:
s->val[option].w = *(SANE_Word *)value;
usb_LampSwitch( dev, s->val[option].w );
if( s->val[option].w == 0 )
usb_StopLampTimer( dev );
else
usb_StartLampTimer( dev );
break;
case OPT_LAMPOFF_ONEND:
s->val[option].w = *(SANE_Word *)value;
dev->adj.lampOffOnEnd = s->val[option].w;
usb_CheckAndCopyAdjs( dev );
break;
case OPT_CUSTOM_GAMMA:
@ -1672,137 +1796,202 @@ sane_control_option( SANE_Handle handle, SANE_Int option,
}
break;
case OPT_LAMPOFF_TIMER:
s->val[option].w = (*(SANE_Word *)value);
adj->lampOff = (*(SANE_Word *)value);
usb_CheckAndCopyAdjs( dev );
break;
case OPT_WARMUPTIME:
s->val[option].w = (*(SANE_Word *)value);
adj->warmup = (*(SANE_Word *)value);
usb_CheckAndCopyAdjs( dev );
break;
case OPT_OVR_REDGAIN:
s->val[option].w = (*(SANE_Word *)value);
adj->rgain = (*(SANE_Word *)value);
break;
case OPT_OVR_GREENGAIN:
s->val[option].w = (*(SANE_Word *)value);
adj->ggain = (*(SANE_Word *)value);
break;
case OPT_OVR_BLUEGAIN:
s->val[option].w = (*(SANE_Word *)value);
adj->bgain = (*(SANE_Word *)value);
break;
case OPT_OVR_REDOFS:
s->val[option].w = (*(SANE_Word *)value);
adj->rofs = (*(SANE_Word *)value);
break;
case OPT_OVR_GREENOFS:
s->val[option].w = (*(SANE_Word *)value);
adj->gofs = (*(SANE_Word *)value);
break;
case OPT_OVR_BLUEOFS:
s->val[option].w = (*(SANE_Word *)value);
adj->bofs = (*(SANE_Word *)value);
break;
case OPT_OVR_RED_LOFF:
s->val[option].w = (*(SANE_Word *)value);
adj->rlampoff = (*(SANE_Word *)value);
break;
case OPT_OVR_GREEN_LOFF:
s->val[option].w = (*(SANE_Word *)value);
adj->glampoff = (*(SANE_Word *)value);
break;
case OPT_OVR_BLUE_LOFF:
s->val[option].w = (*(SANE_Word *)value);
adj->blampoff = (*(SANE_Word *)value);
break;
case OPT_CONTRAST:
case OPT_BRIGHTNESS:
s->val[option].w =
((*(SANE_Word *)value) >> SANE_FIXED_SCALE_SHIFT);
break;
case OPT_MODE:
idx = (optval - mode_usb_list);
case OPT_MODE:
idx = (optval - mode_usb_list);
mp = getModeList( s );
s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
if( mp[idx].scanmode == COLOR_BW ) {
s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
}
s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
if( mp[idx].scanmode == COLOR_BW ) {
s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
}
s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
if( s->val[OPT_CUSTOM_GAMMA].w &&
!(s->opt[OPT_CUSTOM_GAMMA].cap & SANE_CAP_INACTIVE)) {
!(s->opt[OPT_CUSTOM_GAMMA].cap & SANE_CAP_INACTIVE)) {
if((mp[idx].scanmode == COLOR_256GRAY) ||
(mp[idx].scanmode == COLOR_GRAY16)) {
s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
} else {
s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
}
}
if( NULL != info )
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
if( NULL != info )
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
s->val[option].w = optval - s->opt[option].constraint.string_list;
break;
s->val[option].w = optval - s->opt[option].constraint.string_list;
break;
case OPT_EXT_MODE: {
s->val[option].w = optval - s->opt[option].constraint.string_list;
case OPT_EXT_MODE: {
s->val[option].w = optval - s->opt[option].constraint.string_list;
/*
* change the area and mode_list when changing the source
*/
if( s->val[option].w == 0 ) {
/* change the area and mode_list when changing the source
*/
if( s->val[option].w == 0 ) {
dev->scanning.sParam.bSource = SOURCE_Reflection;
s->hw->dpi_range.min = _DEF_DPI;
dev->dpi_range.min = _DEF_DPI;
s->hw->x_range.max = SANE_FIX(s->hw->max_x);
s->hw->y_range.max = SANE_FIX(s->hw->max_y);
s->val[OPT_TL_X].w = SANE_FIX(_DEFAULT_TLX);
s->val[OPT_TL_Y].w = SANE_FIX(_DEFAULT_TLY);
s->val[OPT_BR_X].w = SANE_FIX(_DEFAULT_BRX);
s->val[OPT_BR_Y].w = SANE_FIX(_DEFAULT_BRY);
dev->x_range.max = SANE_FIX(dev->max_x);
dev->y_range.max = SANE_FIX(dev->max_y);
s->val[OPT_TL_X].w = SANE_FIX(_DEFAULT_TLX);
s->val[OPT_TL_Y].w = SANE_FIX(_DEFAULT_TLY);
s->val[OPT_BR_X].w = SANE_FIX(_DEFAULT_BRX);
s->val[OPT_BR_Y].w = SANE_FIX(_DEFAULT_BRY);
s->opt[OPT_MODE].constraint.string_list = mode_usb_list;
s->val[OPT_MODE].w = COLOR_TRUE24;
s->opt[OPT_MODE].constraint.string_list = mode_usb_list;
s->val[OPT_MODE].w = COLOR_TRUE24;
} else {
} else {
s->hw->dpi_range.min = _TPAMinDpi;
dev->dpi_range.min = _TPAMinDpi;
if( s->val[option].w == 1 ) {
s->hw->x_range.max = SANE_FIX(_TP_X);
s->hw->y_range.max = SANE_FIX(_TP_Y);
s->val[OPT_TL_X].w = SANE_FIX(_DEFAULT_TP_TLX);
s->val[OPT_TL_Y].w = SANE_FIX(_DEFAULT_TP_TLY);
s->val[OPT_BR_X].w = SANE_FIX(_DEFAULT_TP_BRX);
s->val[OPT_BR_Y].w = SANE_FIX(_DEFAULT_TP_BRY);
if( s->val[option].w == 1 ) {
} else {
s->hw->x_range.max = SANE_FIX(_NEG_X);
s->hw->y_range.max = SANE_FIX(_NEG_Y);
s->val[OPT_TL_X].w = SANE_FIX(_DEFAULT_NEG_TLX);
s->val[OPT_TL_Y].w = SANE_FIX(_DEFAULT_NEG_TLY);
s->val[OPT_BR_X].w = SANE_FIX(_DEFAULT_NEG_BRX);
s->val[OPT_BR_Y].w = SANE_FIX(_DEFAULT_NEG_BRY);
}
s->opt[OPT_MODE].constraint.string_list =
&mode_usb_list[_TPAModeSupportMin];
s->val[OPT_MODE].w = 0; /* COLOR_24 is the default */
}
dev->scanning.sParam.bSource = SOURCE_Transparency;
if( dev->usbDev.Caps.wFlags & DEVCAPSFLAG_LargeTPA ) {
dev->x_range.max = SANE_FIX(_SCALE(_TPALargePageWidth));
dev->y_range.max = SANE_FIX(_SCALE(_TPALargePageHeight));
} else {
dev->x_range.max = SANE_FIX(_SCALE(_TPAPageWidth));
dev->y_range.max = SANE_FIX(_SCALE(_TPAPageHeight));
}
s->val[OPT_TL_X].w = SANE_FIX(_DEFAULT_TP_TLX);
s->val[OPT_TL_Y].w = SANE_FIX(_DEFAULT_TP_TLY);
s->val[OPT_BR_X].w = SANE_FIX(_DEFAULT_TP_BRX);
s->val[OPT_BR_Y].w = SANE_FIX(_DEFAULT_TP_BRY);
s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
} else {
dev->scanning.sParam.bSource = SOURCE_Negative;
if( dev->usbDev.Caps.wFlags & DEVCAPSFLAG_LargeTPA ) {
dev->x_range.max = SANE_FIX(_SCALE(_NegLargePageWidth));
dev->y_range.max = SANE_FIX(_SCALE(_NegLargePageHeight));
} else {
dev->x_range.max = SANE_FIX(_SCALE(_NegPageWidth));
dev->y_range.max = SANE_FIX(_SCALE(_NegPageHeight));
}
s->val[OPT_TL_X].w = SANE_FIX(_DEFAULT_NEG_TLX);
s->val[OPT_TL_Y].w = SANE_FIX(_DEFAULT_NEG_TLY);
s->val[OPT_BR_X].w = SANE_FIX(_DEFAULT_NEG_BRX);
s->val[OPT_BR_Y].w = SANE_FIX(_DEFAULT_NEG_BRY);
}
s->opt[OPT_MODE].constraint.string_list =
&mode_usb_list[dev->usbDev.Caps.Positive.bMinDataType];
s->val[OPT_MODE].w = 0; /* COLOR_24 is the default */
}
if( s->val[OPT_LAMPSWITCH].w != 0 ) {
usb_LampSwitch( dev, s->val[OPT_LAMPSWITCH].w );
if( s->val[OPT_LAMPSWITCH].w == 0 )
usb_StopLampTimer( dev );
else
usb_StartLampTimer( dev );
}
if( NULL != info )
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
break;
}
s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
if( NULL != info )
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
break;
}
case OPT_GAMMA_VECTOR:
DBG( _DBG_INFO, "Setting MASTER gamma.\n" );
memcpy( s->val[option].wa, value, s->opt[option].size );
checkGammaSettings(s);
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
break;
case OPT_GAMMA_VECTOR_R:
DBG( _DBG_INFO, "Setting RED gamma.\n" );
memcpy( s->val[option].wa, value, s->opt[option].size );
checkGammaSettings(s);
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
break;
case OPT_GAMMA_VECTOR_G:
DBG( _DBG_INFO, "Setting GREEN gamma.\n" );
memcpy( s->val[option].wa, value, s->opt[option].size );
checkGammaSettings(s);
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
break;
case OPT_GAMMA_VECTOR_B:
DBG( _DBG_INFO, "Setting BLUE gamma.\n" );
memcpy( s->val[option].wa, value, s->opt[option].size );
checkGammaSettings(s);
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
if( NULL != info )
*info |= SANE_INFO_RELOAD_PARAMS;
break;
default:
return SANE_STATUS_INVAL;
default:
return SANE_STATUS_INVAL;
}
break;
@ -1887,7 +2076,7 @@ SANE_Status
sane_start( SANE_Handle handle )
{
Plustek_Scanner *s = (Plustek_Scanner *)handle;
pPlustek_Device dev;
Plustek_Device *dev;
pModeParam mp;
int result;
@ -1928,13 +2117,13 @@ sane_start( SANE_Handle handle )
return SANE_STATUS_IO_ERROR;
}
result = dev->getCaps( dev );
result = usbDev_getCaps( dev );
if( result < 0 ) {
DBG( _DBG_ERROR, "dev->getCaps() failed(%d)\n", result);
dev->close( dev );
DBG( _DBG_ERROR, "usbDev_getCaps() failed(%d)\n", result);
usbDev_close( dev );
return SANE_STATUS_IO_ERROR;
}
}
/* All ready to go. Set image def and see what the scanner
* says for crop info.
*/
@ -1961,13 +2150,13 @@ sane_start( SANE_Handle handle )
dpi_y = (double)dev->usbDev.Caps.OpticDpi.x * 2;
left = (int)(SANE_UNFIX (s->val[OPT_TL_X].w)*dpi_x/
(MM_PER_INCH*(dpi_x/300.0)));
(MM_PER_INCH*(dpi_x/300.0)));
top = (int)(SANE_UNFIX (s->val[OPT_TL_Y].w)*dpi_y/
(MM_PER_INCH*(dpi_y/300.0)));
(MM_PER_INCH*(dpi_y/300.0)));
width = (int)(SANE_UNFIX (s->val[OPT_BR_X].w - s->val[OPT_TL_X].w) *
dpi_x / (MM_PER_INCH *(dpi_x/300.0)));
dpi_x / (MM_PER_INCH *(dpi_x/300.0)));
height = (int)(SANE_UNFIX (s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w) *
dpi_y / (MM_PER_INCH *(dpi_y/300.0)));
dpi_y / (MM_PER_INCH *(dpi_y/300.0)));
/* adjust mode list according to the model we use and the
* source we have
@ -1994,17 +2183,17 @@ sane_start( SANE_Handle handle )
default: break;
}
result = dev->getCropInfo( dev, &crop );
result = usbDev_getCropInfo( dev, &crop );
if( result < 0 ) {
DBG( _DBG_ERROR, "dev->getCropInfo() failed(%d)\n", result );
dev->close( dev );
DBG( _DBG_ERROR, "usbDev_getCropInfo() failed(%d)\n", result );
usbDev_close( dev );
return SANE_STATUS_IO_ERROR;
}
/* DataInf.dwAppPixelsPerLine = crop.dwPixelsPerLine; */
s->params.pixels_per_line = crop.dwPixelsPerLine;
s->params.bytes_per_line = crop.dwBytesPerLine;
s->params.lines = crop.dwLinesPerArea;
s->params.lines = crop.dwLinesPerArea;
/* build a SCANINFO block and get ready to scan it */
crop.ImgDef.dwFlag |= SCANDEF_QualityScan;
@ -2022,28 +2211,28 @@ sane_start( SANE_Handle handle )
DBG( _DBG_SANE_INIT, "brightness %i, contrast %i\n",
sinfo.siBrightness, sinfo.siContrast );
result = dev->setScanEnv( dev, &sinfo );
result = usbDev_setScanEnv( dev, &sinfo );
if( result < 0 ) {
DBG( _DBG_ERROR, "dev->setEnv() failed(%d)\n", result );
dev->close( dev );
DBG( _DBG_ERROR, "usbDev_setScanEnv() failed(%d)\n", result );
usbDev_close( dev );
return SANE_STATUS_IO_ERROR;
}
/* download gamma correction tables... */
if( scanmode <= COLOR_GRAY16 ) {
dev->setMap( dev, s->gamma_table[0], s->gamma_length, _MAP_MASTER);
usbDev_setMap( dev, s->gamma_table[0], s->gamma_length, _MAP_MASTER);
} else {
dev->setMap( dev, s->gamma_table[1], s->gamma_length, _MAP_RED );
dev->setMap( dev, s->gamma_table[2], s->gamma_length, _MAP_GREEN );
dev->setMap( dev, s->gamma_table[3], s->gamma_length, _MAP_BLUE );
usbDev_setMap( dev, s->gamma_table[1], s->gamma_length, _MAP_RED );
usbDev_setMap( dev, s->gamma_table[2], s->gamma_length, _MAP_GREEN );
usbDev_setMap( dev, s->gamma_table[3], s->gamma_length, _MAP_BLUE );
}
tsecs = 0; /* reset timer */
result = dev->startScan( dev );
result = usbDev_startScan( dev );
if( result < 0 ) {
DBG( _DBG_ERROR, "dev->startScan() failed(%d)\n", result );
dev->close( dev );
DBG( _DBG_ERROR, "usbDev_startScan() failed(%d)\n", result );
usbDev_close( dev );
return SANE_STATUS_IO_ERROR;
}
@ -2053,7 +2242,7 @@ sane_start( SANE_Handle handle )
s->buf = realloc( s->buf, (s->params.lines) * s->params.bytes_per_line );
if( NULL == s->buf ) {
DBG( _DBG_ERROR, "realloc failed\n" );
dev->close( dev );
usbDev_close( dev );
return SANE_STATUS_NO_MEM;
}
@ -2069,7 +2258,7 @@ sane_start( SANE_Handle handle )
if( pipe(fds) < 0 ) {
DBG( _DBG_ERROR, "ERROR: could not create pipe\n" );
s->scanning = SANE_FALSE;
dev->close( dev );
usbDev_close( dev );
return SANE_STATUS_IO_ERROR;
}
@ -2084,7 +2273,7 @@ sane_start( SANE_Handle handle )
if( s->reader_pid < 0 ) {
DBG( _DBG_ERROR, "ERROR: could not start reader task\n" );
s->scanning = SANE_FALSE;
dev->close( dev );
usbDev_close( dev );
return SANE_STATUS_IO_ERROR;
}

32
backend/plustek.conf
Wyświetl plik

@ -40,13 +40,16 @@
# options for the previous USB entry
#
# switch lamp off after xxx secs, 0 disables the feature
# (can also be set via frontend)
option lampOff 300
# warmup period in seconds, 0 means no warmup
option warmup 15
# warmup period in seconds, 0 means no warmup, -1 means auto-warmup
# (can also be set via frontend)
option warmup -1
# 0 means leave lamp-status untouched, not 0 means switch off
# on sane_close
# (can also be set via frontend)
option lOffOnEnd 1
#
@ -70,7 +73,7 @@ option negOffY 0
# for setting the calibration strip position
# (WARNING: there's no internal range check!!!)
# -1 means use built in
#
# (can also be set via frontend)
option posShadingY -1
option tpaShadingY -1
option negShadingY -1
@ -82,7 +85,7 @@ option invertNegatives 0
#
# to save/restore coarse calibration data
#
# (can also be set via frontend)
option cacheCalData 0
#
@ -106,31 +109,40 @@ option skipFine 0
#
option skipFineWhite 0
# for replacing the gain values found during
# for replacing the gain values found during coarse
# calibration
# (can also be set via frontend)
option red_gain -1
option green_gain -1
option blue_gain -1
# for replacing the offset values found during coarse
# calibration
# (can also be set via frontend)
option red_offset -1
option green_offset -1
option blue_offset -1
#
#
# for replacing the default lampoff settings, this
# works only for CIS devices like CanoScan LiDE20
# (can also be set via frontend)
option red_lampoff -1
option green_lampoff -1
option blue_lampoff -1
#
# for adjusting the default gamma values
#
# (can also be set via frontend)
option redGamma 1.0
option greenGamma 1.0
option blueGamma 1.0
option grayGamma 1.0
#
# to enable TPA (non Plustek devices only)
# to enable TPA (EPSON or UMAX, if autodetection fails)
# 0 means default behaviour as specified in the internal tables
# 1 means enable
#
# 1 means enable (needed for UMAX 3450)
option enableTPA 0
#

143
backend/plustek.h
Wyświetl plik

@ -7,7 +7,7 @@
* @brief Definitions for the backend.
*
* Based on Kazuhiro Sasayama previous
* Work on plustek.[ch] file from the SANE package.<br>
* work on plustek.[ch] file from the SANE package.<br>
*
* original code taken from sane-0.71<br>
* Copyright (C) 1997 Hypercore Software Design, Ltd.<br>
@ -31,7 +31,7 @@
* - removed dropout stuff
* - 0.39 - PORTTYPE enum
* - added function pointers to control a scanner device
* (Parport and USB)
* (Parport and USB)
* - 0.40 - added USB stuff
* - 0.41 - added configuration stuff
* - 0.42 - added custom gamma tables
@ -46,6 +46,11 @@
* - 0.47 - added mov to adjustment
* - changed stopScan function definition
* - removed open function
* - added OPT_LAMPSWITCH and OPT_WARMUPTIME
* - 0.48 - added OPT_CACHECAL, OPT_OVR_*, OPT_LAMPOFF_TIMER and
* OPT_LAMPOFF_ONEND, also did some cleanup
* - moved SCANDEF definitions to plustek-usb.h
* - removed function pointer
* .
* <hr>
* This file is part of the SANE package.
@ -100,52 +105,52 @@
# define PATH_MAX 1024
#endif
#define _MEASURE_BASE 300UL
#define _DEF_DPI 50
#define _MEASURE_BASE 300UL
#define _DEF_DPI 50
/** the default image size
*/
#define _DEFAULT_TLX 0 /* 0..216 mm */
#define _DEFAULT_TLY 0 /* 0..297 mm */
#define _DEFAULT_BRX 126 /* 0..216 mm*/
#define _DEFAULT_BRY 76.21 /* 0..297 mm */
#define _DEFAULT_TLX 0 /* 0..216 mm */
#define _DEFAULT_TLY 0 /* 0..297 mm */
#define _DEFAULT_BRX 126 /* 0..216 mm */
#define _DEFAULT_BRY 76.21 /* 0..297 mm */
#define _DEFAULT_TP_TLX 3.5 /* 0..42.3 mm */
#define _DEFAULT_TP_TLY 10.5 /* 0..43.1 mm */
#define _DEFAULT_TP_BRX 38.5 /* 0..42.3 mm */
#define _DEFAULT_TP_BRY 33.5 /* 0..43.1 mm */
#define _DEFAULT_TP_TLX 3.5 /* 0..42.3 mm */
#define _DEFAULT_TP_TLY 10.5 /* 0..43.1 mm */
#define _DEFAULT_TP_BRX 38.5 /* 0..42.3 mm */
#define _DEFAULT_TP_BRY 33.5 /* 0..43.1 mm */
#define _DEFAULT_NEG_TLX 1.5 /* 0..38.9 mm */
#define _DEFAULT_NEG_TLY 1.5 /* 0..29.6 mm */
#define _DEFAULT_NEG_BRX 37.5 /* 0..38.9 mm */
#define _DEFAULT_NEG_BRY 25.5 /* 0..29.6 mm */
#define _DEFAULT_NEG_TLX 1.5 /* 0..38.9 mm */
#define _DEFAULT_NEG_TLY 1.5 /* 0..29.6 mm */
#define _DEFAULT_NEG_BRX 37.5 /* 0..38.9 mm */
#define _DEFAULT_NEG_BRY 25.5 /* 0..29.6 mm */
/** image sizes for normal, transparent and negative modes
*/
#define _TPAPageWidth 500U
#define _TPAPageHeight 510U
#define _TPAMinDpi 150
#define _TPAModeSupportMin COLOR_TRUE24
#define _TPAPageWidth 500UL
#define _TPAPageHeight 510UL
#define _TPALargePageWidth 1270UL
#define _TPALargePageHeight 1570UL
#define _TPAMinDpi 150
#define _NegativePageWidth 460UL
#define _NegativePageHeight 350UL
#define _NegPageWidth 460UL
#define _NegPageHeight 350UL
#define _NegLargePageWidth 1270UL
#define _NegLargePageHeight 1570UL
#define _TP_X ((double)_TPAPageWidth/300.0 * MM_PER_INCH)
#define _TP_Y ((double)_TPAPageHeight/300.0 * MM_PER_INCH)
#define _NEG_X ((double)_NegativePageWidth/300.0 * MM_PER_INCH)
#define _NEG_Y ((double)_NegativePageHeight/300.0 * MM_PER_INCH)
#define _SCALE(X) ((double)(X)/300.0 * MM_PER_INCH)
/** scan modes
*/
#define COLOR_BW 0
#define COLOR_256GRAY 1
#define COLOR_GRAY16 2
#define COLOR_TRUE24 3
#define COLOR_TRUE48 4
#define COLOR_BW 0
#define COLOR_256GRAY 1
#define COLOR_GRAY16 2
#define COLOR_TRUE24 3
#define COLOR_TRUE48 4
/** usb id buffer
*/
#define _MAX_ID_LEN 20
#define _MAX_ID_LEN 20
/**
*/
@ -154,19 +159,9 @@
/**
*/
#define SCANDEF_Transparency 0x00000100 /* Scanning from transparency*/
#define SCANDEF_Negative 0x00000200 /* Scanning from negative */
#define SCANDEF_QualityScan 0x00000400 /* Scanning in quality mode */
#define SCANDEF_ContinuousScan 0x00001000
#define SCANDEF_TPA (SCANDEF_Transparency | SCANDEF_Negative)
#define SCANDEF_Adf 0x00020000 /* Scan from ADF tray */
/**
*/
#define SOURCE_Reflection 0
#define SOURCE_Transparency 1
#define SOURCE_Negative 2
#define SOURCE_Reflection 0
#define SOURCE_Transparency 1
#define SOURCE_Negative 2
#define SOURCE_ADF 3
/** for Gamma tables
@ -178,7 +173,7 @@
/** generic error codes...
*/
#define _FIRST_ERR -9000
#define _FIRST_ERR -9000
#define _E_ALLOC (_FIRST_ERR-1) /**< error allocating memory */
#define _E_INVALID (_FIRST_ERR-2) /**< invalid parameter detected */
@ -215,7 +210,20 @@ enum {
OPT_GAMMA_VECTOR_B,
OPT_DEVICE_GROUP,
OPT_LAMPSWITCH,
OPT_LAMPOFF_TIMER,
OPT_LAMPOFF_ONEND,
OPT_WARMUPTIME,
OPT_CACHECAL,
OPT_AFE_GROUP,
OPT_OVR_REDGAIN,
OPT_OVR_GREENGAIN,
OPT_OVR_BLUEGAIN,
OPT_OVR_REDOFS,
OPT_OVR_GREENOFS,
OPT_OVR_BLUEOFS,
OPT_OVR_RED_LOFF,
OPT_OVR_GREEN_LOFF,
OPT_OVR_BLUE_LOFF,
NUM_OPTIONS
};
@ -242,16 +250,21 @@ typedef struct {
int altCalibrate; /* force use of the alternate canoscan autocal;
perhaps other Canon scanners require the
alternate autocalibration as well */
int rgain;
/* AFE adjustemnts, gain and offset */
int rgain;
int ggain;
int bgain;
int rofs;
int gofs;
int bofs;
int rlampoff; /* for red lamp off setting (CIS-scanner) */
int glampoff; /* for green lamp off setting (CIS-scanner) */
int blampoff; /* for blue lamp off setting (CIS-scanner) */
OffsDef pos; /* for adjusting normal scan area */
OffsDef tpa; /* for adjusting transparency scan area */
OffsDef neg; /* for adjusting negative scan area */
OffsDef pos; /* for adjusting normal scan area */
OffsDef tpa; /* for adjusting transparency scan area */
OffsDef neg; /* for adjusting negative scan area */
int posShadingY;
int tpaShadingY;
@ -294,9 +307,9 @@ typedef struct {
} ScanInfo, *pScanInfo;
typedef struct {
unsigned long dwFlag;
unsigned short wMaxExtentX; /**< scanarea width */
unsigned short wMaxExtentY; /**< scanarea height */
unsigned long dwFlag;
unsigned short wMaxExtentX; /**< scanarea width */
unsigned short wMaxExtentY; /**< scanarea height */
} ScannerCaps, *pScannerCaps;
/** for defining the scanmodes
@ -324,8 +337,8 @@ typedef struct Plustek_Device
SANE_Int *res_list; /* to hold the available phys. */
SANE_Int res_list_size; /* resolution values */
ScannerCaps caps; /* caps reported by the driver */
AdjDef adj; /* for driver adjustment */
AdjDef adj; /* for driver adjustment */
/**************************** USB-stuff **********************************/
char usbId[_MAX_ID_LEN];/* to keep Vendor and product */
/* ID string (from conf) file */
@ -335,19 +348,6 @@ typedef struct Plustek_Device
#ifdef HAVE_SETITIMER
struct itimerval saveSettings; /* for lamp timer */
#endif
/* each device we support may need other access functions...
*/
int (*close) ( struct Plustek_Device* );
void (*shutdown) ( struct Plustek_Device* );
int (*getCaps) ( struct Plustek_Device* );
int (*getCropInfo)( struct Plustek_Device*, pCropInfo );
int (*setScanEnv) ( struct Plustek_Device*, pScanInfo );
int (*setMap) ( struct Plustek_Device*, SANE_Word*,
SANE_Word, SANE_Word );
int (*startScan) ( struct Plustek_Device* );
int (*stopScan) ( struct Plustek_Device* );
int (*prepare) ( struct Plustek_Device*, SANE_Byte* );
int (*readLine) ( struct Plustek_Device* );
} Plustek_Device, *pPlustek_Device;
@ -355,8 +355,8 @@ typedef struct Plustek_Device
/* for compatibility with older versions */
typedef union
{
SANE_Word w;
SANE_Word *wa; /* word array */
SANE_Word w;
SANE_Word *wa;
SANE_String s;
} Option_Value;
#endif
@ -375,7 +375,7 @@ typedef struct Plustek_Scanner
SANE_Bool scanning; /* TRUE during scan-process */
SANE_Parameters params; /* for keeping the parameter */
/************************** gamma tables *********************************/
/************************** gamma tables *********************************/
SANE_Word gamma_table[4][4096];
SANE_Range gamma_range;
@ -385,7 +385,6 @@ typedef struct Plustek_Scanner
} Plustek_Scanner, *pPlustek_Scanner;
/** for collecting configuration info...
*/
typedef struct {