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

2658 wiersze
77 KiB
C
Czysty Wina Historia

/* @file plustek-pp_dac.c
* @brief all the shading function formerly found in shading.c.
* don't ask me why I called this file dac.c...
*
* based on sources acquired from Plustek Inc.
* Copyright (C) 1998 Plustek Inc.
* Copyright (C) 2000-2004 Gerhard Jaeger <gerhard@gjaeger.de>
* also based on the work done by Rick Bronson
*
* History:
* - 0.30 - initial version
* - 0.31 - no changes
* - 0.32 - no changes
* - 0.33 - added some comments
* - 0.34 - slight changes
* - 0.35 - removed SetInitialGainRAM from structure pScanData
* - 0.36 - added dacP96001WaitForShading and changed dacP96WaitForShading to
* dacP96003WaitForShading
* - changes, due to define renaming
* - 0.37 - removed dacP98FillShadingDarkToShadingRegister()
* - removed // comments
* - some code cleanup
* - 0.38 - added P12 stuff
* - 0.39 - no changes
* - 0.40 - disabled the A3I stuff
* - 0.41 - no changes
* - 0.42 - changed include names
* - 0.43 - no changes
* .
* <hr>
* This file is part of the SANE package.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
* MA 02111-1307, USA.
*
* As a special exception, the authors of SANE give permission for
* additional uses of the libraries contained in this release of SANE.
*
* The exception is that, if you link a SANE library with other files
* to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public
* License. Your use of that executable is in no way restricted on
* account of linking the SANE library code into it.
*
* This exception does not, however, invalidate any other reasons why
* the executable file might be covered by the GNU General Public
* License.
*
* If you submit changes to SANE to the maintainers to be included in
* a subsequent release, you agree by submitting the changes that
* those changes may be distributed with this exception intact.
*
* If you write modifications of your own for SANE, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
* <hr>
*/
#include "plustek-pp_scan.h"
/************************** local definitions ********************************/
/***************************** global vars ***********************************/
static const Byte a_bCorrectTimesTable[4] = {0, 1, 2, 4};
static ULong dwADCPipeLine = 4 * 4;
static ULong dwReadyLen;
/*************************** local functions *********************************/
/**
*/
static void dacP98AdjustGainAverage( pScanData ps )
{
pUChar pDest, pSrce;
ULong dw, dw1;
UShort wSum;
pDest = pSrce = ps->pScanBuffer1;
for (dw1 = 0; dw1 < (2560 * 3) / 16; dw1++, pDest++) {
for (dw = 0, wSum = 0; dw < 16; dw++, pSrce++)
wSum += *pSrce;
*pDest = wSum / 16;
}
}
/**
*/
static void dacP98FillDarkDAC( pScanData ps )
{
IODataRegisterToDAC( ps, 0x20, ps->bRedDAC );
IODataRegisterToDAC( ps, 0x21, ps->bGreenDAC );
IODataRegisterToDAC( ps, 0x22, ps->bBlueDAC );
}
/**
*/
static void dacP98SetReadFBKRegister( pScanData ps )
{
IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
ps->AsicReg.RD_ScanControl = _SCAN_12BITMODE + _SCAN_1ST_AVERAGE;
IOSelectLampSource( ps );
IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
ps->AsicReg.RD_Motor0Control = _MotorOn;
ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
ps->AsicReg.RD_Origin = 4;
ps->AsicReg.RD_Pixels = 512;
ps->AsicReg.RD_Motor1Control = 0;
ps->AsicReg.RD_Motor0Control = 0;
ps->AsicReg.RD_ModelControl = _LED_CONTROL + _LED_ACTIVITY;
if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_ModelControl += _ModelDpi300;
} else {
ps->AsicReg.RD_Dpi = 600;
ps->AsicReg.RD_ModelControl += _ModelDpi600;
}
}
/**
*/
static UShort dacP98CalDarkOff( pScanData ps, UShort wChDarkOff,
UShort wDACCompareHigh, UShort wDACOffset )
{
UShort wTemp;
if ((_CCD_518 == ps->Device.bCCDID) || (_CCD_535 == ps->Device.bCCDID)) {
wTemp = wChDarkOff + wDACOffset;
} else {
if (_CCD_3797 == ps->Device.bCCDID) {
if (wChDarkOff > wDACOffset) {
wTemp = wChDarkOff - wDACOffset;
} else {
wTemp = 0;
}
} else {
if (wChDarkOff > wDACCompareHigh) {
wTemp = wChDarkOff - wDACCompareHigh;
} else {
wTemp = 0;
}
}
}
return wTemp;
}
/**
*/
static Bool dacP98AdjustDAC( UShort DarkOff, UShort wHigh,
UShort wLow, pUChar pbReg, Bool *fDACStopFlag )
{
if (DarkOff > wHigh) {
if ((DarkOff - wHigh) > 10) {
if ((DarkOff - wHigh) > 2550)
*pbReg += ((DarkOff - wHigh) / 20);
else
*pbReg += ((DarkOff - wHigh) / 10);
} else
*pbReg += 1;
if (!(*pbReg))
*pbReg = 0xff;
*fDACStopFlag = _FALSE;
return _FALSE;
} else {
if (DarkOff < wLow) {
if (DarkOff > 0)
*pbReg -= 2;
else
*pbReg -= 10;
*fDACStopFlag = _FALSE;
return _FALSE;
} else
return _TRUE;
}
}
/**
*/
static Bool dacP98CheckChannelDarkLevel( pScanData ps )
{
Bool fDACStopFlag = _TRUE;
dacP98AdjustDAC( ps->Shade.DarkOffset.Colors.Red,
ps->Shade.pCcdDac->DarkCmpHi.Colors.Red,
ps->Shade.pCcdDac->DarkCmpLo.Colors.Red,
&ps->bRedDAC, &fDACStopFlag );
dacP98AdjustDAC( ps->Shade.DarkOffset.Colors.Green,
ps->Shade.pCcdDac->DarkCmpHi.Colors.Green,
ps->Shade.pCcdDac->DarkCmpLo.Colors.Green,
&ps->bGreenDAC, &fDACStopFlag );
dacP98AdjustDAC( ps->Shade.DarkOffset.Colors.Blue,
ps->Shade.pCcdDac->DarkCmpHi.Colors.Blue,
ps->Shade.pCcdDac->DarkCmpLo.Colors.Blue,
&ps->bBlueDAC, &fDACStopFlag );
return fDACStopFlag;
}
/** Average left offset 30, 16 pixels as each color's dark level
*/
static void dacP98FillChannelDarkLevelControl( pScanData ps )
{
DataPointer p;
ULong dwPos, dw, dwSum;
if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
dwPos = 0x10 * 3;
} else {
dwPos = 0x20 * 2;
}
for (p.pw = (pUShort)(ps->pScanBuffer1 + dwPos), dwSum = 0, dw = 16;
dw; dw--, p.pw++) {
dwSum += (ULong)(*p.pw);
}
ps->Shade.DarkOffset.Colors.Red = (UShort)(dwSum / 16);
for (p.pw = (pUShort)(ps->pScanBuffer1 + dwPos + 1024), dwSum = 0, dw = 16;
dw; dw--, p.pw++) {
dwSum += (ULong)(*p.pw);
}
ps->Shade.DarkOffset.Colors.Green = (UShort)(dwSum / 16);
for (p.pw = (pUShort)(ps->pScanBuffer1 + dwPos + 1024 * 2), dwSum = 0, dw = 16;
dw; dw--, p.pw++) {
dwSum += (ULong)(*p.pw);
}
ps->Shade.DarkOffset.Colors.Blue = (UShort)(dwSum / 16);
}
/**
*/
static void dacP98AdjustGain( pScanData ps )
{
DataPointer p;
ULong dw;
UShort w;
Byte b[3];
pUChar pbReg[3];
dacP98AdjustGainAverage( ps );
pbReg[0] = &ps->bRedGainIndex;
pbReg[1] = &ps->bGreenGainIndex;
pbReg[2] = &ps->bBlueGainIndex;
for (w = 0, p.pb = ps->pScanBuffer1; w < 3; w++) {
for (dw = 2560 / 16, b [w] = 0; dw; dw--, p.pb++) {
if (b [w] < *p.pb)
b [w] = *p.pb;
}
if (b[w] < _GAIN_LOW) {
if ((_GAIN_P98_HIGH - b[w]) < b[w])
*(pbReg[w]) += 1;
else
*(pbReg[w]) += 4;
} else {
if (b[w] > _GAIN_P98_HIGH)
*(pbReg[w]) -= 1;
}
}
}
/**
*/
static void dacP98CheckLastGain( pScanData ps )
{
DataPointer p;
ULong dw;
UShort w;
Byte b[3];
pUChar pbReg[3];
dacP98AdjustGainAverage( ps );
pbReg[0] = &ps->bRedGainIndex;
pbReg[1] = &ps->bGreenGainIndex;
pbReg[2] = &ps->bBlueGainIndex;
for (w = 0, p.pb = ps->pScanBuffer1; w < 3; w++) {
for (dw = 2560 / 16, b [w] = 0; dw; dw--, p.pb++) {
if (b[w] < *p.pb)
b[w] = *p.pb;
}
if (b[w] > _GAIN_P98_HIGH) {
*(pbReg [w]) -= 1;
}
}
}
/**
*/
static void dacP98FillGainInitialRestRegister( pScanData ps )
{
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegThresholdGapControl, ps->AsicReg.RD_ThresholdGapCtrl );
IODataToRegister( ps, ps->RegModelControl, ps->AsicReg.RD_ModelControl );
ps->CloseScanPath( ps );
}
/**
*/
static void dacP98SetInitialGainRegister( pScanData ps )
{
DacP98FillGainOutDirectPort( ps ); /* R/G/B GainOut to scanner */
dacP98FillGainInitialRestRegister( ps );/* Model Control2, LED, Correct.*/
}
/** Find the the most ideal intensity for each color (RGB)
*/
static void dacP98SetRGBGainRegister( pScanData ps )
{
IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeIdle );
ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE;
IOSelectLampSource( ps );
IOCmdRegisterToScanner( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
dacP98SetInitialGainRegister( ps );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
ps->AsicReg.RD_Motor0Control = _MotorOn + _MotorDirForward + _MotorHEightStep;
ps->AsicReg.RD_XStepTime = ps->bSpeed4;
if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi300;
ps->AsicReg.RD_Origin = 32 + 60 + 4;
} else {
ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi600;
ps->AsicReg.RD_Origin = 64 + 120 + 4;
}
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_Pixels = 2560;
IOPutOnAllRegisters( ps );
}
/**
*/
static void dacP98FillRGBMap( pUChar pBuffer )
{
ULong dw, dw1;
pULong pdw = (pULong)(pBuffer);
for( dw = 256, dw1 = 0; dw; dw--, dw1 += 0x01010101 ) {
*pdw++ = dw1;
*pdw++ = dw1;
*pdw++ = dw1;
*pdw++ = dw1;
}
}
/** here we download the current mapping table
*/
static void dacP98DownloadMapTable( pScanData ps, pUChar pBuffer )
{
Byte bAddr;
ULong i;
IODataToRegister( ps, ps->RegScanControl,
(Byte)((ps->AsicReg.RD_ScanControl & 0xfc) | _SCAN_BYTEMODE));
for( i = 3, bAddr = _MAP_ADDR_RED; i--; bAddr += _MAP_ADDR_SIZE ) {
IODataToRegister( ps, ps->RegModeControl, _ModeMappingMem );
IODataToRegister( ps, ps->RegMemoryLow, 0);
IODataToRegister( ps, ps->RegMemoryHigh, bAddr );
IOMoveDataToScanner( ps, pBuffer, 4096 );
pBuffer += 4096;
}
IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
}
/**
*/
static void dacP98DownloadShadingTable( pScanData ps,
pUChar pBuffer, ULong size )
{
IODataToRegister( ps, ps->RegModeControl, _ModeShadingMem );
IODataToRegister( ps, ps->RegMemoryLow, 0 );
IODataToRegister( ps, ps->RegMemoryHigh, 0 );
/* set 12 bits output color */
IODataToRegister( ps, ps->RegScanControl,
(Byte)(ps->AsicReg.RD_ScanControl | _SCAN_12BITMODE));
/* MoveDataToShadingRam() */
IOMoveDataToScanner( ps ,pBuffer, size );
if( _ASIC_IS_98003 == ps->sCaps.AsicID )
IODataToRegister( ps, ps->RegModeControl, _ModeScan );
else
IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
DacP98FillShadingDarkToShadingRegister( ps );
}
/** Build a linear map for asic (this model is 12-bit scanner, there are 4096
* map entries but just generate 256 level output, so the content must be 0 to
* 255), then fill the shading buffer (the first 3k), and map table (the last
* 1k) to asic for R & G & B channels.
*
* I need pScanBuffer2 size = 5400 * 2 * 3
* pScanBuffer1 size = 256 * 16 * 2
*/
static void dacP98SetInitialGainRAM( pScanData ps )
{
memset( ps->pScanBuffer2, 0xff, (5400 * 2 * 3));
dacP98DownloadShadingTable( ps, ps->pScanBuffer2, (5400 * 2 * 3));
dacP98FillRGBMap( ps->pScanBuffer1 ); /* Fill 12 Bits R Map */
dacP98FillRGBMap( ps->pScanBuffer1 + 4096 ); /* Fill 12 Bits G Map */
dacP98FillRGBMap( ps->pScanBuffer1 + 8192 ); /* Fill 12 Bits B Map */
dacP98DownloadMapTable( ps, ps->pScanBuffer1 );
}
/** Find the the most ideal intensity for each color (RGB)
*/
static void dacP98AdjustRGBGain( pScanData ps )
{
int bCorrectTimes;
DBG( DBG_LOW, "dacP98AdjustRGBGain()\n" );
ps->OpenScanPath( ps );
dacP98SetInitialGainRAM( ps ); /* set shading ram and read out data to */
ps->CloseScanPath( ps );
ps->bRedGainIndex = 0x02;
ps->bGreenGainIndex = 0x02;
ps->bBlueGainIndex = 0x02;
for (bCorrectTimes = 10; bCorrectTimes; bCorrectTimes-- ) {
dacP98SetRGBGainRegister( ps ); /* shading the most brightness &*/
ps->PauseColorMotorRunStates( ps ); /* stop scan states */
IOReadOneShadingLine( ps, ps->pScanBuffer1, 2560UL );
dacP98AdjustGain( ps );
}
dacP98SetRGBGainRegister( ps ); /* shading the most brightness & */
ps->PauseColorMotorRunStates( ps ); /* stop scan states */
IOReadOneShadingLine( ps, ps->pScanBuffer1, 2560UL );
dacP98CheckLastGain( ps );
DacP98FillGainOutDirectPort( ps );
}
/**
*/
static void dacP98SetAdjustShadingRegister( pScanData ps )
{
DBG( DBG_LOW, "dacP98SetAdjustShadingRegister()\n" );
IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeIdle );
ps->AsicReg.RD_ScanControl = _SCAN_12BITMODE + _SCAN_1ST_AVERAGE;
IOSelectLampSource( ps );
IOCmdRegisterToScanner( ps, ps->RegScanControl,
ps->AsicReg.RD_ScanControl );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_Motor0Control = _MotorOn + _MotorHEightStep + _MotorDirForward;
ps->AsicReg.RD_XStepTime = ps->bSpeed1;
ps->AsicReg.RD_ModelControl = _LED_ACTIVITY + _LED_CONTROL;
if (ps->bSetScanModeFlag & _ScanMode_AverageOut) {
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_Pixels = 2700;
ps->AsicReg.RD_ModelControl += _ModelDpi300;
} else {
ps->AsicReg.RD_Dpi = 600;
ps->AsicReg.RD_Pixels = 5400;
ps->AsicReg.RD_ModelControl += _ModelDpi600;
}
ps->AsicReg.RD_Origin = 4;
IOPutOnAllRegisters( ps );
}
/**
*/
static void dacP98ReadShadingScanLine( pScanData ps )
{
TimerDef timer;
MiscStartTimer( &timer, _SECOND );
ps->Scan.bFifoSelect = ps->RegGFifoOffset;
while((IOReadFifoLength( ps ) < dwReadyLen) &&
!MiscCheckTimer(&timer)) {
_DO_UDELAY( 1 );
}
IOReadColorData( ps, ps->pScanBuffer2, ps->dwShadingLen );
}
/**
*/
static void dacP98GainResize( pUShort pValue, UShort wResize)
{
DataType Data;
Byte bTemp;
Data.dwValue = ((ULong) *pValue) * (ULong) wResize / 100;
if (0x1000 <= Data.dwValue)
Data.wValue = 0xfff;
Data.wValue *= 16;
bTemp = Data.wOverlap.b1st;
Data.wOverlap.b1st = Data.wOverlap.b2nd;
Data.wOverlap.b2nd = bTemp;
*pValue = Data.wValue;
}
/**
*/
static void dacP98SortHilightShadow( pScanData ps, pUShort pwData,
ULong dwHilightOff, ULong dwShadowOff )
{
ULong dwLines, dwPixels;
UShort wVCmp, wTmp;
pUShort pw;
for (dwPixels = 0; dwPixels < (ps->dwShadingPixels - 4); dwPixels++) {
pw = (pUShort)ps->Shade.pHilight + dwHilightOff + dwPixels;
wVCmp = pwData[dwPixels] & 0xfffU;
for (dwLines = _DEF_BRIGHTEST_SKIP; dwLines--; pw += 5400UL) {
if (wVCmp > *pw) {
wTmp = wVCmp;
wVCmp = *pw;
*pw = wTmp;
}
}
}
for (dwPixels = 0; dwPixels < (ps->dwShadingPixels - 4); dwPixels++) {
pw = ps->pwShadow + dwShadowOff + dwPixels;
wVCmp = pwData [dwPixels] & 0xfffU;
for (dwLines = _DEF_DARKEST_SKIP; dwLines--; pw += 5400UL) {
if (wVCmp < *pw) {
wTmp = wVCmp;
wVCmp = *pw;
*pw = wTmp;
}
}
}
}
/**
*/
static void dacP98WriteBackToShadingRAM( pScanData ps )
{
ULong dw;
pUShort pBuffer = (pUShort)ps->pScanBuffer2;
DBG( DBG_LOW, "dacP98WriteBackToShadingRAM()\n" );
if (ps->DataInf.wPhyDataType >= COLOR_TRUE24) {
for (dw = 0; dw < 5400; dw++) {
*pBuffer = ((pUShort)ps->pScanBuffer1)[dw] -
ps->Shade.DarkOffset.Colors.Red;
dacP98GainResize( pBuffer,
ps->Shade.pCcdDac->GainResize.Colors.Red );
pBuffer ++;
*pBuffer = ((pUShort)ps->pScanBuffer1)[dw + 5400] -
ps->Shade.DarkOffset.Colors.Green;
dacP98GainResize( pBuffer,
ps->Shade.pCcdDac->GainResize.Colors.Green );
pBuffer ++;
*pBuffer = ((pUShort)ps->pScanBuffer1)[dw + 5400 * 2] -
ps->Shade.DarkOffset.Colors.Blue;
dacP98GainResize( pBuffer,
ps->Shade.pCcdDac->GainResize.Colors.Blue );
pBuffer ++;
}
} else {
for (dw = 0; dw < 5400; dw++) {
DataType Data;
Byte bTemp;
*pBuffer = ((pUShort)ps->pScanBuffer1)[dw + 5400] -
ps->Shade.DarkOffset.Colors.Green;
Data.wValue = (*pBuffer) * 16;
bTemp = Data.wOverlap.b1st;
Data.wOverlap.b1st = Data.wOverlap.b2nd;
Data.wOverlap.b2nd = bTemp;
*pBuffer = Data.wValue;
pBuffer++;
}
}
dacP98DownloadShadingTable( ps, ps->pScanBuffer2, (5400 * 2 * 3));
}
/**
*/
static void dacP98ShadingRunLoop( pScanData ps )
{
int i;
DataPointer p;
p.pb = ps->a_nbNewAdrPointer;
switch( ps->IO.portMode ) {
case _PORT_SPP:
case _PORT_BIDI:
*p.pw++ = 0;
for (i = 0; i < 7; i++)
*p.pdw++ = 0x00800700;
*p.pw = 0;
break;
default:
*p.pb++ = 0;
for (i = 0; i < 15; i++)
*p.pw++ = 0xf888;
*p.pb = 0;
}
IOSetToMotorRegister( ps );
}
/**
*/
static void dacP98Adjust12BitShading( pScanData ps )
{
DataPointer pd, pt;
ULong dw, dw1, dwLoop;
DBG( DBG_LOW, "dacP98Adjust12BitShading()\n" );
memset( ps->pScanBuffer1, 0, (5400 * 4 * 3));
if( ps->Shade.pHilight && (_Shading_32Times == ps->bShadingTimeFlag)) {
memset( ps->Shade.pHilight, 0, (ps->dwHilight * 2UL));
for (dw = 0; dw < ps->dwShadow; dw++)
ps->pwShadow[dw] = 0xfff;
}
/*
* in the original code this function does not exist !
* (of course the code behind the function does ;-)
*/
dacP98SetAdjustShadingRegister( ps );
dacP98ShadingRunLoop( ps );
_DODELAY( 24 );
if ((ps->DataInf.dwScanFlag & SCANDEF_TPA ) ||
(_Shading_32Times == ps->bShadingTimeFlag)) {
dwLoop = 32;
} else {
if (_Shading_16Times == ps->bShadingTimeFlag) {
dwLoop = 16;
} else {
dwLoop = 4;
}
}
for (dw1 = 0; dw1 < dwLoop; dw1++) {
ps->Scan.bFifoSelect = ps->RegGFifoOffset;
dacP98ReadShadingScanLine( ps );
if((_Shading_32Times == ps->bShadingTimeFlag) && ps->Shade.pHilight ) {
dacP98SortHilightShadow( ps, (pUShort)ps->pScanBuffer2, 0, 0 );
dacP98SortHilightShadow( ps, (pUShort)ps->pScanBuffer2 +
ps->dwShadingPixels,
ps->dwHilightCh, ps->dwShadowCh );
dacP98SortHilightShadow( ps, (pUShort)ps->pScanBuffer2 +
ps->dwShadingPixels * 2,
ps->dwHilightCh * 2, ps->dwShadowCh * 2);
}
/* SumAdd12BitShadingR */
pd.pw = (pUShort)ps->pScanBuffer2;
pt.pdw = (pULong)(ps->pScanBuffer1 + dwADCPipeLine);
for (dw = 5400 - 4; dw; dw--, pd.pw++, pt.pdw++)
*pt.pdw += (ULong)(*pd.pw & 0x0fff);
/* SumAdd10BitShadingG */
if( ps->bSetScanModeFlag & _ScanMode_AverageOut )
pd.pw = (pUShort)(ps->pScanBuffer2 + 2700 * 2);
else
pd.pw = (pUShort)(ps->pScanBuffer2 + 5400 * 2);
pt.pdw = (pULong)(ps->pScanBuffer1 + 5400 * 4 + dwADCPipeLine);
for (dw = 5400 - 4; dw; dw--, pd.pw++, pt.pdw++)
*pt.pdw += (ULong)(*pd.pw & 0x0fff);
/* SumAdd12BitShadingB */
if( ps->bSetScanModeFlag & _ScanMode_AverageOut )
pd.pw = (pUShort)(ps->pScanBuffer2 + 2700 * 4);
else
pd.pw = (pUShort)(ps->pScanBuffer2 + 5400 * 4);
pt.pdw = (pULong)(ps->pScanBuffer1 + 5400 * 8 + dwADCPipeLine);
for (dw = 5400 - 4; dw; dw--, pd.pw++, pt.pdw++)
*pt.pdw += (ULong)(*pd.pw * 94 / 100 & 0x0fff);
/* one line */
if (IOReadFifoLength( ps ) <= 2500)
IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
}
TPAP98001AverageShadingData( ps );
ps->OpenScanPath( ps );
dacP98WriteBackToShadingRAM( ps );
ps->CloseScanPath( ps );
}
/**
*/
static Bool dacP98WaitForShading( pScanData ps )
{
Byte oldLineControl;
DBG( DBG_LOW, "dacP98WaitForShading()\n" );
/*
* before getting the shading data, (re)init the ASIC
*/
ps->InitialSetCurrentSpeed( ps );
ps->ReInitAsic( ps, _TRUE );
IOCmdRegisterToScanner( ps, ps->RegLineControl,
ps->AsicReg.RD_LineControl );
ps->Shade.DarkOffset.Colors.Red = 0;
ps->Shade.DarkOffset.Colors.Green = 0;
ps->Shade.DarkOffset.Colors.Blue = 0;
/*
* according to the scan mode, switch on the lamp
*/
IOSelectLampSource( ps );
IOCmdRegisterToScanner(ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi300;
} else {
ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi600;
}
IOCmdRegisterToScanner( ps, ps->RegModelControl,
ps->AsicReg.RD_ModelControl );
IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeScan);
oldLineControl = ps->AsicReg.RD_LineControl;
IOSetXStepLineScanTime( ps, _DEFAULT_LINESCANTIME );
/* set line control */
IOCmdRegisterToScanner( ps, ps->RegLineControl,
ps->AsicReg.RD_LineControl );
/* Wait for Sensor to position */
if( !ps->GotoShadingPosition( ps ))
return _FALSE;
ps->AsicReg.RD_LineControl = oldLineControl;
IOCmdRegisterToScanner( ps, ps->RegLineControl,
ps->AsicReg.RD_LineControl );
dwADCPipeLine = 4 * 4;
if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
dwReadyLen = 2500;
ps->dwShadingLen = 2700 * 2;
ps->dwShadingPixels = 2700;
} else {
dwReadyLen = 5000;
ps->dwShadingLen = 5400 * 2;
ps->dwShadingPixels = 5400;
}
dacP98AdjustRGBGain ( ps );
DacP98AdjustDark ( ps );
dacP98Adjust12BitShading( ps );
ps->OpenScanPath( ps );
DacP98FillShadingDarkToShadingRegister( ps );
if ( COLOR_BW != ps->DataInf.wPhyDataType )
dacP98DownloadMapTable( ps, ps->a_bMapTable );
ps->CloseScanPath( ps );
return _TRUE;
}
/** Set RAM bank and size, then write the data to it
*/
static void dacP96FillWhole4kRAM( pScanData ps, pUChar pBuf )
{
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegMemAccessControl,
ps->Asic96Reg.RD_MemAccessControl );
ps->AsicReg.RD_ModeControl = _ModeProgram;
IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
IOMoveDataToScanner( ps, pBuf, ps->ShadingBankSize );
ps->AsicReg.RD_ModeControl = _ModeScan;
IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
ps->CloseScanPath( ps );
}
/**
*/
static void dacP96FillChannelDarkOffset( pScanData ps )
{
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegRedChDarkOffset,
ps->Asic96Reg.RD_RedChDarkOff );
IODataToRegister( ps, ps->RegGreenChDarkOffset,
ps->Asic96Reg.RD_GreenChDarkOff );
IODataToRegister( ps, ps->RegBlueChDarkOffset,
ps->Asic96Reg.RD_BlueChDarkOff );
ps->CloseScanPath( ps );
}
/**
*/
static void dacP96FillEvenOddControl( pScanData ps )
{
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegRedChEvenOffset,
ps->Asic96Reg.RD_RedChEvenOff );
IODataToRegister( ps, ps->RegGreenChEvenOffset,
ps->Asic96Reg.RD_GreenChEvenOff );
IODataToRegister( ps, ps->RegBlueChEvenOffset,
ps->Asic96Reg.RD_BlueChEvenOff );
IODataToRegister( ps, ps->RegRedChOddOffset,
ps->Asic96Reg.RD_RedChOddOff );
IODataToRegister( ps, ps->RegGreenChOddOffset,
ps->Asic96Reg.RD_GreenChOddOff );
IODataToRegister( ps, ps->RegBlueChOddOffset,
ps->Asic96Reg.RD_BlueChOddOff );
ps->CloseScanPath( ps );
}
/** Used for capture data to pScanData->pPrescan16.
* Used to replace:
* 1) ReadFBKScanLine (3 * 1024, 5)
* 2) ReadOneScanLine (3 * 2560, 11)
* 4) ReadShadingScanLine (3 * 1280, 6)
*/
static void dacP96ReadDataWithinOneSecond( pScanData ps,
ULong dwLen, Byte bBlks )
{
TimerDef timer;
MiscStartTimer( &timer, _SECOND );
while((IODataRegisterFromScanner( ps, ps->RegFifoOffset) < bBlks) &&
!MiscCheckTimer(&timer));
IOReadScannerImageData( ps, ps->pPrescan16, dwLen );
}
/**
*/
static void dacP96GetEvenOddOffset( pUChar pb, pWordVal pwv )
{
ULong dw;
UShort we, wo;
for (dw = 8, we = wo = 0; dw; dw-- ) {
we += *pb++;
wo += *pb++;
}
pwv->b1st = (Byte)(we >> 3);
pwv->b2nd = (Byte)(wo >> 3);
}
/**
*/
static void dacP96SumAverageShading( pScanData ps, pUChar pDest, pUChar pSrce )
{
ULong dw;
UShort wLeft[6];
UShort wSumL, wSumR;
pSrce += ps->Offset70 + ps->Device.DataOriginX;
pDest += ps->Offset70 + ps->Device.DataOriginX;
wLeft[0] = wLeft[1] = wLeft[2] =
wLeft[3] = wLeft[4] = wLeft[5] = (UShort)*pSrce;
wSumL = wLeft[0] * 6;
wSumR = (UShort)pSrce[1] + pSrce[2] + pSrce[3] + pSrce[4] +
pSrce[5] + pSrce[6];
/* for (dw = 2772; dw; dw--, pSrce++, pDest++) */
for (dw = ps->BufferSizePerModel - 6; dw; dw--, pSrce++, pDest++) {
*pDest = (Byte)(((UShort)*pSrce * 4 + wSumL + wSumR) / 16);
wSumL = wSumL - wLeft [0] + (UShort)*pSrce;
wLeft[0] = wLeft[1];
wLeft[1] = wLeft[2];
wLeft[2] = wLeft[3];
wLeft[3] = wLeft[4];
wLeft[4] = wLeft[5];
wLeft[5] = (UShort)*pSrce;
wSumR = wSumR - (UShort) *(pSrce + 1) + (UShort) *(pSrce + 7);
}
}
/**
*/
static void dacP96WriteLinearGamma( pScanData ps,
pUChar pBuf, ULong dwEntries, Byte bBank )
{
ULong dw;
pULong pdw = (pULong)(pBuf + ps->ShadingBufferSize);
for (dw = 0; dwEntries; pdw++, dwEntries--, dw += 0x01010101)
*pdw = dw;
ps->Asic96Reg.RD_MemAccessControl = bBank;
dacP96FillWhole4kRAM( ps, pBuf );
}
/**
*/
static void dacP96FillChannelShadingOffset( pScanData ps )
{
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegRedChShadingOffset,
ps->Asic96Reg.u28.RD_RedChShadingOff);
IODataToRegister( ps, ps->RegGreenChShadingOffset,
ps->Asic96Reg.u29.RD_GreenChShadingOff);
IODataToRegister( ps, ps->RegBlueChShadingOffset,
ps->Asic96Reg.RD_BlueChShadingOff);
ps->CloseScanPath( ps );
}
/**
*/
static void dacP96GetHilightShadow( pScanData ps,
pUChar pBuf, pUChar pChOff, pUChar pHigh )
{
ULong dw;
/* GetShadingImageExtent (ps) */
if (ps->DataInf.wAppDataType < COLOR_256GRAY)
dw = (ULong)(ps->DataInf.crImage.cx & 0xfff8);
else
dw = (ULong)ps->DataInf.crImage.cx;
for( pBuf += ps->DataInf.crImage.x, *pChOff = 0xff, *pHigh = 0;
dw; dw--, pBuf++ ) {
if (*pChOff < *pBuf) {
if (*pHigh < *pBuf)
*pHigh = *pBuf; /* brightest */
} else
*pChOff = *pBuf; /* darkest */
}
}
/**
*/
static void dacP96ReadColorShadingLine( pScanData ps )
{
Byte b2ndDiscard, b3rdDiscard, b1stReadLines, b2ndReadLines;
Byte b3rdReadLines;
ULong dw;
DataType Data;
/* ClearScanBuffer1 (ps) */
/* buffer to keep sum of data */
memset( ps->pScanBuffer1, 0, ps->BufferForDataRead1 );
b2ndDiscard = ps->b2ndLinesOffset;
b3rdDiscard = ps->b1stLinesOffset;
b1stReadLines = b2ndReadLines = b3rdReadLines = 8;
while( _TRUE ) {
/* ReadShadingScanLine(ps) */
dacP96ReadDataWithinOneSecond( ps, ps->ShadingScanLineLen,
ps->ShadingScanLineBlks );
if (b1stReadLines) {
b1stReadLines--;
/* SumAdd10BitShadingR */
for (dw = 0; dw < ps->BufferSizeBase; dw++)
((pUShort)ps->pScanBuffer1)[dw] += (UShort)ps->pPrescan16 [dw];
}
if (!b2ndDiscard) {
if (b2ndReadLines) {
b2ndReadLines--;
/* SumAdd10BitShadingG */
for (dw = ps->BufferSizeBase;dw < (ULong)ps->BufferSizeBase * 2;dw++) {
((pUShort)ps->pScanBuffer1)[dw] +=
(UShort)ps->pPrescan16[dw];
}
}
} else
b2ndDiscard--;
if (!b3rdDiscard) {
if (b3rdReadLines) {
b3rdReadLines--;
/* SumAdd10BitShadingB */
for (dw = ps->BufferSizeBase * 2;
dw < (ULong)ps->BufferSizeBase * 3; dw++) {
((pUShort)ps->pScanBuffer1)[dw] +=
(UShort)ps->pPrescan16[dw];
}
} else
break;
} else
b3rdDiscard--;
IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
}
for (dw = 0; dw < (ULong)ps->BufferSizeBase * 3; dw++) {
Data.wOverlap.b1st =
Data.wOverlap.b2nd = (Byte)(((pUShort)ps->pScanBuffer1)[dw] / 8);
((pUShort)ps->pPrescan16)[dw] = Data.wValue;
}
}
/**
*/
static void dacP96SetShadingGainProc( pScanData ps, Byte bHigh, ULong dwCh )
{
Byte bDark, bGain, bGainX2, bGainX4, bMask;
pUChar pbChDark, pbSrce, pbDest;
ULong dw;
pbChDark = NULL, pbSrce = NULL, pbDest = NULL;
bDark = 0, bGain = 0, bGainX2 = 0, bGainX4 = 0, bMask = 0;
switch( dwCh ) {
case 0: /* red */
pbChDark = &ps->Asic96Reg.u28.RD_RedChShadingOff;
pbSrce = ps->pPrescan16;
pbDest = ps->pScanBuffer1 + ps->Offset70 + ps->Device.DataOriginX;
bGainX2 = 1;
bGainX4 = 3;
bMask = 0x3c;
break;
case 1: /* green */
pbChDark = &ps->Asic96Reg.u29.RD_GreenChShadingOff;
pbSrce = ps->pPrescan16 + ps->BufferSizePerModel;
pbDest = ps->pScanBuffer1 + ps->Offset70 + ps->ShadingBankSize +
ps->Device.DataOriginX;
bGainX2 = 4;
bGainX4 = 0x0c;
bMask = 0x33;
break;
case 2:
pbChDark = &ps->Asic96Reg.RD_BlueChShadingOff;
pbSrce = ps->pPrescan16 + ps->BufferSizePerModel * 2;
pbDest = ps->pScanBuffer1 + ps->Offset70 + ps->ShadingBankSize * 2 +
ps->Device.DataOriginX;
bGainX2 = 0x10;
bGainX4 = 0x30;
bMask = 0x0f;
}
bDark = *pbChDark;
if ((bHigh -= bDark) > 60U) {
/* Hilight - Shadow > 60, Quality not so good */
bGain = bGainX2; /* Gain x 2 */
if (bHigh > 120U)
bGain = bGainX4; /* Poor quality, Gain x 4 */
} else
bGain = 0;
ps->Asic96Reg.RD_ShadingCorrectCtrl &= bMask;
ps->Asic96Reg.RD_ShadingCorrectCtrl |= bGain;
if (!bGain) {
/* GammaGain1 (ps) */
for (dw = ps->BufferSizePerModel; dw; dw--, pbSrce++, pbDest++)
if (*pbSrce > bDark)
*pbDest = (*pbSrce - bDark) * 4;
else
*pbDest = 0;
} else
if (bGain == bGainX2) {
/* GammaGain2 */
for (dw = ps->BufferSizePerModel; dw; dw--, pbSrce++, pbDest++)
if (*pbSrce > bDark)
*pbDest = (*pbSrce - bDark) * 2;
else
*pbDest = 0;
} else {
/* GammaGain4 (ps) */
memcpy( pbDest, pbSrce, ps->BufferSizePerModel );
*pbChDark = 0;
}
}
/**
*/
static void dacP96FillShadingAndGammaTable( pScanData ps )
{
ps->Asic96Reg.RD_MemAccessControl = ps->ShadingBankRed; /* R */
dacP96FillWhole4kRAM( ps, ps->pPrescan16 );
ps->Asic96Reg.RD_MemAccessControl = ps->ShadingBankGreen; /* G */
dacP96FillWhole4kRAM( ps, ps->pPrescan16 );
ps->Asic96Reg.RD_MemAccessControl = ps->ShadingBankBlue; /* B */
dacP96FillWhole4kRAM( ps, ps->pPrescan16 );
}
/**
*/
static void dacP96SetInitialGainRAM( pScanData ps )
{
ULong dw, dw1;
pULong pdw = (pULong)(ps->pPrescan16 + ps->ShadingBufferSize);
memset( ps->pPrescan16, 0xff, ps->ShadingBufferSize );
for (dw = 256, dw1 = 0; dw; dw--, dw1 += 0x01010101, pdw++)
*pdw = dw1;
dacP96FillShadingAndGammaTable( ps );
}
/**
*/
static void dacP96Adjust10BitShading( pScanData ps )
{
pULong pdw;
ULong dw;
Byte bRedHigh, bGreenHigh, bBlueHigh;
/* ShadingMotorRunLoop(ps)
* set scan states as:
* 40h, 00, 00, 00, 40h, 01, 03, 02, ... (repeat)
* so, read a R/G/B line every 2 steps
*/
pdw = (pULong)ps->a_nbNewAdrPointer;
for (dw = 0; dw < 4; dw++) {
*pdw++ = 0x40;
*pdw++ = 0x02030140;
}
dacP96SetInitialGainRAM( ps); /* initiates the shading buffers and maps */
/* SetAdjustShadingRegister(ps) */
/* Prepare Physical/2 dpi, 8.5" scanning condition for reading the shading area */
ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
ps->Asic96Reg.RD_MotorControl = ps->IgnorePF | ps->MotorOn |
_MotorDirForward;
ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
ps->AsicReg.RD_Dpi = ps->PhysicalDpi / 2;
ps->AsicReg.RD_Origin = (UShort)(ps->Offset70 +
ps->Device.DataOriginX);
ps->AsicReg.RD_Pixels = ps->BufferSizeBase;
IOPutOnAllRegisters( ps );
ps->Asic96Reg.RD_ShadingCorrectCtrl = _ShadingRCorrectX4|_ShadingGCorrectX4|
_ShadingBCorrectX4;
IOCmdRegisterToScanner( ps, ps->RegShadingCorrectCtrl,
ps->Asic96Reg.RD_ShadingCorrectCtrl );
/* Read shaded data and do average */
dacP96ReadColorShadingLine( ps );
/* ExpandAndAverage (ps) ------------------------------------------------*/
/*
for (dw = 0; dw < 1280 * 3; dw++)
{
Data.wOverlap.b1st =
Data.wOverlap.b2nd = (Byte)(((pUShort) ps->pScanBuffer1)[dw] / 8);
((pULong) ps->pPrescan16)[dw] = Data.wValue;
}
*/
/* CalculateShadingOffset (ps); */
dacP96GetHilightShadow( ps, ps->pPrescan16,
&ps->Asic96Reg.u28.RD_RedChShadingOff, &bRedHigh );
dacP96GetHilightShadow( ps, ps->pPrescan16 + ps->BufferSizePerModel,
&ps->Asic96Reg.u29.RD_GreenChShadingOff, &bGreenHigh );
dacP96GetHilightShadow( ps, ps->pPrescan16 + ps->BufferSizePerModel * 2,
&ps->Asic96Reg.RD_BlueChShadingOff, &bBlueHigh );
/* SubTheImageDataBase (ps) */
dacP96SetShadingGainProc( ps, bRedHigh, 0 ); /* red */
dacP96SetShadingGainProc( ps, bGreenHigh, 1 ); /* green */
dacP96SetShadingGainProc( ps, bBlueHigh, 2 ); /* blue */
dacP96FillChannelShadingOffset( ps );
IOCmdRegisterToScanner( ps, ps->RegShadingCorrectCtrl,
ps->Asic96Reg.RD_ShadingCorrectCtrl );
dacP96SumAverageShading( ps, ps->pPrescan16, ps->pScanBuffer1 );
dacP96SumAverageShading( ps, ps->pPrescan16 + ps->ShadingBankSize,
ps->pScanBuffer1 + ps->ShadingBankSize );
dacP96SumAverageShading( ps, ps->pPrescan16 + ps->ShadingBankSize * 2,
ps->pScanBuffer1 + ps->ShadingBankSize * 2 );
/* --------------------------------------------------------------------- */
/* PrewriteBackToGammaShadingRAM( ps) */
dacP96WriteLinearGamma( ps, ps->pPrescan16, 256, ps->ShadingBankRed );
dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize, 256,
ps->ShadingBankGreen );
dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize * 2,
256, ps->ShadingBankBlue );
}
/**
*/
static Bool dacP96003WaitForShading( pScanData ps )
{
int bCorrectTimes;
DataPointer p;
ULong dw;
UShort w;
WordVal wv;
pUChar pbReg[3];
Byte b[3];
DBG( DBG_LOW, "dacP96003WaitForShading()\n" );
/* TurnOnLamp () */
ps->AsicReg.RD_ScanControl |= ps->bLampOn;
IOCmdRegisterToScanner(ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
ps->Asic96Reg.RD_LedControl = _LedActControl | _LedMotorActEnable;
IOCmdRegisterToScanner(ps, ps->RegLedControl, ps->Asic96Reg.RD_LedControl);
if ( ps->GotoShadingPosition( ps )) {
/* AdjustRGBGain () =================================================*/
ps->Asic96Reg.RD_RedGainOut = ps->Asic96Reg.RD_GreenGainOut =
ps->Asic96Reg.RD_BlueGainOut = 8;
ps->Asic96Reg.u26.RD_ModelControl2 = _Model2DirectOutPort;
IOCmdRegisterToScanner(ps, ps->RegModelControl2, _Model2DirectOutPort);
for ( bCorrectTimes = 4; bCorrectTimes >= 1; bCorrectTimes-- ) {
ps->PauseColorMotorRunStates( ps );
/* SetRGBGainRegister () ----------------------------------------*/
ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
dacP96SetInitialGainRAM( ps );
/* SetInitialGainRegister () ++++++++++++++++++++++++++++++++++++*/
ps->Asic96Reg.u28.RD_RedChShadingOff =
ps->Asic96Reg.u29.RD_GreenChShadingOff =
ps->Asic96Reg.RD_BlueChShadingOff =
ps->Asic96Reg.RD_RedChDarkOff =
ps->Asic96Reg.RD_GreenChDarkOff =
ps->Asic96Reg.RD_BlueChDarkOff =
ps->Asic96Reg.RD_RedChEvenOff =
ps->Asic96Reg.RD_GreenChEvenOff =
ps->Asic96Reg.RD_BlueChEvenOff =
ps->Asic96Reg.RD_RedChOddOff =
ps->Asic96Reg.RD_GreenChOddOff =
ps->Asic96Reg.RD_BlueChOddOff = 0;
ps->Asic96Reg.RD_ShadingCorrectCtrl = _ShadingRCorrectX4 |
_ShadingGCorrectX4 |
_ShadingBCorrectX4;
dacP96FillChannelShadingOffset( ps );
dacP96FillChannelDarkOffset( ps );
dacP96FillEvenOddControl( ps );
/* FillGainOutDirectPort (); */
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegRedGainOutDirect,
ps->Asic96Reg.RD_RedGainOut );
IODataToRegister( ps, ps->RegGreenGainOutDirect,
ps->Asic96Reg.RD_GreenGainOut );
IODataToRegister( ps, ps->RegBlueGainOutDirect,
ps->Asic96Reg.RD_BlueGainOut );
/* FillGainInitialRestRegister (); */
IODataToRegister( ps, ps->RegModelControl2,
ps->Asic96Reg.u26.RD_ModelControl2 );
IODataToRegister( ps, ps->RegThresholdGapControl,
ps->AsicReg.RD_ThresholdGapCtrl );
IODataToRegister( ps, ps->RegLedControl,
ps->Asic96Reg.RD_LedControl );
IODataToRegister( ps, ps->RegShadingCorrectCtrl,
ps->Asic96Reg.RD_ShadingCorrectCtrl );
ps->CloseScanPath( ps );
ps->Asic96Reg.RD_MotorControl = 0;
IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
ps->Asic96Reg.RD_MotorControl = (ps->IgnorePF |
ps->MotorOn | _MotorDirForward);
ps->AsicReg.RD_Origin = 142;
ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
ps->AsicReg.RD_Dpi = ps->PhysicalDpi;
ps->AsicReg.RD_Pixels = ps->BufferSizePerModel;
IOPutOnAllRegisters( ps );
/*---------------------------------------------------------------*/
/* ReadOneScanLine (); */
dacP96ReadDataWithinOneSecond( ps, ps->OneScanLineLen, 11 );
/* AdjustGain () */
/* FindTheMaxGain (), AdjustGainOutData (); */
pbReg[0] = &ps->Asic96Reg.RD_RedGainOut;
pbReg[1] = &ps->Asic96Reg.RD_GreenGainOut;
pbReg[2] = &ps->Asic96Reg.RD_BlueGainOut;
for (w = 0, p.pb = ps->pPrescan16; w < 3; w++) {
/* CHANGE: org was: for (dw = 2560, b[w] = 0; dw; dw--, p.pb++) { */
for (dw = (ps->OneScanLineLen/3), b[w] = 0; dw; dw--, p.pb++) {
if (b[w] < *p.pb)
b[w] = *p.pb;
}
if (b[w] < _GAIN_LOW)
*(pbReg[w]) += a_bCorrectTimesTable[bCorrectTimes - 1];
else
if (b[w] > _GAIN_P96_HIGH)
*(pbReg[w]) -= a_bCorrectTimesTable[bCorrectTimes - 1];
}
}
/*===================================================================*/
/* SonyFBK ()/ToshibaFBK ()====================================*/
/*FillRGBDarkLevel0Table (); */
memset( ps->pPrescan16, 0xff, ps->ShadingBankSize );
for( dw = 0, p.pb = ps->pPrescan16 + ps->ShadingBufferSize;
dw <=255; dw++, p.pb++ ) {
*p.pb = (Byte) dw;
}
dacP96FillShadingAndGammaTable( ps );
ps->PauseColorMotorRunStates( ps );
/* SetReadFBKRegister () */
ps->Asic96Reg.RD_MotorControl = 0;
IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
ps->Asic96Reg.RD_MotorControl = ps->IgnorePF | ps->MotorOn |
_MotorDirForward;
ps->AsicReg.RD_Origin = 22;
ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
ps->AsicReg.RD_Dpi = ps->PhysicalDpi;
ps->AsicReg.RD_Pixels = ps->FBKScanLineLenBase;
IOPutOnAllRegisters( ps );
/* ReadFBKScanLine () */
dacP96ReadDataWithinOneSecond( ps, ps->FBKScanLineLen,
ps->FBKScanLineBlks );
/*===================================================================*/
if ( ps->fSonyCCD ) {
/* FillChannelDarkLevelControl (); */
for ( p.pb = ps->pPrescan16 + 32, w = 0, dw = 16;
dw; dw--, p.pb++) {
w += (UShort) *p.pb;
}
ps->Asic96Reg.RD_RedChDarkOff = (Byte)(w / 16);
for ( p.pb = ps->pPrescan16 + 32 + ps->FBKScanLineLenBase, w = 0, dw = 16;
dw; dw--, p.pb++ ) {
w += (UShort)*p.pb;
}
ps->Asic96Reg.RD_GreenChDarkOff = (Byte)(w / 16);
for ( p.pb = ps->pPrescan16 + 32 + ps->FBKScanLineLenBase * 2, w = 0, dw = 16;
dw; dw--, p.pb++) {
w += (UShort)*p.pb;
}
ps->Asic96Reg.RD_BlueChDarkOff = (Byte)(w / 16);
dacP96FillChannelDarkOffset( ps );
} else {
/* FillToshibaDarkLevelControl (); */
dacP96GetEvenOddOffset( ps->pPrescan16 + 32, &wv );
ps->Asic96Reg.RD_RedChEvenOff = wv.b1st;
ps->Asic96Reg.RD_RedChOddOff = wv.b2nd;
dacP96GetEvenOddOffset( ps->pPrescan16 + 32 + ps->FBKScanLineLenBase, &wv );
ps->Asic96Reg.RD_GreenChEvenOff = wv.b1st;
ps->Asic96Reg.RD_GreenChOddOff = wv.b2nd;
dacP96GetEvenOddOffset( ps->pPrescan16 + 32 + ps->FBKScanLineLenBase * 2, &wv );
ps->Asic96Reg.RD_BlueChEvenOff = wv.b1st;
ps->Asic96Reg.RD_BlueChOddOff = wv.b2nd;
dacP96FillEvenOddControl( ps );
}
/* SetInitialGainRAM (); */
dacP96Adjust10BitShading( ps );
return _TRUE;
}
return _FALSE;
}
/**
*/
static void dacP96001ToSetShadingAddress( pScanData ps, pUChar pData )
{
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegMemAccessControl,
ps->Asic96Reg.RD_MemAccessControl);
ps->AsicReg.RD_ModeControl = _ModeProgram;
IODataToRegister( ps, ps->RegModeControl, _ModeProgram );
ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
IODataToRegister( ps, ps->RegMotorControl, ps->Asic96Reg.RD_MotorControl);
memset( ps->pScanBuffer1, 0, (64 + 8 + ps->Offset70));
memcpy( ps->pScanBuffer1 + 64 + 8 + ps->Offset70, pData,
_BUF_SIZE_BASE_CONST * 2 );
IOMoveDataToScanner( ps, ps->pScanBuffer1,
_BUF_SIZE_BASE_CONST * 2 + 64 + 8 + ps->Offset70 );
ps->AsicReg.RD_ModeControl = _ModeScan;
IODataToRegister( ps, ps->RegModeControl, _ModeScan );
ps->CloseScanPath( ps );
}
/**
*/
static void dacP96001WriteBackToColorShadingRam( pScanData ps )
{
ps->Asic96Reg.RD_MemAccessControl = (_MemBankSize4k96001 | 0x3a);
dacP96001ToSetShadingAddress( ps, ps->pPrescan16 );
ps->Asic96Reg.RD_MemAccessControl = (_MemBankSize4k96001 | 0x3e);
dacP96001ToSetShadingAddress( ps, ps->pPrescan16 + _BUF_SIZE_BASE_CONST*2);
ps->Asic96Reg.RD_MemAccessControl = (_MemBankSize4k96001 | 0x3c);
dacP96001ToSetShadingAddress( ps, ps->pPrescan16 + _BUF_SIZE_BASE_CONST*4);
}
/**
*/
static void dacP96001ModifyShadingColor( pByte pData, Byte bMul )
{
UShort w;
ULong dw;
for ( dw = 0; dw < _BUF_SIZE_BASE_CONST * 2; dw++ ) {
w = (UShort)(Byte)(~pData[dw]) * bMul / 100U;
if (w >= 255U)
pData[dw] = 0;
else
pData[dw] = (Byte)~w;
}
}
/**
*/
static Byte dacP96001FBKReading( pScanData ps, Byte bValue,
Byte bReg, pByte pbSave, Bool bFBKModify )
{
TimerDef timer;
UShort w, wSum;
Byte addrSeq[8] = { 0x40, 0x20, 0x10, 0x08, 4, 2, 1, 0 };
Byte bTemp, bFBKTemp, bFBKIndex;
if( bFBKModify ) {
bFBKIndex = 3;
bFBKTemp = *pbSave;
} else {
bFBKTemp = 0x80;
bFBKIndex = 0;
}
while( _TRUE ) {
*pbSave = bFBKTemp;
IOCmdRegisterToScanner( ps, bReg, bFBKTemp );
/* SetColorRunTable (BYTE) */
memset( ps->a_nbNewAdrPointer, bValue, _SCANSTATE_BYTES );
MotorSetConstantMove( ps, 0 );
/* SetReadFBK (pScanData) */
ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
ps->Asic96Reg.RD_MotorControl );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE | ps->bLampOn;
ps->AsicReg.RD_ModelControl =
(_ModelMemSize32k96001 | _ModelDpi300 | _ModelWhiteIs0 );
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_Origin = 22;
ps->AsicReg.RD_Pixels = 1024;
IOPutOnAllRegisters( ps );
ps->Asic96Reg.RD_MotorControl =
(ps->FullStep | ps->MotorOn | _MotorDirForward);
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
ps->Asic96Reg.RD_MotorControl );
MiscStartTimer( &timer, _SECOND );
while((IODataRegisterFromScanner( ps, ps->RegFifoOffset) < 1) &&
!MiscCheckTimer( &timer ));
IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
IOReadScannerImageData( ps, ps->pScanBuffer1, 64 );
for( w = 26, wSum = 0; w < 42; w++)
wSum += ps->pScanBuffer1[w];
wSum >>= 4;
bTemp = addrSeq[bFBKIndex++];
if( bTemp ) {
if( wSum < 0xfe )
bFBKTemp += bTemp;
else
bFBKTemp -= bTemp;
} else {
return bFBKTemp;
}
}
}
/**
*/
static Bool dacP96001WaitForShading( pScanData ps )
{
Bool bFBKModify;
Byte bRSave;
Byte bGSave;
Byte bBSave;
ULong dw;
pULong pdw;
DBG( DBG_LOW, "dacP96001WaitForShading()\n" );
ps->AsicReg.RD_ScanControl |= ps->bLampOn;
IOCmdRegisterToScanner(ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
if ( ps->GotoShadingPosition( ps )) {
_DODELAY( 250 );
/* AdjustMostWideOffset70 (pScanData) -------------------------------*/
/* FillABitGray (pScanData)*/
memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
ps->a_nbNewAdrPointer[8] =
ps->a_nbNewAdrPointer[24] = 0x30;
MotorSetConstantMove( ps, 32 );
/* SetMaxWideRegister (pScanData) */
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE | ps->bLampOn;
ps->Asic96Reg.RD_MotorControl =
(ps->MotorOn | ps->IgnorePF | _MotorDirForward);
ps->AsicReg.RD_ModelControl =
(_ModelMemSize32k96001 | _ModelDpi300 | _ModelWhiteIs0);
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_Origin = 64 + 8;
ps->AsicReg.RD_Pixels = 2700;
IOPutOnAllRegisters( ps );
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
ps->Asic96Reg.RD_MotorControl );
/* ReadMaxWideLine */
dacP96ReadDataWithinOneSecond( ps, 2700, 5 );
/* AdjustOffset70Proc (pScanData)------------------------------------*/
{
ULong dwSum, dw, dwLeft, dwCenter;
/* AverageWideBank (pScanData) */
for( dwSum = 0, dw = 0; dw < 2700; dw++ )
dwSum += (ULong)ps->pPrescan16[dw];
dwSum /= 2700UL;
if( dwSum <= 0x80 ) {
memcpy( ps->pScanBuffer1, ps->pPrescan16, 140 );
memcpy( ps->pScanBuffer1 + 140,
ps->pPrescan16 + _BUF_SIZE_BASE_CONST * 2, 140);
/* BlackOffsetCheck (pScanData) */
for( dw = dwLeft = 0; dw < 140; dw++ ) {
if( ps->pScanBuffer1[dw] >= 0xe0 )
dwLeft++;
else
break;
}
/* WhiteOffsetCheck (pScanData) */
for( dw = 140, dwCenter = 0; dw < 280; dw++ ) {
if( ps->pScanBuffer1[dw] < 0xe0 )
dwCenter++;
else
break;
}
if (dwLeft) {
ps->Offset70 = (dwLeft + dwCenter) / 2 + 14;
} else {
if (dwCenter == 140)
ps->Offset70 = 70;
else
ps->Offset70 = dwCenter / 2 + 2;
}
}
}
memset( ps->pPrescan16, 0, ps->BufferSizePerModel * 3 );
dacP96001WriteBackToColorShadingRam( ps );
/* SetFBK */
if((IODataRegisterFromScanner(ps, ps->RegReadIOBufBus) & 0x0f) == 0x0f)
bFBKModify = 0;
else
bFBKModify = 1;
dacP96001FBKReading(ps, 0x10, ps->RegRedDCAdjust, &bRSave,bFBKModify);
dacP96001FBKReading(ps, 0x30, ps->RegGreenDCAdjust,&bGSave,bFBKModify);
dacP96001FBKReading(ps, 0x20, ps->RegBlueDCAdjust, &bBSave,bFBKModify);
ps->OpenScanPath( ps );
IODataToRegister( ps, ps->RegRedDCAdjust, (Byte)(bRSave + 2));
IODataToRegister( ps, ps->RegGreenDCAdjust, (Byte)(bGSave + 2));
IODataToRegister( ps, ps->RegBlueDCAdjust, bBSave);
ps->CloseScanPath( ps );
/* Turn off and then turn on motor */
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
(Byte)(ps->Asic96Reg.RD_MotorControl & ~ps->MotorOn));
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
ps->Asic96Reg.RD_MotorControl );
/* FillABitColor (pScanData) */
pdw = (pULong)ps->a_nbNewAdrPointer;
for( dw = 0; dw < 4; dw++) {
*pdw++ = 0x40;
*pdw++ = 0x2030140;
}
IOSetToMotorRegister( ps );
/* SetShadingRegister (pScanData) */
ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
ps->Asic96Reg.RD_MotorControl );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_LineControl = ps->TimePerLine;
ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE | ps->bLampOn;
ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
ps->AsicReg.RD_ModelControl =
(_ModelMemSize32k96001 | _ModelDpi300 | _ModelWhiteIs0);
ps->AsicReg.RD_Dpi = 150;
ps->AsicReg.RD_Origin = (UShort)(64 + 8 + ps->Offset70);
ps->AsicReg.RD_Pixels = ps->BufferSizeBase;
IOPutOnAllRegisters( ps );
IOCmdRegisterToScanner( ps, ps->RegMotorControl,
(Byte)(ps->MotorOn | ps->IgnorePF | _MotorDirForward));
dacP96ReadColorShadingLine( ps );
/* ModifyShadingColor (pScanData) */
dacP96001ModifyShadingColor( ps->pPrescan16, 103 );
dacP96001ModifyShadingColor( ps->pPrescan16 +
_BUF_SIZE_BASE_CONST * 2 * 2, 97);
dacP96001WriteBackToColorShadingRam( ps );
return _TRUE;
}
return _FALSE;
}
/**
*/
static void dacP98003GainOffsetToDAC( pScanData ps, Byte ch, Byte reg, Byte d )
{
if( ps->Device.bDACType == _DA_SAMSUNG8531 ) {
IODataToRegister( ps, ps->RegADCAddress, 0 );
IODataToRegister( ps, ps->RegADCData, ch );
IODataToRegister( ps, ps->RegADCSerialOutStr, ch);
}
IODataToRegister( ps, ps->RegADCAddress, reg );
IODataToRegister( ps, ps->RegADCData, d );
IODataToRegister( ps, ps->RegADCSerialOutStr, d );
}
/**
*/
static void dacP98003AdjustRGBGain( pScanData ps )
{
ULong i;
Byte bHi[3];
DBG( DBG_LOW, "dacP98003AdjustRGBGain()\n" );
ps->Shade.Gain.Colors.Red =
ps->Shade.Gain.Colors.Green =
ps->Shade.Gain.Colors.Blue = ps->Shade.bUniGain;
ps->Shade.Hilight.Colors.Red =
ps->Shade.Hilight.Colors.Green =
ps->Shade.Hilight.Colors.Blue = 0;
ps->Shade.bGainHigh = _GAIN_P98003_HIGH;
ps->Shade.bGainLow = _GAIN_P98003_LOW;
ps->Shade.fStop = _FALSE;
for( i = 10; i-- && !ps->Shade.fStop; ) {
ps->Shade.fStop = _TRUE;
/* SetRGBGainRegister () */
IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE;
IOSelectLampSource( ps );
IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
DacP98003FillToDAC( ps, &ps->Device.RegDACGain, &ps->Shade.Gain );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
ps->AsicReg.RD_Motor0Control = _FORWARD_MOTOR;
if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
ps->AsicReg.RD_Origin = (UShort)ps->Device.DataOriginX >> 1;
else
ps->AsicReg.RD_Origin = (UShort)ps->Device.DataOriginX;
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_Pixels = 2560;
/* PauseColorMotorRunStates () */
memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
ps->a_nbNewAdrPointer[1] = 0x77;
IOPutOnAllRegisters( ps );
_DODELAY( 70 );
/* read one shading line and work on it */
if( IOReadOneShadingLine( ps, (pUChar)ps->Bufs.b1.pShadingRam, 2560)) {
if ( ps->DataInf.wPhyDataType <= COLOR_256GRAY ) {
bHi[1] = DacP98003SumGains(
(pUChar)ps->Bufs.b1.pShadingRam + 2560, 2560);
if( bHi[1] )
DacP98003AdjustGain( ps, _CHANNEL_GREEN, bHi[1] );
else {
ps->Shade.fStop = _FALSE;
}
} else {
bHi[0] = DacP98003SumGains((pUChar)ps->Bufs.b1.pShadingRam, 2560);
bHi[1] = DacP98003SumGains((pUChar)ps->Bufs.b1.pShadingRam + 2560, 2560);
bHi[2] = DacP98003SumGains((pUChar)ps->Bufs.b1.pShadingRam + 5120, 2560);
if (!bHi[0] || !bHi[1] || !bHi[2] ) {
ps->Shade.fStop = _FALSE;
} else {
DacP98003AdjustGain( ps, _CHANNEL_RED, bHi[0] );
DacP98003AdjustGain( ps, _CHANNEL_GREEN, bHi[1] );
DacP98003AdjustGain( ps, _CHANNEL_BLUE, bHi[2] );
}
}
} else
ps->Shade.fStop = _FALSE;
}
#ifdef DEBUG
if( !ps->Shade.fStop )
DBG( DBG_LOW, "dacP98003AdjustRGBGain() - all loops done!!!\n" );
#endif
DacP98003FillToDAC( ps, &ps->Device.RegDACGain, &ps->Shade.Gain );
}
/**
*/
static UShort dacP98003SumDarks( pScanData ps, pUShort data )
{
UShort i, loop;
if( ps->Device.bCCDID == _CCD_3799 ) {
if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
data += 0x18;
else
data += 0x30;
} else {
if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
data += 0x18;
else
data += 0x20;
}
for( i = 0, loop = 16; loop--; data++ )
i += *data;
i >>= 4;
return i;
}
/**
*/
static void dacP98003AdjustShadingWaveform( pScanData ps )
{
Byte b;
UShort count, wR, wG, wB, tmp;
DataType var;
DataPointer pvar, psum;
RBGPtrDef cp;
pRGBUShortDef pRGB, pwsum;
DBG( DBG_LOW, "dacP98003AdjustShadingWaveForm()\n" );
memset( ps->Bufs.b2.pSumBuf, 0, (5400 * 3 * 2));
/* SetAdjustShadingRegister () */
IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
ps->AsicReg.RD_LineControl = _LOBYTE(ps->Shade.wExposure);
ps->AsicReg.RD_ExtLineControl = _HIBYTE(ps->Shade.wExposure);
IODataToRegister( ps, ps->RegExtendedLineControl,
ps->AsicReg.RD_ExtLineControl );
IODataToRegister( ps, ps->RegLineControl, ps->AsicReg.RD_LineControl );
ps->AsicReg.RD_XStepTime = _LOBYTE(ps->Shade.wExposure);
ps->AsicReg.RD_ExtXStepTime = _HIBYTE(ps->Shade.wExposure);
IODataToRegister( ps, ps->RegExtendedXStep, ps->AsicReg.RD_ExtXStepTime );
IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime );
ps->AsicReg.RD_ModeControl = _ModeScan;
ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
ps->AsicReg.RD_Motor0Control = _FORWARD_MOTOR;
if( ps->Shade.bIntermediate & _ScanMode_AverageOut ) {
ps->AsicReg.RD_Dpi = 300;
ps->AsicReg.RD_Pixels = 2700;
ps->Shade.shadingBytes = 2700 * 2;
} else {
ps->AsicReg.RD_Dpi = 600;
ps->AsicReg.RD_Pixels = 5400;
ps->Shade.shadingBytes = 5400 * 2;
}
ps->AsicReg.RD_Origin = _SHADING_BEGINX;
for( pvar.pdw = (pULong)ps->a_nbNewAdrPointer,
var.dwValue = _SCANSTATE_BYTES >> 2; var.dwValue--; pvar.pdw++) {
*pvar.pdw = 0x00f00080;
}
ps->Scan.fRefreshState = _FALSE;
IOPutOnAllRegisters( ps );
_DODELAY( 55 );
/* SetupHilightShadow () */
if( ps->Shade.pHilight ) {
memset( ps->Shade.pHilight, 0,
ps->Shade.shadingBytes * ps->Shade.skipHilight * 3 );
memset((pUChar)ps->Shade.pHilight +
ps->Shade.shadingBytes * ps->Shade.skipHilight * 3, 0xff,
ps->Shade.shadingBytes * ps->Shade.skipShadow * 3 );
}
for( count = 32; count--;) {
IOReadOneShadingLine( ps,
((pUChar)ps->Bufs.b1.pShadingRam)+_SHADING_BEGINX,
ps->Shade.shadingBytes );
/* SaveHilightShadow() */
if( ps->Shade.pHilight ) {
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
cp.red.usp = ps->Bufs.b1.pShadingRam + _SHADING_BEGINX;
cp.green.usp = cp.red.usp + ps->AsicReg.RD_Pixels;
cp.blue.usp = cp.green.usp + ps->AsicReg.RD_Pixels;
pvar.pusrgb = (pRGBUShortDef)ps->Shade.pHilight +
_SHADING_BEGINX;
for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
pRGB = pvar.pusrgb++;
wR = *cp.red.usp;
wG = *cp.green.usp;
wB = *cp.blue.usp;
for( b = ps->Shade.skipHilight; b--;
pRGB += ps->AsicReg.RD_Pixels) {
if( wR > pRGB->Red ) {
tmp = wR;
wR = pRGB->Red;
pRGB->Red = tmp;
}
if( wG > pRGB->Green ) {
tmp = wG;
wG = pRGB->Green;
pRGB->Green = tmp;
}
if( wB > pRGB->Blue ) {
tmp = wB;
wB = pRGB->Blue;
pRGB->Blue = tmp;
}
}
wR = *cp.red.usp++;
wG = *cp.green.usp++;
wB = *cp.blue.usp++;
for(b = ps->Shade.skipShadow; b--;
pRGB += ps->AsicReg.RD_Pixels) {
if (wR < pRGB->Red) {
tmp = wR;
wR = pRGB->Red;
pRGB->Red = tmp;
}
if (wG < pRGB->Green) {
tmp = wG;
wG = pRGB->Green;
pRGB->Green = tmp;
}
if (wB < pRGB->Blue) {
tmp = wB;
wB = pRGB->Blue;
pRGB->Blue = tmp;
}
}
}
} else {
cp.green.usp = ps->Bufs.b1.pShadingRam +
ps->AsicReg.RD_Pixels + _SHADING_BEGINX;
cp.blue.usp = (pUShort) ps->Shade.pHilight + _SHADING_BEGINX;
for (var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
cp.red.usp = cp.blue.usp++;
wG = *cp.green.usp;
for( b = ps->Shade.skipHilight; b--;
cp.red.usp += ps->AsicReg.RD_Pixels) {
if( wG > *cp.red.usp ) {
tmp = wG;
wG = *cp.red.usp;
*cp.red.usp = tmp;
}
}
wG = *cp.green.usp++;
for (b = ps->Shade.skipShadow; b--;
cp.red.usp += ps->AsicReg.RD_Pixels) {
if( wG < *cp.red.usp ) {
tmp = wG;
wG = *cp.red.usp;
*cp.red.usp = tmp;
}
}
}
}
}
/* AddToSumBuffer() */
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
cp.red.usp = ps->Bufs.b1.pShadingRam + _SHADING_BEGINX;
cp.green.usp = cp.red.usp + ps->AsicReg.RD_Pixels;
cp.blue.usp = cp.green.usp + ps->AsicReg.RD_Pixels;
pvar.pulrgb = (pRGBULongDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
for( var.dwValue = (ULong)ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;
pvar.pulrgb++, cp.red.usp++, cp.green.usp++, cp.blue.usp++) {
pvar.pulrgb->Red += (ULong)*cp.red.usp;
pvar.pulrgb->Green += (ULong)*cp.green.usp;
pvar.pulrgb->Blue += (ULong)*cp.blue.usp;
}
} else {
cp.green.usp = ps->Bufs.b1.pShadingRam + ps->AsicReg.RD_Pixels +
_SHADING_BEGINX;
pvar.pdw = (pULong)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
for(var.dwValue = (ULong)ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--; pvar.pdw++, cp.green.usp++) {
*pvar.pdw += (ULong)*cp.green.usp;
}
}
if( IOReadFifoLength( ps ) < ps->AsicReg.RD_Pixels )
IORegisterToScanner( ps, ps->RegRefreshScanState );
}
/* AverageAfterSubHilightShadow() */
if( ps->Shade.pHilight ) {
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
psum.pulrgb = (pRGBULongDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
pwsum = (pRGBUShortDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
pvar.pusrgb = (pRGBUShortDef)ps->Shade.pHilight + _SHADING_BEGINX;
for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
pRGB = pvar.pusrgb++;
for( b = ps->Shade.skipHilight + ps->Shade.skipShadow;
b--; pRGB += ps->AsicReg.RD_Pixels ) {
psum.pulrgb->Red -= (ULong)pRGB->Red;
psum.pulrgb->Green -= (ULong)pRGB->Green;
psum.pulrgb->Blue -= (ULong)pRGB->Blue;
}
pwsum->Red = (UShort)(psum.pulrgb->Red / ps->Shade.dwDiv);
pwsum->Green = (UShort)(psum.pulrgb->Green / ps->Shade.dwDiv);
pwsum->Blue = (UShort)(psum.pulrgb->Blue / ps->Shade.dwDiv);
psum.pulrgb++;
pwsum++;
}
} else {
cp.green.ulp = (pULong)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
cp.blue.usp = (pUShort)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
pvar.pw = (pUShort)ps->Shade.pHilight + _SHADING_BEGINX;
for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
cp.red.usp = pvar.pw++;
for( b = ps->Shade.skipHilight + ps->Shade.skipShadow;
b--; cp.red.usp += ps->AsicReg.RD_Pixels )
*cp.green.ulp -= *cp.red.usp;
*cp.blue.usp = (UShort)(*cp.green.ulp / ps->Shade.dwDiv);
cp.blue.usp++;
cp.green.ulp++;
}
}
} else {
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
psum.pulrgb = (pRGBULongDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
pwsum = (pRGBUShortDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
for (var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
pwsum->Red = (UShort)(psum.pulrgb->Red >> 5);
pwsum->Green = (UShort)(psum.pulrgb->Green >> 5);
pwsum->Blue = (UShort)(psum.pulrgb->Blue >> 5);
psum.pulrgb++;
pwsum++;
}
} else {
cp.green.ulp = (pULong)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
cp.blue.usp = (pUShort)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
for (var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
*cp.blue.usp = (UShort)(*cp.green.ulp >> 5);
cp.blue.usp++;
cp.green.ulp++;
}
}
}
/* Process negative & transparency here */
if( ps->DataInf.dwScanFlag & SCANDEF_TPA )
TPAP98003FindCenterPointer( ps );
if( ps->DataInf.dwScanFlag & SCANDEF_Negative )
TPAP98003Reshading( ps );
pRGB = (pRGBUShortDef)&ps->Shade.pCcdDac->GainResize;
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
pwsum = (pRGBUShortDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
if ((short)(pwsum->Red -= ps->Shade.DarkOffset.Colors.Red) > 0) {
pwsum->Red = pwsum->Red * pRGB->Red / 100U;
if( pwsum->Red > 0xfff )
pwsum->Red = 0xfff;
} else
pwsum->Red = 0;
if((short)(pwsum->Green -= ps->Shade.DarkOffset.Colors.Green) > 0) {
pwsum->Green = pwsum->Green * pRGB->Green / 100U;
if( pwsum->Green > 0xfff )
pwsum->Green = 0xfff;
} else
pwsum->Green = 0;
if ((short)(pwsum->Blue -= ps->Shade.DarkOffset.Colors.Blue) > 0) {
pwsum->Blue = pwsum->Blue * pRGB->Blue / 100U;
if( pwsum->Blue > 0xfff )
pwsum->Blue = 0xfff;
} else
pwsum->Blue = 0;
wR = (UShort)(pwsum->Red >> 4);
pwsum->Red <<= 12;
pwsum->Red |= wR;
wR = (UShort)(pwsum->Green >> 4);
pwsum->Green <<= 12;
pwsum->Green |= wR;
wR = (UShort)(pwsum->Blue>> 4);
pwsum->Blue <<= 12;
pwsum->Blue |= wR;
pwsum++;
}
} else {
cp.green.usp = (pUShort)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
var.dwValue--;) {
if((short)(*cp.green.usp -= ps->Shade.DarkOffset.Colors.Green) > 0) {
*cp.green.usp = *cp.green.usp * pRGB->Green / 100U;
if( *cp.green.usp > 0xfff )
*cp.green.usp = 0xfff;
} else
*cp.green.usp = 0;
wR = (UShort)(*cp.green.usp >> 4);
*cp.green.usp <<= 12;
*cp.green.usp |= wR;
cp.green.usp++;
}
}
/* DownloadShadingAndSetDark() */
dacP98DownloadShadingTable( ps, ps->Bufs.b2.pSumBuf, (5400 * 3 * 2));
}
/**
*/
static void dacP98003AdjustDark( pScanData ps )
{
ULong i;
UShort wDarks[3];
DBG( DBG_LOW, "dacP98003AdjustDark()\n" );
ps->Shade.DarkDAC.Colors = ps->Shade.pCcdDac->DarkDAC.Colors;
ps->Shade.fStop = _FALSE;
for( i = 16; i-- && !ps->Shade.fStop;) {
ps->Shade.fStop = _TRUE;
/* FillDarkToDAC() */
DacP98003FillToDAC( ps, &ps->Device.RegDACOffset, &ps->Shade.DarkDAC );
IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
ps->AsicReg.RD_ScanControl = (_SCAN_12BITMODE + _SCAN_1ST_AVERAGE);
IOSelectLampSource( ps );
IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
ps->AsicReg.RD_Motor0Control = _FORWARD_MOTOR;
ps->AsicReg.RD_Origin = _SHADING_BEGINX;
ps->AsicReg.RD_Pixels = 512;
if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
ps->AsicReg.RD_Dpi = 300;
else
ps->AsicReg.RD_Dpi = 600;
/* PauseColorMotorRunStates () */
memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
ps->a_nbNewAdrPointer[1] = 0x77;
IOPutOnAllRegisters( ps );
_DODELAY( 70 );
/* read one shading line and work on it */
if( IOReadOneShadingLine(ps, (pUChar)ps->Bufs.b1.pShadingRam, 512*2)) {
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
wDarks[0] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam );
wDarks[1] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam +
ps->AsicReg.RD_Pixels );
wDarks[2] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam +
ps->AsicReg.RD_Pixels * 2UL);
if( !wDarks[0] || !wDarks[1] || !wDarks[2] ) {
ps->Shade.fStop = _FALSE;
} else {
ps->Shade.DarkOffset.wColors[0] = wDarks[0];
ps->Shade.DarkOffset.wColors[1] = wDarks[1];
ps->Shade.DarkOffset.wColors[2] = wDarks[2];
(*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
_CHANNEL_RED, wDarks[0] );
(*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
_CHANNEL_GREEN, wDarks[1] );
(*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
_CHANNEL_BLUE, wDarks[2] );
}
} else {
wDarks[1] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam +
ps->AsicReg.RD_Pixels );
if (!wDarks[1] )
ps->Shade.fStop = _FALSE;
else {
ps->Shade.DarkOffset.wColors[1] = wDarks[1];
(*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
_CHANNEL_GREEN, wDarks[1] );
}
}
} else
ps->Shade.fStop = _FALSE;
}
/* CalculateDarkDependOnCCD() */
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
(*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_RED );
(*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_GREEN );
(*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_BLUE );
} else
(*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_GREEN );
}
/**
*/
static Bool dacP98003WaitForShading( pScanData ps )
{
ULong i, tmp;
Byte bScanControl;
DBG( DBG_LOW, "dacP98003WaitForShading()\n" );
/*
* before getting the shading data, (re)init the ASIC
*/
ps->ReInitAsic( ps, _TRUE );
ps->Shade.DarkOffset.Colors.Red = 0;
ps->Shade.DarkOffset.Colors.Green = 0;
ps->Shade.DarkOffset.Colors.Blue = 0;
IORegisterToScanner( ps, ps->RegResetMTSC );
IODataToRegister( ps, ps->RegModelControl, ps->AsicReg.RD_ModelControl);
IODataToRegister( ps, ps->RegMotorDriverType,
ps->AsicReg.RD_MotorDriverType );
IODataToRegister( ps, ps->RegScanControl1,
(_SCANSTOPONBUFFULL| _MFRC_BY_XSTEP));
ps->GotoShadingPosition( ps );
bScanControl = ps->AsicReg.RD_ScanControl;
/* SetShadingMapForGainDark */
memset( ps->Bufs.b2.pSumBuf, 0xff, (5400 * 3 * 2));
/* DownloadShadingAndSetDark() */
dacP98DownloadShadingTable( ps, ps->Bufs.b2.pSumBuf, (5400 * 3 * 2));
for( i = 0, tmp = 0; i < 1024; tmp += 0x01010101, i += 4 ) {
ps->Bufs.b1.Buf.pdw[i] =
ps->Bufs.b1.Buf.pdw[i+1] =
ps->Bufs.b1.Buf.pdw[i+2] =
ps->Bufs.b1.Buf.pdw[i+3] = tmp;
}
memcpy( ps->Bufs.b1.pShadingMap + 4096, ps->Bufs.b1.pShadingMap, 4096 );
memcpy( ps->Bufs.b1.pShadingMap + 8192, ps->Bufs.b1.pShadingMap, 4096 );
dacP98DownloadMapTable( ps, ps->Bufs.b1.pShadingMap );
DBG( DBG_LOW, "wExposure = %u\n", ps->Shade.wExposure);
DBG( DBG_LOW, "wXStep = %u\n", ps->Shade.wXStep);
ps->AsicReg.RD_LineControl = (_LOBYTE(ps->Shade.wExposure));
ps->AsicReg.RD_ExtLineControl = (_HIBYTE(ps->Shade.wExposure));
IODataToRegister(ps, ps->RegExtendedLineControl,
ps->AsicReg.RD_ExtLineControl );
IODataToRegister(ps, ps->RegLineControl, ps->AsicReg.RD_LineControl );
dacP98003AdjustRGBGain( ps );
dacP98003AdjustDark( ps );
dacP98003AdjustShadingWaveform( ps );
ps->AsicReg.RD_ScanControl = bScanControl;
/* here we have to download the table in any case...*/
dacP98DownloadMapTable( ps, ps->a_bMapTable );
MotorP98003BackToHomeSensor( ps );
return _TRUE;
}
/************************ exported functions *********************************/
/**
*/
_LOC int DacInitialize( pScanData ps )
{
DBG( DBG_HIGH, "DacInitialize()\n" );
if( NULL == ps )
return _E_NULLPTR;
/*
* depending on the asic, we set some functions
*/
if( _ASIC_IS_98003 == ps->sCaps.AsicID ) {
ps->WaitForShading = dacP98003WaitForShading;
} else if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
ps->WaitForShading = dacP98WaitForShading;
} else if( _ASIC_IS_96003 == ps->sCaps.AsicID ) {
ps->WaitForShading = dacP96003WaitForShading;
} else if( _ASIC_IS_96001 == ps->sCaps.AsicID ) {
ps->WaitForShading = dacP96001WaitForShading;
} else {
DBG( DBG_HIGH , "NOT SUPPORTED ASIC !!!\n" );
return _E_NOSUPP;
}
return _OK;
}
/** Fill out the R/G/B GainOut value
*/
_LOC void DacP98FillGainOutDirectPort( pScanData ps )
{
ps->OpenScanPath( ps );
IODataRegisterToDAC( ps, 0x28, ps->bRedGainIndex );
IODataRegisterToDAC( ps, 0x29, ps->bGreenGainIndex );
IODataRegisterToDAC( ps, 0x2a, ps->bBlueGainIndex );
ps->CloseScanPath( ps );
}
/**
*/
_LOC void DacP98FillShadingDarkToShadingRegister( pScanData ps )
{
pUChar pValue;
Byte bReg;
DBG( DBG_LOW, "DacP98FillShadingDarkToShadingRegister()\n" );
ps->AsicReg.RD_RedDarkOff = ps->Shade.DarkOffset.Colors.Red;
ps->AsicReg.RD_GreenDarkOff = ps->Shade.DarkOffset.Colors.Green;
ps->AsicReg.RD_BlueDarkOff = ps->Shade.DarkOffset.Colors.Blue;
pValue = (pUChar)&ps->AsicReg.RD_RedDarkOff;
for (bReg = ps->RegRedChDarkOffsetLow; bReg <= ps->RegBlueChDarkOffsetHigh;
bReg++, pValue++) {
IODataToRegister( ps, bReg, *pValue );
}
}
/**
*/
_LOC void DacP98AdjustDark( pScanData ps )
{
Byte bCorrectTimes; /* used to be a global var !*/
DBG( DBG_LOW, "DacP98AdjustDark()\n" );
ps->Shade.pCcdDac->DarkDAC.Colors.Red = ps->bsPreRedDAC;
ps->Shade.pCcdDac->DarkDAC.Colors.Green = ps->bsPreGreenDAC;
ps->Shade.pCcdDac->DarkDAC.Colors.Blue = ps->bsPreBlueDAC;
if( ps->DataInf.dwScanFlag & SCANDEF_Negative ) {
bCorrectTimes = 6;
} else {
bCorrectTimes = 5;
}
/* CHANGE
** original code seems to be buggy : for (bCorrectTimes ; bCorrectTimes--;) {
*/
for (;bCorrectTimes ; bCorrectTimes-- ) {
ps->OpenScanPath( ps );
dacP98FillDarkDAC( ps );
dacP98SetReadFBKRegister( ps );
ps->CloseScanPath( ps );
IOPutOnAllRegisters( ps );
ps->PauseColorMotorRunStates( ps ); /* stop scan states */
IOReadOneShadingLine( ps, ps->pScanBuffer1, 512*2 );
dacP98FillChannelDarkLevelControl( ps );
if(dacP98CheckChannelDarkLevel( ps ))
break;
}
ps->Shade.DarkOffset.Colors.Red=
dacP98CalDarkOff( ps, ps->Shade.DarkOffset.Colors.Red,
ps->Shade.pCcdDac->DarkCmpHi.Colors.Red,
ps->Shade.pCcdDac->DarkOffSub.Colors.Red );
ps->Shade.DarkOffset.Colors.Green =
dacP98CalDarkOff( ps, ps->Shade.DarkOffset.Colors.Green,
ps->Shade.pCcdDac->DarkCmpHi.Colors.Green,
ps->Shade.pCcdDac->DarkOffSub.Colors.Green );
ps->Shade.DarkOffset.Colors.Blue =
dacP98CalDarkOff( ps, ps->Shade.DarkOffset.Colors.Blue,
ps->Shade.pCcdDac->DarkCmpHi.Colors.Blue,
ps->Shade.pCcdDac->DarkOffSub.Colors.Blue );
}
/**
*/
_LOC void DacP96WriteBackToGammaShadingRAM( pScanData ps )
{
/* ModifyGammaShadingOffset(ps) */
ps->OpenScanPath( ps);
IODataToRegister( ps, ps->RegRedChShadingOffset,
ps->Asic96Reg.u28.RD_RedChShadingOff );
IODataToRegister( ps, ps->RegGreenChShadingOffset,
(Byte)((ULong)ps->Asic96Reg.u29.RD_GreenChShadingOff * 96UL/100UL));
IODataToRegister( ps, ps->RegBlueChShadingOffset,
(Byte)((ULong)ps->Asic96Reg.RD_BlueChShadingOff * 91UL/100UL));
ps->CloseScanPath( ps );
dacP96WriteLinearGamma( ps, ps->pPrescan16, 256, ps->ShadingBankRed);
dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize,
256, ps->ShadingBankGreen);
dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize * 2,
256, ps->ShadingBankBlue);
}
/**
*/
_LOC void DacP98003FillToDAC( pScanData ps, pRGBByteDef regs, pColorByte data )
{
if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
dacP98003GainOffsetToDAC( ps, _DAC_RED, regs->Red, data->Colors.Red );
dacP98003GainOffsetToDAC( ps, _DAC_GREENCOLOR,
regs->Green, data->Colors.Green );
dacP98003GainOffsetToDAC( ps, _DAC_BLUE,
regs->Blue, data->Colors.Blue );
} else {
dacP98003GainOffsetToDAC( ps, _DAC_GREENMONO, regs->Green,
data->Colors.Green );
}
}
/**
*/
_LOC void DacP98003AdjustGain( pScanData ps, ULong color, Byte hilight )
{
if( hilight < ps->Shade.bGainLow ) {
if( ps->Shade.Hilight.bColors[color] < ps->Shade.bGainHigh ) {
ps->Shade.fStop = _FALSE;
ps->Shade.Hilight.bColors[color] = hilight;
if( hilight <= (Byte)(ps->Shade.bGainLow - hilight))
ps->Shade.Gain.bColors[color] += ps->Shade.bGainDouble;
else
ps->Shade.Gain.bColors[color]++;
}
} else {
if( hilight > ps->Shade.bGainHigh ) {
ps->Shade.fStop = _FALSE;
ps->Shade.Hilight.bColors[color] = hilight;
ps->Shade.Gain.bColors[color]--;
} else
ps->Shade.Hilight.bColors[color] = hilight;
}
if( ps->Shade.Gain.bColors[color] > ps->Shade.bMaxGain ) {
ps->Shade.Gain.bColors[color] = ps->Shade.bMaxGain;
}
}
/**
*/
_LOC Byte DacP98003SumGains( pUChar pb, ULong pixelsLine )
{
Byte bHilight, tmp;
ULong dwPixels, dwAve;
UShort sum;
for( bHilight = 0, dwPixels = pixelsLine >> 4; dwPixels--; ) {
for( sum = 0, dwAve = 16; dwAve--; pb++)
sum += (UShort)*pb;
sum >>= 4;
tmp = (Byte)sum;
if( tmp > bHilight )
bHilight = tmp;
}
return bHilight;
}
/* END PLUSTEK-PP_DAC.C .....................................................*/
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik