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

Use prefix 'p' instead of 'lp', fix other style issues.

merge-requests/1/head
Jan Hauffa 2011-04-17 15:56:40 +02:00 zatwierdzone przez m. allan noah
rodzic 9e2aabc976
commit 4962b35abd
6 zmienionych plików z 485 dodań i 491 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

182
backend/mustek_usb2.c
Wyświetl plik

@ -122,12 +122,10 @@ static const Scanner_Model mustek_A2nu2_model = {
}; };
static SANE_Byte * g_lpNegImageData = NULL; static SANE_Byte * g_pNegImageData = NULL;
static unsigned int g_dwAlreadyGetNegLines; static unsigned int g_dwAlreadyGetNegLines;
static SANE_Bool IsTAConnected (void); static SANE_Bool IsTAConnected (void);
static void AutoLevel (SANE_Byte *lpSource, unsigned short ScanLines,
unsigned int BytesPerLine);
static size_t static size_t
@ -487,6 +485,83 @@ SetParameters (TARGETIMAGE * pSetParameters)
return SANE_TRUE; return SANE_TRUE;
} }
static unsigned short
AdjustColorComponent (SANE_Byte c, SANE_Byte min, SANE_Byte max,
SANE_Byte range)
{
if (range == 0)
c = max;
else if (c < min)
c = 0;
else
{
float fmax = (float) ((c - min) * 255) / range;
c = (unsigned short) fmax;
if ((fmax - c) >= 0.5)
c++;
}
return c;
}
static void
AutoLevel (SANE_Byte * pSource, unsigned short ScanLines,
unsigned int BytesPerLine)
{
unsigned int i, j;
unsigned int tLines;
SANE_Byte R, G, B;
SANE_Byte max_R = 0, max_G = 0, max_B = 0;
SANE_Byte min_R = 255, min_G = 255, min_B = 255;
SANE_Byte range_R, range_G, range_B;
unsigned int iWidth = BytesPerLine / 3;
DBG (DBG_FUNC, "AutoLevel: start\n");
/* find min and max values for each color component */
for (j = 0, tLines = 0; j < ScanLines; j++, tLines += BytesPerLine)
{
for (i = 0; i < iWidth; i++)
{
R = pSource[tLines + i * 3 + 2];
G = pSource[tLines + i * 3 + 1];
B = pSource[tLines + i * 3];
max_R = _MAX (R, max_R);
max_G = _MAX (G, max_G);
max_B = _MAX (B, max_B);
min_R = _MIN (R, min_R);
min_G = _MIN (G, min_G);
min_B = _MIN (B, min_B);
}
}
range_R = max_R - min_R;
range_G = max_G - min_G;
range_B = max_B - min_B;
/* stretch histogram */
for (j = 0, tLines = 0; j < ScanLines; j++, tLines += BytesPerLine)
{
for (i = 0; i < iWidth; i++)
{
R = pSource[tLines + i * 3 + 2];
G = pSource[tLines + i * 3 + 1];
B = pSource[tLines + i * 3];
R = AdjustColorComponent (R, min_R, max_R, range_R);
G = AdjustColorComponent (G, min_G, max_G, range_G);
B = AdjustColorComponent (B, min_B, max_B, range_B);
pSource[tLines + i * 3 + 2] = R;
pSource[tLines + i * 3 + 1] = G;
pSource[tLines + i * 3] = B;
}
}
DBG (DBG_FUNC, "AutoLevel: exit\n");
}
static SANE_Bool static SANE_Bool
ReadScannedData (IMAGEROWS * pImageRows, TARGETIMAGE * pTarget) ReadScannedData (IMAGEROWS * pImageRows, TARGETIMAGE * pTarget)
{ {
@ -507,28 +582,28 @@ ReadScannedData (IMAGEROWS * pImageRows, TARGETIMAGE * pTarget)
if (pTarget->cmColorMode != CM_RGB24) if (pTarget->cmColorMode != CM_RGB24)
return SANE_FALSE; return SANE_FALSE;
if (!g_lpNegImageData) if (!g_pNegImageData)
{ {
unsigned int TotalImageSize = g_SWHeight * pTarget->dwBytesPerRow; unsigned int TotalImageSize = g_SWHeight * pTarget->dwBytesPerRow;
g_dwAlreadyGetNegLines = 0; g_dwAlreadyGetNegLines = 0;
g_lpNegImageData = malloc (TotalImageSize); g_pNegImageData = malloc (TotalImageSize);
if (!g_lpNegImageData) if (!g_pNegImageData)
{ {
DBG (DBG_ERR, "ReadScannedData: error allocating memory\n"); DBG (DBG_ERR, "ReadScannedData: error allocating memory\n");
return SANE_FALSE; return SANE_FALSE;
} }
if (!MustScanner_GetRows (g_lpNegImageData, &g_SWHeight, isRGBInvert)) if (!MustScanner_GetRows (g_pNegImageData, &g_SWHeight, isRGBInvert))
return SANE_FALSE; return SANE_FALSE;
DBG (DBG_INFO, "ReadScannedData: get image data is over!\n"); DBG (DBG_INFO, "ReadScannedData: get image data is over!\n");
for (i = 0; i < TotalImageSize; i++) for (i = 0; i < TotalImageSize; i++)
g_lpNegImageData[i] ^= 0xff; g_pNegImageData[i] ^= 0xff;
AutoLevel (g_lpNegImageData, g_SWHeight, pTarget->dwBytesPerRow); AutoLevel (g_pNegImageData, g_SWHeight, pTarget->dwBytesPerRow);
DBG (DBG_INFO, "ReadScannedData: autolevel is ok\n"); DBG (DBG_INFO, "ReadScannedData: autolevel is ok\n");
} }
memcpy (pImageRows->pBuffer, g_lpNegImageData + memcpy (pImageRows->pBuffer, g_pNegImageData +
(pTarget->dwBytesPerRow * g_dwAlreadyGetNegLines), (pTarget->dwBytesPerRow * g_dwAlreadyGetNegLines),
pTarget->dwBytesPerRow * Rows); pTarget->dwBytesPerRow * Rows);
pImageRows->wXferedLineNum = Rows; pImageRows->wXferedLineNum = Rows;
@ -537,8 +612,8 @@ ReadScannedData (IMAGEROWS * pImageRows, TARGETIMAGE * pTarget)
g_dwAlreadyGetNegLines += Rows; g_dwAlreadyGetNegLines += Rows;
if (g_dwAlreadyGetNegLines >= g_SWHeight) if (g_dwAlreadyGetNegLines >= g_SWHeight)
{ {
free (g_lpNegImageData); free (g_pNegImageData);
g_lpNegImageData = NULL; g_pNegImageData = NULL;
} }
} }
else else
@ -582,10 +657,10 @@ StopScan (void)
g_pGammaTable = NULL; g_pGammaTable = NULL;
} }
if (g_lpReadImageHead) if (g_pReadImageHead)
{ {
free (g_lpReadImageHead); free (g_pReadImageHead);
g_lpReadImageHead = NULL; g_pReadImageHead = NULL;
} }
DBG (DBG_FUNC, "StopScan: exit\n"); DBG (DBG_FUNC, "StopScan: exit\n");
@ -641,83 +716,6 @@ GetKeyStatus (SANE_Byte * pKey)
} }
#endif #endif
static unsigned short
AdjustColorComponent (SANE_Byte c, SANE_Byte min, SANE_Byte max,
SANE_Byte range)
{
if (range == 0)
c = max;
else if (c < min)
c = 0;
else
{
float fmax = (float) ((c - min) * 255) / range;
c = (unsigned short) fmax;
if ((fmax - c) >= 0.5)
c++;
}
return c;
}
static void
AutoLevel (SANE_Byte *lpSource, unsigned short ScanLines,
unsigned int BytesPerLine)
{
unsigned int i, j;
unsigned int tLines;
SANE_Byte R, G, B;
SANE_Byte max_R = 0, max_G = 0, max_B = 0;
SANE_Byte min_R = 255, min_G = 255, min_B = 255;
SANE_Byte range_R, range_G, range_B;
unsigned int iWidth = BytesPerLine / 3;
DBG (DBG_FUNC, "AutoLevel: start\n");
/* find min and max values for each color component */
for (j = 0, tLines = 0; j < ScanLines; j++, tLines += BytesPerLine)
{
for (i = 0; i < iWidth; i++)
{
R = lpSource[tLines + i * 3 + 2];
G = lpSource[tLines + i * 3 + 1];
B = lpSource[tLines + i * 3];
max_R = _MAX (R, max_R);
max_G = _MAX (G, max_G);
max_B = _MAX (B, max_B);
min_R = _MIN (R, min_R);
min_G = _MIN (G, min_G);
min_B = _MIN (B, min_B);
}
}
range_R = max_R - min_R;
range_G = max_G - min_G;
range_B = max_B - min_B;
/* stretch histogram */
for (j = 0, tLines = 0; j < ScanLines; j++, tLines += BytesPerLine)
{
for (i = 0; i < iWidth; i++)
{
R = lpSource[tLines + i * 3 + 2];
G = lpSource[tLines + i * 3 + 1];
B = lpSource[tLines + i * 3];
R = AdjustColorComponent (R, min_R, max_R, range_R);
G = AdjustColorComponent (G, min_G, max_G, range_G);
B = AdjustColorComponent (B, min_B, max_B, range_B);
lpSource[tLines + i * 3 + 2] = R;
lpSource[tLines + i * 3 + 1] = G;
lpSource[tLines + i * 3] = B;
}
}
DBG (DBG_FUNC, "AutoLevel: exit\n");
}
/****************************** SANE API functions ****************************/ /****************************** SANE API functions ****************************/

4
backend/mustek_usb2.h
Wyświetl plik

@ -129,8 +129,8 @@ typedef struct Mustek_Scanner
SANE_Bool bIsScanning; SANE_Bool bIsScanning;
SANE_Bool bIsReading; SANE_Bool bIsReading;
SANE_Word read_rows; /* number of transfered image lines */ SANE_Word read_rows; /* number of transfered image lines */
SANE_Byte *Scan_data_buf; SANE_Byte * Scan_data_buf;
SANE_Byte *Scan_data_buf_start; SANE_Byte * Scan_data_buf_start;
size_t scan_buffer_len; size_t scan_buffer_len;
} Mustek_Scanner; } Mustek_Scanner;

150
backend/mustek_usb2_asic.c
Wyświetl plik

@ -51,10 +51,6 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif
#include <math.h> #include <math.h>
#include "../include/sane/sane.h" #include "../include/sane/sane.h"
@ -75,12 +71,12 @@ static SANE_Byte RegisterBankStatus = ~0;
static SANE_Status static SANE_Status
WriteIOControl (ASIC * chip, unsigned short wValue, unsigned short wIndex, WriteIOControl (ASIC * chip, unsigned short wValue, unsigned short wIndex,
unsigned short wLength, SANE_Byte * lpBuf) unsigned short wLength, SANE_Byte * pBuf)
{ {
SANE_Status status; SANE_Status status;
status = sanei_usb_control_msg (chip->fd, 0x40, 0x01, wValue, wIndex, wLength, status = sanei_usb_control_msg (chip->fd, 0x40, 0x01, wValue, wIndex, wLength,
lpBuf); pBuf);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
DBG (DBG_ERR, "WriteIOControl Error!\n"); DBG (DBG_ERR, "WriteIOControl Error!\n");
@ -89,12 +85,12 @@ WriteIOControl (ASIC * chip, unsigned short wValue, unsigned short wIndex,
static SANE_Status static SANE_Status
ReadIOControl (ASIC * chip, unsigned short wValue, unsigned short wIndex, ReadIOControl (ASIC * chip, unsigned short wValue, unsigned short wIndex,
unsigned short wLength, SANE_Byte * lpBuf) unsigned short wLength, SANE_Byte * pBuf)
{ {
SANE_Status status; SANE_Status status;
status = sanei_usb_control_msg (chip->fd, 0xc0, 0x01, wValue, wIndex, wLength, status = sanei_usb_control_msg (chip->fd, 0xc0, 0x01, wValue, wIndex, wLength,
lpBuf); pBuf);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
DBG (DBG_ERR, "ReadIOControl Error!\n"); DBG (DBG_ERR, "ReadIOControl Error!\n");
@ -233,7 +229,7 @@ Mustek_SetRWSize (ASIC * chip, SANE_Bool isWriteAccess, unsigned int size)
} }
static SANE_Status static SANE_Status
Mustek_DMARead (ASIC * chip, unsigned int size, SANE_Byte * lpData) Mustek_DMARead (ASIC * chip, unsigned int size, SANE_Byte * pData)
{ {
SANE_Status status; SANE_Status status;
size_t cur_read_size; size_t cur_read_size;
@ -256,7 +252,7 @@ Mustek_DMARead (ASIC * chip, unsigned int size, SANE_Byte * lpData)
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
return status; return status;
status = sanei_usb_read_bulk (chip->fd, lpData, &cur_read_size); status = sanei_usb_read_bulk (chip->fd, pData, &cur_read_size);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
{ {
DBG (DBG_ERR, "Mustek_DMARead: read error\n"); DBG (DBG_ERR, "Mustek_DMARead: read error\n");
@ -264,7 +260,7 @@ Mustek_DMARead (ASIC * chip, unsigned int size, SANE_Byte * lpData)
} }
size -= cur_read_size; size -= cur_read_size;
lpData += cur_read_size; pData += cur_read_size;
} }
if (cur_read_size < DMA_BLOCK_SIZE) if (cur_read_size < DMA_BLOCK_SIZE)
@ -275,7 +271,7 @@ Mustek_DMARead (ASIC * chip, unsigned int size, SANE_Byte * lpData)
} }
static SANE_Status static SANE_Status
Mustek_DMAWrite (ASIC * chip, unsigned int size, SANE_Byte * lpData) Mustek_DMAWrite (ASIC * chip, unsigned int size, SANE_Byte * pData)
{ {
SANE_Status status; SANE_Status status;
size_t cur_write_size; size_t cur_write_size;
@ -298,7 +294,7 @@ Mustek_DMAWrite (ASIC * chip, unsigned int size, SANE_Byte * lpData)
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
return status; return status;
status = sanei_usb_write_bulk (chip->fd, lpData, &cur_write_size); status = sanei_usb_write_bulk (chip->fd, pData, &cur_write_size);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
{ {
DBG (DBG_ERR, "Mustek_DMAWrite: write error\n"); DBG (DBG_ERR, "Mustek_DMAWrite: write error\n");
@ -306,7 +302,7 @@ Mustek_DMAWrite (ASIC * chip, unsigned int size, SANE_Byte * lpData)
} }
size -= cur_write_size; size -= cur_write_size;
lpData += cur_write_size; pData += cur_write_size;
} }
status = Mustek_ClearFIFO (chip); status = Mustek_ClearFIFO (chip);
@ -847,22 +843,22 @@ SetMotorStepTableForCalibration (ASIC * chip, LLF_MOTORMOVE * MotorStepsTable,
} }
static void static void
CalculateScanMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable) CalculateScanMotorTable (LLF_CALCULATEMOTORTABLE * pCalculateMotorTable)
{ {
unsigned short wEndSpeed, wStartSpeed; unsigned short wEndSpeed, wStartSpeed;
unsigned short wScanAccSteps; unsigned short wScanAccSteps;
SANE_Byte bScanDecSteps; SANE_Byte bScanDecSteps;
unsigned short * lpMotorTable; unsigned short * pMotorTable;
long double y; long double y;
unsigned short i; unsigned short i;
DBG (DBG_ASIC, "CalculateScanMotorTable: Enter\n"); DBG (DBG_ASIC, "CalculateScanMotorTable: Enter\n");
wStartSpeed = lpCalculateMotorTable->StartSpeed; wStartSpeed = pCalculateMotorTable->StartSpeed;
wEndSpeed = lpCalculateMotorTable->EndSpeed; wEndSpeed = pCalculateMotorTable->EndSpeed;
wScanAccSteps = lpCalculateMotorTable->AccStepBeforeScan; wScanAccSteps = pCalculateMotorTable->AccStepBeforeScan;
bScanDecSteps = lpCalculateMotorTable->DecStepAfterScan; bScanDecSteps = pCalculateMotorTable->DecStepAfterScan;
lpMotorTable = lpCalculateMotorTable->lpMotorTable; pMotorTable = pCalculateMotorTable->pMotorTable;
/* motor T0 & T6 acc table */ /* motor T0 & T6 acc table */
for (i = 0; i < 512; i++) for (i = 0; i < 512; i++)
@ -870,8 +866,8 @@ CalculateScanMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable)
y = 6000 - 3500; y = 6000 - 3500;
y *= pow (0.09, (M_PI_2 * i) / 512) - pow (0.09, (M_PI_2 * 511) / 512); y *= pow (0.09, (M_PI_2 * i) / 512) - pow (0.09, (M_PI_2 * 511) / 512);
y += 4500; y += 4500;
lpMotorTable[i] = (unsigned short) y; /* T0 */ pMotorTable[i] = (unsigned short) y; /* T0 */
lpMotorTable[i + 512 * 6] = (unsigned short) y; /* T6 */ pMotorTable[i + 512 * 6] = (unsigned short) y; /* T6 */
} }
/* motor T1 & T7 dec table */ /* motor T1 & T7 dec table */
@ -880,8 +876,8 @@ CalculateScanMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable)
y = 6000 - 3500; y = 6000 - 3500;
y *= pow (0.3, (M_PI_2 * i) / 256); y *= pow (0.3, (M_PI_2 * i) / 256);
y = 6000 - y; y = 6000 - y;
lpMotorTable[i + 512] = (unsigned short) y; /* T1 */ pMotorTable[i + 512] = (unsigned short) y; /* T1 */
lpMotorTable[i + 512 * 7] = (unsigned short) y; /* T7 */ pMotorTable[i + 512 * 7] = (unsigned short) y; /* T7 */
} }
for (i = 0; i < wScanAccSteps; i++) for (i = 0; i < wScanAccSteps; i++)
@ -890,13 +886,13 @@ CalculateScanMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable)
y *= pow (0.09, (M_PI_2 * i) / wScanAccSteps) - y *= pow (0.09, (M_PI_2 * i) / wScanAccSteps) -
pow (0.09, (M_PI_2 * (wScanAccSteps - 1)) / wScanAccSteps); pow (0.09, (M_PI_2 * (wScanAccSteps - 1)) / wScanAccSteps);
y += wEndSpeed; y += wEndSpeed;
lpMotorTable[i + 512 * 2] = (unsigned short) y; /* T2 */ pMotorTable[i + 512 * 2] = (unsigned short) y; /* T2 */
lpMotorTable[i + 512 * 4] = (unsigned short) y; /* T4 */ pMotorTable[i + 512 * 4] = (unsigned short) y; /* T4 */
} }
for (i = wScanAccSteps; i < 512; i++) for (i = wScanAccSteps; i < 512; i++)
{ {
lpMotorTable[i + 512 * 2] = wEndSpeed; /* T2 */ pMotorTable[i + 512 * 2] = wEndSpeed; /* T2 */
lpMotorTable[i + 512 * 4] = wEndSpeed; /* T4 */ pMotorTable[i + 512 * 4] = wEndSpeed; /* T4 */
} }
for (i = 0; i < (unsigned short) bScanDecSteps; i++) for (i = 0; i < (unsigned short) bScanDecSteps; i++)
@ -904,53 +900,53 @@ CalculateScanMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable)
y = wStartSpeed - wEndSpeed; y = wStartSpeed - wEndSpeed;
y *= pow (0.3, (M_PI_2 * i) / bScanDecSteps); y *= pow (0.3, (M_PI_2 * i) / bScanDecSteps);
y = wStartSpeed - y; y = wStartSpeed - y;
lpMotorTable[i + 512 * 3] = (unsigned short) y; /* T3 */ pMotorTable[i + 512 * 3] = (unsigned short) y; /* T3 */
lpMotorTable[i + 512 * 5] = (unsigned short) y; /* T5 */ pMotorTable[i + 512 * 5] = (unsigned short) y; /* T5 */
} }
for (i = bScanDecSteps; i < 256; i++) for (i = bScanDecSteps; i < 256; i++)
{ {
lpMotorTable[i + 512 * 3] = wStartSpeed; /* T3 */ pMotorTable[i + 512 * 3] = wStartSpeed; /* T3 */
lpMotorTable[i + 512 * 5] = wStartSpeed; /* T5 */ pMotorTable[i + 512 * 5] = wStartSpeed; /* T5 */
} }
DBG (DBG_ASIC, "CalculateScanMotorTable: Exit\n"); DBG (DBG_ASIC, "CalculateScanMotorTable: Exit\n");
} }
static void static void
CalculateMoveMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable) CalculateMoveMotorTable (LLF_CALCULATEMOTORTABLE * pCalculateMotorTable)
{ {
unsigned short wEndSpeed, wStartSpeed; unsigned short wEndSpeed, wStartSpeed;
unsigned short wScanAccSteps; unsigned short wScanAccSteps;
unsigned short * lpMotorTable; unsigned short * pMotorTable;
long double y; long double y;
unsigned short i; unsigned short i;
DBG (DBG_ASIC, "CalculateMoveMotorTable: Enter\n"); DBG (DBG_ASIC, "CalculateMoveMotorTable: Enter\n");
wStartSpeed = lpCalculateMotorTable->StartSpeed; wStartSpeed = pCalculateMotorTable->StartSpeed;
wEndSpeed = lpCalculateMotorTable->EndSpeed; wEndSpeed = pCalculateMotorTable->EndSpeed;
wScanAccSteps = lpCalculateMotorTable->AccStepBeforeScan; wScanAccSteps = pCalculateMotorTable->AccStepBeforeScan;
lpMotorTable = lpCalculateMotorTable->lpMotorTable; pMotorTable = pCalculateMotorTable->pMotorTable;
for (i = 0; i < 512; i++) for (i = 0; i < 512; i++)
{ {
/* before scan acc table */ /* before scan acc table */
y = (wStartSpeed - wEndSpeed) * y = (wStartSpeed - wEndSpeed) *
pow (0.09, (M_PI_2 * i) / 512) + wEndSpeed; pow (0.09, (M_PI_2 * i) / 512) + wEndSpeed;
lpMotorTable[i] = (unsigned short) y; pMotorTable[i] = (unsigned short) y;
lpMotorTable[i + 512 * 2] = (unsigned short) y; pMotorTable[i + 512 * 2] = (unsigned short) y;
lpMotorTable[i + 512 * 4] = (unsigned short) y; pMotorTable[i + 512 * 4] = (unsigned short) y;
lpMotorTable[i + 512 * 6] = (unsigned short) y; pMotorTable[i + 512 * 6] = (unsigned short) y;
} }
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
y = wStartSpeed - (wStartSpeed - wEndSpeed) * y = wStartSpeed - (wStartSpeed - wEndSpeed) *
pow (0.3, (M_PI_2 * i) / 256); pow (0.3, (M_PI_2 * i) / 256);
lpMotorTable[i + 512] = (unsigned short) y; pMotorTable[i + 512] = (unsigned short) y;
lpMotorTable[i + 512 * 3] = (unsigned short) y; pMotorTable[i + 512 * 3] = (unsigned short) y;
lpMotorTable[i + 512 * 5] = (unsigned short) y; pMotorTable[i + 512 * 5] = (unsigned short) y;
lpMotorTable[i + 512 * 7] = (unsigned short) y; pMotorTable[i + 512 * 7] = (unsigned short) y;
} }
for (i = 0; i < wScanAccSteps; i++) for (i = 0; i < wScanAccSteps; i++)
@ -959,7 +955,7 @@ CalculateMoveMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable)
(pow (0.09, (M_PI_2 * i) / wScanAccSteps) - (pow (0.09, (M_PI_2 * i) / wScanAccSteps) -
pow (0.09, (M_PI_2 * (wScanAccSteps - 1)) / wScanAccSteps)) + pow (0.09, (M_PI_2 * (wScanAccSteps - 1)) / wScanAccSteps)) +
wEndSpeed; wEndSpeed;
lpMotorTable[i + 512 * 2] = (unsigned short) y; pMotorTable[i + 512 * 2] = (unsigned short) y;
} }
DBG (DBG_ASIC, "CalculateMoveMotorTable: Exit\n"); DBG (DBG_ASIC, "CalculateMoveMotorTable: Exit\n");
@ -1005,7 +1001,7 @@ MotorMove (ASIC * chip, unsigned short wStartSpeed, unsigned short wEndSpeed,
CalMotorTable.StartSpeed = wStartSpeed; CalMotorTable.StartSpeed = wStartSpeed;
CalMotorTable.EndSpeed = wEndSpeed; CalMotorTable.EndSpeed = wEndSpeed;
CalMotorTable.AccStepBeforeScan = 511; CalMotorTable.AccStepBeforeScan = 511;
CalMotorTable.lpMotorTable = MotorTable; CalMotorTable.pMotorTable = MotorTable;
CalculateMoveMotorTable (&CalMotorTable); CalculateMoveMotorTable (&CalMotorTable);
CurrentPhase.MoveType = _4_TABLE_SPACE_FOR_FULL_STEP; CurrentPhase.MoveType = _4_TABLE_SPACE_FOR_FULL_STEP;
@ -1996,7 +1992,7 @@ Asic_Initialize (ASIC * chip)
chip->isUsb20 = SANE_FALSE; chip->isUsb20 = SANE_FALSE;
chip->dwBytesCountPerRow = 0; chip->dwBytesCountPerRow = 0;
chip->isMotorMoveToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_ENABLE; chip->isMotorMoveToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_ENABLE;
chip->lpShadingTable = NULL; chip->pShadingTable = NULL;
InitTiming (chip); InitTiming (chip);
@ -2143,7 +2139,7 @@ Asic_SetWindow (ASIC * chip, SCANSOURCE lsLightSource,
unsigned short XRatioTypeWord; unsigned short XRatioTypeWord;
double XRatioTypeDouble; double XRatioTypeDouble;
double XRatioAdderDouble; double XRatioAdderDouble;
LLF_MOTORMOVE lpMotorStepsTable; LLF_MOTORMOVE pMotorStepsTable;
SANE_Byte bDummyCycleNum; SANE_Byte bDummyCycleNum;
unsigned short wMultiMotorStep; unsigned short wMultiMotorStep;
SANE_Byte bMotorMoveType; SANE_Byte bMotorMoveType;
@ -2156,7 +2152,7 @@ Asic_SetWindow (ASIC * chip, SCANSOURCE lsLightSource,
SANE_Byte isMotorMoveToFirstLine; SANE_Byte isMotorMoveToFirstLine;
SANE_Byte isUniformSpeedToScan; SANE_Byte isUniformSpeedToScan;
SANE_Byte isScanBackTracking; SANE_Byte isScanBackTracking;
unsigned short * lpMotorTable; unsigned short * pMotorTable;
unsigned int RealTableSize; unsigned int RealTableSize;
unsigned short wFullBank; unsigned short wFullBank;
@ -2301,13 +2297,13 @@ Asic_SetWindow (ASIC * chip, SCANSOURCE lsLightSource,
if (ScanType == SCAN_TYPE_NORMAL) if (ScanType == SCAN_TYPE_NORMAL)
{ {
SetMotorStepTable (chip, &lpMotorStepsTable, wY, SetMotorStepTable (chip, &pMotorStepsTable, wY,
wLength * SENSOR_DPI / wYResolution * wMultiMotorStep, wLength * SENSOR_DPI / wYResolution * wMultiMotorStep,
wYResolution); wYResolution);
} }
else else
{ {
SetMotorStepTableForCalibration (chip, &lpMotorStepsTable, SetMotorStepTableForCalibration (chip, &pMotorStepsTable,
wLength * SENSOR_DPI / wYResolution * wMultiMotorStep); wLength * SENSOR_DPI / wYResolution * wMultiMotorStep);
} }
@ -2362,19 +2358,19 @@ Asic_SetWindow (ASIC * chip, SCANSOURCE lsLightSource,
Mustek_SendData (chip, ES01_FD_MotorFixedspeedLSB, LOBYTE (EndSpeed)); Mustek_SendData (chip, ES01_FD_MotorFixedspeedLSB, LOBYTE (EndSpeed));
Mustek_SendData (chip, ES01_FE_MotorFixedspeedMSB, HIBYTE (EndSpeed)); Mustek_SendData (chip, ES01_FE_MotorFixedspeedMSB, HIBYTE (EndSpeed));
lpMotorTable = malloc (MOTOR_TABLE_SIZE * sizeof (unsigned short)); pMotorTable = malloc (MOTOR_TABLE_SIZE * sizeof (unsigned short));
if (!lpMotorTable) if (!pMotorTable)
{ {
DBG (DBG_ERR, "Asic_SetWindow: lpMotorTable == NULL\n"); DBG (DBG_ERR, "Asic_SetWindow: pMotorTable == NULL\n");
return SANE_STATUS_NO_MEM; return SANE_STATUS_NO_MEM;
} }
memset (lpMotorTable, 0, MOTOR_TABLE_SIZE * sizeof (unsigned short)); memset (pMotorTable, 0, MOTOR_TABLE_SIZE * sizeof (unsigned short));
CalMotorTable.StartSpeed = StartSpeed; CalMotorTable.StartSpeed = StartSpeed;
CalMotorTable.EndSpeed = EndSpeed; CalMotorTable.EndSpeed = EndSpeed;
CalMotorTable.AccStepBeforeScan = lpMotorStepsTable.wScanAccSteps; CalMotorTable.AccStepBeforeScan = pMotorStepsTable.wScanAccSteps;
CalMotorTable.DecStepAfterScan = lpMotorStepsTable.bScanDecSteps; CalMotorTable.DecStepAfterScan = pMotorStepsTable.bScanDecSteps;
CalMotorTable.lpMotorTable = lpMotorTable; CalMotorTable.pMotorTable = pMotorTable;
if (ScanType == SCAN_TYPE_NORMAL) if (ScanType == SCAN_TYPE_NORMAL)
CalculateScanMotorTable (&CalMotorTable); CalculateScanMotorTable (&CalMotorTable);
else else
@ -2394,8 +2390,8 @@ Asic_SetWindow (ASIC * chip, SCANSOURCE lsLightSource,
/* write motor table */ /* write motor table */
RealTableSize = MOTOR_TABLE_SIZE; RealTableSize = MOTOR_TABLE_SIZE;
dwTableBaseAddr = PACK_AREA_START_ADDRESS - RealTableSize; dwTableBaseAddr = PACK_AREA_START_ADDRESS - RealTableSize;
status = LLFSetMotorTable (chip, dwTableBaseAddr, lpMotorTable); status = LLFSetMotorTable (chip, dwTableBaseAddr, pMotorTable);
free (lpMotorTable); free (pMotorTable);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
return status; return status;
@ -2411,7 +2407,7 @@ Asic_SetWindow (ASIC * chip, SCANSOURCE lsLightSource,
RealTableSize = sizeof (unsigned short) * RealTableSize = sizeof (unsigned short) *
ShadingTableSize ((int) ((wWidth + 4) * XRatioAdderDouble)); ShadingTableSize ((int) ((wWidth + 4) * XRatioAdderDouble));
status = LLFSetShadingTable (chip, dwTableBaseAddr, RealTableSize, status = LLFSetShadingTable (chip, dwTableBaseAddr, RealTableSize,
chip->lpShadingTable); chip->pShadingTable);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
return status; return status;
} }
@ -2750,8 +2746,8 @@ Asic_CarriageHome (ASIC * chip)
} }
SANE_Status SANE_Status
Asic_SetShadingTable (ASIC * chip, unsigned short * lpWhiteShading, Asic_SetShadingTable (ASIC * chip, unsigned short * pWhiteShading,
unsigned short * lpDarkShading, unsigned short * pDarkShading,
unsigned short wXResolution, unsigned short wWidth) unsigned short wXResolution, unsigned short wWidth)
{ {
unsigned short i, j, n; unsigned short i, j, n;
@ -2779,15 +2775,15 @@ Asic_SetShadingTable (ASIC * chip, unsigned short * lpWhiteShading,
First 4 and last 5 elements of shading table cannot be used. */ First 4 and last 5 elements of shading table cannot be used. */
wShadingTableSize = ShadingTableSize (wValidPixelNumber) * wShadingTableSize = ShadingTableSize (wValidPixelNumber) *
sizeof (unsigned short); sizeof (unsigned short);
if (chip->lpShadingTable) if (chip->pShadingTable)
free (chip->lpShadingTable); free (chip->pShadingTable);
DBG (DBG_ASIC, "Allocating a new shading table, size=%d byte\n", DBG (DBG_ASIC, "Allocating a new shading table, size=%d byte\n",
wShadingTableSize); wShadingTableSize);
chip->lpShadingTable = malloc (wShadingTableSize); chip->pShadingTable = malloc (wShadingTableSize);
if (!chip->lpShadingTable) if (!chip->pShadingTable)
{ {
DBG (DBG_ASIC, "lpShadingTable == NULL\n"); DBG (DBG_ASIC, "pShadingTable == NULL\n");
return SANE_STATUS_NO_MEM; return SANE_STATUS_NO_MEM;
} }
@ -2800,13 +2796,13 @@ Asic_SetShadingTable (ASIC * chip, unsigned short * lpWhiteShading,
for (j = 0; j < numPixel; j++) for (j = 0; j < numPixel; j++)
{ {
chip->lpShadingTable[i * 256 + j * 6] = lpDarkShading[n * 3]; chip->pShadingTable[i * 256 + j * 6] = pDarkShading[n * 3];
chip->lpShadingTable[i * 256 + j * 6 + 2] = lpDarkShading[n * 3 + 1]; chip->pShadingTable[i * 256 + j * 6 + 2] = pDarkShading[n * 3 + 1];
chip->lpShadingTable[i * 256 + j * 6 + 4] = lpDarkShading[n * 3 + 2]; chip->pShadingTable[i * 256 + j * 6 + 4] = pDarkShading[n * 3 + 2];
chip->lpShadingTable[i * 256 + j * 6 + 1] = lpWhiteShading[n * 3]; chip->pShadingTable[i * 256 + j * 6 + 1] = pWhiteShading[n * 3];
chip->lpShadingTable[i * 256 + j * 6 + 3] = lpWhiteShading[n * 3 + 1]; chip->pShadingTable[i * 256 + j * 6 + 3] = pWhiteShading[n * 3 + 1];
chip->lpShadingTable[i * 256 + j * 6 + 5] = lpWhiteShading[n * 3 + 2]; chip->pShadingTable[i * 256 + j * 6 + 5] = pWhiteShading[n * 3 + 2];
if ((j % (unsigned short) dbXRatioAdderDouble) == if ((j % (unsigned short) dbXRatioAdderDouble) ==
(dbXRatioAdderDouble - 1)) (dbXRatioAdderDouble - 1))

8
backend/mustek_usb2_asic.h
Wyświetl plik

@ -129,7 +129,7 @@ typedef struct
unsigned short EndSpeed; unsigned short EndSpeed;
unsigned short AccStepBeforeScan; unsigned short AccStepBeforeScan;
SANE_Byte DecStepAfterScan; SANE_Byte DecStepAfterScan;
unsigned short * lpMotorTable; unsigned short * pMotorTable;
} LLF_CALCULATEMOTORTABLE; } LLF_CALCULATEMOTORTABLE;
typedef struct typedef struct
@ -200,7 +200,7 @@ typedef struct
ADConverter AD; ADConverter AD;
SANE_Byte isMotorMoveToFirstLine; SANE_Byte isMotorMoveToFirstLine;
unsigned short * lpShadingTable; unsigned short * pShadingTable;
} ASIC; } ASIC;
@ -984,8 +984,8 @@ SANE_Status Asic_ReadCalibrationData (ASIC * chip, SANE_Byte * pBuffer,
SANE_Status Asic_MotorMove (ASIC * chip, SANE_Bool isForward, SANE_Status Asic_MotorMove (ASIC * chip, SANE_Bool isForward,
unsigned int dwTotalSteps); unsigned int dwTotalSteps);
SANE_Status Asic_CarriageHome (ASIC * chip); SANE_Status Asic_CarriageHome (ASIC * chip);
SANE_Status Asic_SetShadingTable (ASIC * chip, unsigned short * lpWhiteShading, SANE_Status Asic_SetShadingTable (ASIC * chip, unsigned short * pWhiteShading,
unsigned short * lpDarkShading, unsigned short * pDarkShading,
unsigned short wXResolution, unsigned short wXResolution,
unsigned short wWidth); unsigned short wWidth);

628
backend/mustek_usb2_high.c
Wyświetl plik

Plik diff jest za duży Load Diff

4
backend/mustek_usb2_high.h
Wyświetl plik

@ -109,7 +109,7 @@ typedef struct
extern SANE_Bool g_isScanning; extern SANE_Bool g_isScanning;
extern unsigned short g_SWHeight; extern unsigned short g_SWHeight;
extern SANE_Byte * g_lpReadImageHead; extern SANE_Byte * g_pReadImageHead;
extern unsigned short g_wLineartThreshold; extern unsigned short g_wLineartThreshold;
extern unsigned short * g_pGammaTable; extern unsigned short * g_pGammaTable;
extern SCANSOURCE g_ssScanSource; extern SCANSOURCE g_ssScanSource;
@ -118,7 +118,7 @@ extern ASIC g_chip;
void MustScanner_Init (void); void MustScanner_Init (void);
SANE_Bool MustScanner_PowerControl (SANE_Bool isLampOn, SANE_Bool isTALampOn); SANE_Bool MustScanner_PowerControl (SANE_Bool isLampOn, SANE_Bool isTALampOn);
SANE_Bool MustScanner_BackHome (void); SANE_Bool MustScanner_BackHome (void);
SANE_Bool MustScanner_GetRows (SANE_Byte * lpBlock, unsigned short * Rows, SANE_Bool MustScanner_GetRows (SANE_Byte * pBlock, unsigned short * Rows,
SANE_Bool isOrderInvert); SANE_Bool isOrderInvert);
SANE_Bool MustScanner_ScanSuggest (TARGETIMAGE * pTarget); SANE_Bool MustScanner_ScanSuggest (TARGETIMAGE * pTarget);
SANE_Bool MustScanner_StopScan (void); SANE_Bool MustScanner_StopScan (void);