|
|
#include "precomp.h"
// #define DEBUG_MEMXFER
#define PRIVATE_CAP_ARRAY_PADDING 64 // 64 bytes padding
const TCHAR WIA_STR[] = TEXT("WIA-");const CHAR* FAMILY_NAME = "Twain Data Source On WIA";
CWiaDataSrc::CWiaDataSrc() :m_dsState(DS_STATE_0),m_hMemXferBits(NULL),m_pMemXferBits(NULL),m_pDevice(NULL),m_pIWiaItems(NULL),m_NumIWiaItems(0),m_NextIWiaItemIndex(0),m_NumCaps(0),m_CapList(NULL),m_hCachedImageData(NULL),m_bCacheImage(FALSE){ SetTWAINState(DS_STATE_3); memset(m_FileXferName,0,sizeof(m_FileXferName)); memset(&m_AppIdentity,0,sizeof(m_AppIdentity)); memset(&m_dsIdentity,0, sizeof(m_dsIdentity)); memset(&m_CurFrame, 0,sizeof(m_CurFrame)); memset(&m_CurImageLayout, 0,sizeof(m_CurImageLayout)); memset(&m_MemoryTransferInfo,0,sizeof(m_MemoryTransferInfo));
ResetMemXfer();
m_twStatus.ConditionCode = TWCC_SUCCESS;
m_CurImageLayout.DocumentNumber = 1; m_CurImageLayout.PageNumber = 1; m_CurImageLayout.FrameNumber = 1; m_CurImageLayout.Frame.Top.Whole = 0; m_CurImageLayout.Frame.Top.Frac = 0; m_CurImageLayout.Frame.Left.Whole = 0; m_CurImageLayout.Frame.Left.Frac = 0; m_CurImageLayout.Frame.Right.Whole = 8; m_CurImageLayout.Frame.Right.Frac = 5; m_CurImageLayout.Frame.Bottom.Whole = 11; m_CurImageLayout.Frame.Bottom.Frac = 0; m_pCurrentIWiaItem = NULL;}
CWiaDataSrc::~CWiaDataSrc(){ ResetMemXfer(); if (m_pDevice){ delete m_pDevice; m_pDevice = NULL; }
if (m_pIWiaItems){ delete [] m_pIWiaItems; m_pIWiaItems = NULL; }}
TW_UINT16 CWiaDataSrc::IWiaDataSrc(LPCTSTR DeviceId){ if (!DeviceId) { m_twStatus.ConditionCode = TWCC_BADVALUE; return TWRC_FAILURE; }
//
// Initialize m_dsIdentity. This is required because
// DG_CONTROL/DAT_IDENTITY/MSG_GET could be called
// before we are opened.
//
m_pDevice = new CWiaDevice;
if (!m_pDevice) { m_twStatus.ConditionCode = TWCC_LOWMEMORY; return TWRC_FAILURE; }
TCHAR szTempString[MAX_PATH]; memset(szTempString,0,sizeof(szTempString));
HRESULT hr = S_OK;
hr = m_pDevice->Initialize(DeviceId); if (FAILED(hr)) { m_twStatus.ConditionCode = TWCC_LOWMEMORY; delete m_pDevice; m_pDevice = NULL; DBG_ERR(("CWiaDataSrc::IWiaDataSrc(), WIA Device object Initialize failed")); return TWRC_FAILURE; }
//
// We don't need to attach a callback here because we will
// close the device after we are done with it.
//
if (SUCCEEDED(hr)) { m_dsIdentity.Id = 0; m_dsIdentity.Version.MajorNum = 1; m_dsIdentity.Version.MinorNum = 0; m_dsIdentity.Version.Language = TWLG_USA; m_dsIdentity.Version.Country = TWCY_USA; m_dsIdentity.ProtocolMajor = TWON_PROTOCOLMAJOR; m_dsIdentity.ProtocolMinor = TWON_PROTOCOLMINOR; m_dsIdentity.SupportedGroups = DG_CONTROL | DG_IMAGE; lstrcpyA(m_dsIdentity.Version.Info,"26 June 2000");
//
// Use a specific product family name so that applications
// can differentiate between a data source on WIA and
// a *pure* TWAIN data source
//
lstrcpyA(m_dsIdentity.ProductFamily, FAMILY_NAME); lstrcpyA(m_dsIdentity.ProductName, "UnknownProduct"); lstrcpyA(m_dsIdentity.Manufacturer, "UnknownMfg");
#ifdef UNICODE
//
// UNICODE specific
//
// This assumes that ProductName, FamilyName and Manufacturer
// are all in TW_STR32 (TWAIN data type for a string).
//
UINT Len = 0; memset(szTempString,0,sizeof(szTempString)); hr = m_pDevice->GetDeviceDesc(szTempString,sizeof(szTempString),&Len); if (SUCCEEDED(hr)) {
//
// Add "WIA-" to beginning of ProductName string, to separate
// TWAIN installed data sources, from WIA data sources
//
AddWIAPrefixToString(szTempString,sizeof(szTempString)); Len += lstrlen(WIA_STR); // add prefix size to length
//
// set ProductName in TW_IDENTITY structure
//
WideCharToMultiByte(CP_ACP, 0, szTempString, Len + 1,m_dsIdentity.ProductName, (sizeof(m_dsIdentity.ProductName)/sizeof(m_dsIdentity.ProductName[0])),NULL, NULL);
Len = 0; } else { DBG_ERR(("CWiaDataSrc::IWiaDataSrc(), GetDeviceDesc failed")); return TWRC_FAILURE; }
memset(szTempString,0,sizeof(szTempString)); hr = m_pDevice->GetDeviceVendorName(szTempString,sizeof(szTempString),&Len); if (SUCCEEDED(hr)) {
//
// set Manufacturer in TW_IDENTITY structure
//
WideCharToMultiByte(CP_ACP, 0, szTempString, Len + 1,m_dsIdentity.Manufacturer, (sizeof(m_dsIdentity.Manufacturer)/sizeof(m_dsIdentity.Manufacturer[0])),NULL, NULL); } else { DBG_ERR(("CWiaDataSrc::IWiaDataSrc(), GetDeviceVendorName failed")); return TWRC_FAILURE; }
#else
//
// ANSI specific
//
memset(szTempString,0,sizeof(szTempString)); hr = m_pDevice->GetDeviceDesc(szTempString,sizeof(szTempString),NULL); if (SUCCEEDED(hr) ) {
//
// Add "WIA-" to beginning of ProductName string, to separate
// TWAIN installed data sources, from WIA data sources
//
AddWIAPrefixToString(szTempString,sizeof(szTempString));
//
// set ProductName in TW_IDENTITY structure
//
strncpy(m_dsIdentity.ProductName,szTempString,sizeof(TW_STR32) - 1);
} else { DBG_ERR(("CWiaDataSrc::IWiaDataSrc(),GetDeviceDesc failed")); return TWRC_FAILURE; }
memset(szTempString,0,sizeof(szTempString)); hr = m_pDevice->GetDeviceVendorName(szTempString,sizeof(szTempString),NULL); if (SUCCEEDED(hr) ) {
//
// set Manufacturer in TW_IDENTITY structure
//
strncpy(m_dsIdentity.Manufacturer,szTempString,sizeof(TW_STR32) - 1); } else { DBG_ERR(("CWiaDataSrc::IWiaDataSrc(),GetDeviceVendorName failed")); }#endif
} return(SUCCEEDED(hr)) ? TWRC_SUCCESS : TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::AddWIAPrefixToString(LPTSTR szString,UINT uSize){ TCHAR szTempBuffer[512]; memset(szTempBuffer,0,sizeof(szTempBuffer)); _sntprintf(szTempBuffer,(sizeof(szTempBuffer)/sizeof(szTempBuffer[0])),TEXT("%s%s"),WIA_STR,szString); szTempBuffer[(sizeof(szTempBuffer)/sizeof(szTempBuffer[0])) - 1] = 0;
//
// copy, and truncate New string to TWAIN's required
// restricted size.
//
memset(szString,0,uSize);
#ifdef UNICODE
wcsncpy(szString,szTempBuffer,(sizeof(TW_STR32) - 1));#else
strncpy(szString,szTempBuffer,(sizeof(TW_STR32) - 1));#endif
return TWRC_SUCCESS;}
TW_UINT16 CWiaDataSrc::DSEntry(pTW_IDENTITY pOrigin,TW_UINT32 DG,TW_UINT16 DAT, TW_UINT16 MSG,TW_MEMREF pData){ TWAIN_MSG twMsg; twMsg.AppId = pOrigin; twMsg.DG = DG; twMsg.DAT = DAT; twMsg.MSG = MSG; twMsg.pData = pData;
TW_UINT16 twRc = TWRC_SUCCESS;
if (MSG_PROCESSEVENT == MSG) { //
// Since we rely on WIA UI to provide the user interface and since
// the WIA UI is a modal dialog box(meaning it has its own
// messge loop), every event we receive here is not DS event.
//
//((TW_EVENT*)twMsg.pData)->TWMessage = MSG_NULL;
twRc = TWRC_NOTDSEVENT; } else { //
// Dispatch message based on group
//
switch (twMsg.DG) { case DG_CONTROL: twRc = DispatchControlMsg(&twMsg); break; case DG_IMAGE: twRc = DispatchImageMsg(&twMsg); break; default: m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; break; } DBG_TRC(("Sent to TWAIN Application, DG = %X, DT = %X, MSG = %X, ( TWRC = %X, TWCC = %X)",DG,DAT,MSG,twRc,m_twStatus.ConditionCode)); } return twRc;}
#ifdef _USE_NONSPRINTF_CONVERSION
float CWiaDataSrc::Fix32ToFloat(TW_FIX32 fix32){ float ffloat = 0.0f;
//
// TWAIN spec implementation
//
ffloat = (float)fix32.Whole + (float)fix32.Frac / 65536.0f;
/*
//
// original implementation
//
int iexp = 1; int frac = fix32.Frac; while(frac/10 > 0){ iexp++; frac = (frac/10); } ffloat = (float)fix32.Whole + (float) ( (float) fix32.Frac / (float) pow(10,iexp));
*/
return ffloat;}
TW_FIX32 CWiaDataSrc::FloatToFix32(float ffloat){ TW_FIX32 fix32; memset(&fix32,0,sizeof(fix32));
//
// TWAIN spec implementation
//
TW_INT32 value = (TW_INT32) (ffloat * 65536.0f + 0.5f); fix32.Whole = (TW_INT16)(value >> 16); fix32.Frac = (TW_UINT16)(value & 0x0000ffffL);
/*
//
// original implementation
//
fix32.Whole = (TW_INT16)ffloat; //float fVal = -((float)fix32.Whole - ffloat);
float fVal = (ffloat - (float)fix32.Whole); fVal = (fVal * 100000.0f); fix32.Frac = (TW_UINT16)(fVal); */
return fix32;}
#else // _USE_NONSPRINTF_CONVERSION
TW_FIX32 CWiaDataSrc::FloatToFix32(float f){ char fstr[64]; memset(fstr,0,sizeof(fstr)); char *p = NULL; TW_FIX32 f32; memset(&f32,0,sizeof(f32));
sprintf(fstr, "%f", f); p = strchr(fstr, '.'); if (p != NULL) { *p = '\0'; f32.Whole = (TW_INT16)atoi(fstr); f32.Frac = (TW_UINT16)atoi(p + 1); } return f32;}
float CWiaDataSrc::Fix32ToFloat(TW_FIX32 fix32){
// (full precision)
char fstr[64]; memset(fstr,0,sizeof(fstr)); float fReturnValue = 0.0f; sprintf(fstr,"%d.%d",fix32.Whole,fix32.Frac); sscanf(fstr,"%f",&fReturnValue);
// original (loses precision)
// fReturnValue = (float)fix32.Whole + (float)(fix32.Frac / 65536.0);
return fReturnValue;}#endif // _USE_NONSPRINTF_CONVERSION
void CWiaDataSrc::NotifyCloseReq(){ DBG_FN_DS(CWiaDataSrc::NotifyCloseReq()); if(m_DSM.Notify(&m_dsIdentity, &m_AppIdentity, (TW_UINT32)DG_CONTROL, DAT_NULL,MSG_CLOSEDSREQ, (TW_MEMREF)NULL)){ DBG_TRC(("CWiaDataSrc::NotifyCloseReq(), MSG_CLOSEDSREQ is sent to application")); } else { DBG_WRN(("CWiaDataSrc::NotifyCloseReq(), could not notify application for MSG_CLOSEDSREQ")); }}
void CWiaDataSrc::NotifyXferReady(){ DBG_FN_DS(CWiaDataSrc::NotifyXferReady()); if (m_DSM.Notify(&m_dsIdentity,&m_AppIdentity, (TW_UINT32)DG_CONTROL,DAT_NULL,MSG_XFERREADY,(TW_MEMREF)NULL)) {
DBG_TRC(("CWiaDataSrc::NotifyXferReady(), MSG_XFERREADY is sent to application"));
//
// transition to STATE_6
//
SetTWAINState(DS_STATE_6);
} else { DBG_WRN(("CWiaDataSrc::NotifyXferReady(), could not notify application for MSG_XFERREADY")); }}
void CWiaDataSrc::ResetMemXfer(){ DBG_FN_DS(CWiaDataSrc::ResetMemXfer()); if (IS_VALID_HANDLE(m_hMemXferBits)) { if (m_pMemXferBits) { if (GlobalUnlock(m_hMemXferBits)) { m_pMemXferBits = NULL; } } // Now free block always
GlobalFree(m_hMemXferBits); } m_hMemXferBits = NULL; m_hCachedImageData = NULL; m_LinesTransferred = 0;}
TW_UINT16 CWiaDataSrc::DispatchControlMsg(PTWAIN_MSG ptwMsg){ TW_UINT16 twRc = TWRC_SUCCESS;
if (!ptwMsg) { m_twStatus.ConditionCode = TWCC_BADPROTOCOL; return TWRC_FAILURE; } switch (ptwMsg->DAT) { case DAT_IDENTITY: twRc = OnIdentityMsg(ptwMsg); break; case DAT_USERINTERFACE: twRc = OnUserInterfaceMsg(ptwMsg); break; case DAT_CAPABILITY: twRc = OnCapabilityMsg(ptwMsg); break; case DAT_STATUS: twRc = OnStatusMsg(ptwMsg); break; case DAT_PENDINGXFERS: twRc = OnPendingXfersMsg(ptwMsg); break; case DAT_SETUPMEMXFER: twRc = OnSetupMemXferMsg(ptwMsg); break; case DAT_SETUPFILEXFER: twRc = OnSetupFileXferMsg(ptwMsg); break; case DAT_XFERGROUP: twRc = OnXferGroupMsg(ptwMsg); break; default: twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; } return twRc;}
TW_UINT16 CWiaDataSrc::DispatchImageMsg(PTWAIN_MSG ptwMsg){ TW_UINT16 twRc = TWRC_SUCCESS;
if (!ptwMsg) { m_twStatus.ConditionCode = TWCC_BADPROTOCOL; return TWRC_FAILURE; }
switch (ptwMsg->DAT) { case DAT_IMAGEINFO: twRc = OnImageInfoMsg(ptwMsg); break; case DAT_IMAGELAYOUT: twRc = OnImageLayoutMsg(ptwMsg); break; case DAT_IMAGEMEMXFER: twRc = OnImageMemXferMsg(ptwMsg); break; case DAT_IMAGENATIVEXFER: twRc = OnImageNativeXferMsg(ptwMsg); break; case DAT_IMAGEFILEXFER: twRc = OnImageFileXferMsg(ptwMsg); break; case DAT_PALETTE8: twRc = OnPalette8Msg(ptwMsg); break; case DAT_GRAYRESPONSE: twRc = OnGrayResponseMsg(ptwMsg); break; case DAT_RGBRESPONSE: twRc = OnRGBResponseMsg(ptwMsg); break; case DAT_CIECOLOR: twRc = OnCIEColorMsg(ptwMsg);; break; case DAT_JPEGCOMPRESSION: twRc = OnJPEGCompressionMsg(ptwMsg); break; default: twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; } return twRc;}
TW_UINT16 CWiaDataSrc::OnPalette8Msg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnPalette8Msg()); TW_UINT16 twRc = TWRC_SUCCESS; switch (GetTWAINState()) { case DS_STATE_4: case DS_STATE_5: case DS_STATE_6: case DS_STATE_7: switch (ptwMsg->MSG) { case MSG_GET:
// TWPA_RGB - color palette
// TWPA_GRAY - grayscale palette
// TWPA_CMY - CMY palette
((TW_PALETTE8 *)ptwMsg->pData)->NumColors = 0; ((TW_PALETTE8 *)ptwMsg->pData)->PaletteType = TWPA_RGB; break; case MSG_GETDEFAULT: case MSG_RESET: case MSG_SET: break; default: m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; DSError(); } break; default: m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::OnSetupMemXferMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnSetupMemXferMsg()); TW_UINT16 twRc = TWRC_SUCCESS; TW_SETUPMEMXFER *pMemSetup = (TW_SETUPMEMXFER *)ptwMsg->pData;
switch (GetTWAINState()) { case DS_STATE_4: case DS_STATE_5: case DS_STATE_6: if (MSG_GET == ptwMsg->MSG) { if (pMemSetup) { pMemSetup->MinBufSize = MIN_MEMXFER_SIZE; pMemSetup->MaxBufSize = MAX_MEMXFER_SIZE; pMemSetup->Preferred = PREFERRED_MEMXFER_SIZE; } else { m_twStatus.ConditionCode = TWCC_BADVALUE; twRc = TWRC_FAILURE; } } else { m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; DSError(); } break; default: m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::OnSetupFileXferMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnSetupFileXferMsg()); TW_UINT16 twRc = TWRC_SUCCESS; CCap *pImageXferCap = NULL; TW_SETUPFILEXFER *pFileXfer = NULL; switch (GetTWAINState()) { case DS_STATE_4: case DS_STATE_5: case DS_STATE_6: pFileXfer = (TW_SETUPFILEXFER *)ptwMsg->pData; pImageXferCap = FindCap(ICAP_IMAGEFILEFORMAT); switch (ptwMsg->MSG) { case MSG_GET: case MSG_GETDEFAULT: case MSG_GETCURRENT: if (pImageXferCap) { pFileXfer->Format = (TW_UINT16)pImageXferCap->GetCurrent(); pFileXfer->VRefNum = 0; pFileXfer->FileName[0] = 0; strcpy(pFileXfer->FileName, m_FileXferName); } else { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BUMMER; } break; case MSG_SET: { strcpy(m_FileXferName, pFileXfer->FileName); pImageXferCap->SetCurrent((VOID*)&pFileXfer->Format); } break; default: twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; DSError(); break; } break; default: twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_SEQERROR; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::OnXferGroupMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnXferGroupMsg()); TW_UINT16 twRc = TWRC_SUCCESS; switch (GetTWAINState()) { case DS_STATE_4: case DS_STATE_5: case DS_STATE_6: switch (ptwMsg->MSG) { case MSG_GET: case MSG_GETDEFAULT: case MSG_GETCURRENT: case MSG_RESET: *((TW_UINT16 *)ptwMsg->pData) = DG_IMAGE; break; case MSG_SET: break; default: m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; DSError(); break; } break; default: m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::OnImageInfoMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnImageInfoMsg()); TW_UINT16 twRc = TWRC_FAILURE; TW_IMAGEINFO *ptwImageInfo = NULL; if (DS_STATE_6 == GetTWAINState()) { if (MSG_GET == ptwMsg->MSG) { ptwImageInfo = (TW_IMAGEINFO *)ptwMsg->pData; HRESULT hr = S_OK; hr = m_pDevice->GetImageInfo(m_pCurrentIWiaItem, &m_MemoryTransferInfo); if (SUCCEEDED(hr)) {
ptwImageInfo->ImageWidth = (TW_INT32)m_MemoryTransferInfo.mtiWidthPixels; ptwImageInfo->ImageLength = (TW_INT32)m_MemoryTransferInfo.mtiHeightPixels; ptwImageInfo->BitsPerPixel = (TW_INT16)m_MemoryTransferInfo.mtiBitsPerPixel; ptwImageInfo->SamplesPerPixel = (TW_INT16)m_MemoryTransferInfo.mtiNumChannels; ptwImageInfo->Planar = (TW_BOOL)m_MemoryTransferInfo.mtiPlanar;
//
// adjust height for unknown length acquisitions
//
if(ptwImageInfo->ImageLength == 0){ DBG_WRN(("CWiaDataSrc::OnImageInfoMsg(), Possible unknown length device detected..checking cached height value")); ptwImageInfo->ImageLength = m_ImageHeight; if(ptwImageInfo->ImageLength == 0){ DBG_WRN(("CWiaDataSrc::OnImageInfoMsg(), no cached height available, defaulting to -1 (ICAP_UNDEFINEDIMAGESIZE support only)")); ptwImageInfo->ImageLength = -1; // unknown page length (only valid if TWAIN applications support ICAP_UNDEFINEDIMAGESIZE)
} else { DBG_TRC(("CWiaDataSrc::OnImageInfoMsg(), new height = %d",ptwImageInfo->ImageLength)); } }
//
// set PixelType to corresponding TWAIN pixel type
//
switch(m_MemoryTransferInfo.mtiDataType) { case WIA_DATA_THRESHOLD: ptwImageInfo->PixelType = TWPT_BW; break; case WIA_DATA_GRAYSCALE: ptwImageInfo->PixelType = TWPT_GRAY; break; case WIA_DATA_COLOR: default: ptwImageInfo->PixelType = TWPT_RGB; break; }
//
// set compression to NONE
//
ptwImageInfo->Compression = TWCP_NONE;
//
// Unit conversion.......
//
ptwImageInfo->XResolution = FloatToFix32((float)m_MemoryTransferInfo.mtiXResolution); ptwImageInfo->YResolution = FloatToFix32((float)m_MemoryTransferInfo.mtiYResolution);
twRc = TWRC_SUCCESS;
} else { m_twStatus.ConditionCode = TWCC_OPERATIONERROR; twRc = TWRC_FAILURE; }
if (TWRC_SUCCESS == twRc) { DBG_TRC(("CWiaDataSrc::OnImageInfoMsg(), Reported Image Information from data source")); DBG_TRC(("XResolution = %d.%d",ptwImageInfo->XResolution.Whole,ptwImageInfo->XResolution.Frac)); DBG_TRC(("YResolution = %d.%d",ptwImageInfo->YResolution.Whole,ptwImageInfo->YResolution.Frac)); DBG_TRC(("ImageWidth = %d",ptwImageInfo->ImageWidth)); DBG_TRC(("ImageLength = %d",ptwImageInfo->ImageLength)); DBG_TRC(("SamplesPerPixel = %d",ptwImageInfo->SamplesPerPixel));
memset(ptwImageInfo->BitsPerSample,0,sizeof(ptwImageInfo->BitsPerSample));
if (ptwImageInfo->BitsPerPixel < 24) { ptwImageInfo->BitsPerSample[0] = ptwImageInfo->BitsPerPixel; } else { for (int i = 0; i < ptwImageInfo->SamplesPerPixel; i++) { ptwImageInfo->BitsPerSample[i] = (ptwImageInfo->BitsPerPixel/ptwImageInfo->SamplesPerPixel); } } // (bpp / spp) = bps
DBG_TRC(("BitsPerSample = [%d],[%d],[%d],[%d],[%d],[%d],[%d],[%d]",ptwImageInfo->BitsPerSample[0], ptwImageInfo->BitsPerSample[1], ptwImageInfo->BitsPerSample[2], ptwImageInfo->BitsPerSample[3], ptwImageInfo->BitsPerSample[4], ptwImageInfo->BitsPerSample[5], ptwImageInfo->BitsPerSample[6], ptwImageInfo->BitsPerSample[7])); DBG_TRC(("BitsPerPixel = %d",ptwImageInfo->BitsPerPixel)); DBG_TRC(("Planar = %d",ptwImageInfo->Planar)); DBG_TRC(("PixelType = %d",ptwImageInfo->PixelType)); DBG_TRC(("Compression = %d",ptwImageInfo->Compression)); } } else { m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; } } else { m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; } if (TWRC_SUCCESS != twRc) { DSError(); } return twRc;}
TW_UINT16 CWiaDataSrc::OnImageLayoutMsg(PTWAIN_MSG ptwMsg){ m_twStatus.ConditionCode = TWCC_BUMMER; return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::OnGrayResponseMsg(PTWAIN_MSG ptwMsg){ m_twStatus.ConditionCode = TWCC_BUMMER; return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::OnRGBResponseMsg(PTWAIN_MSG ptwMsg){ m_twStatus.ConditionCode = TWCC_BUMMER; return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::OnCIEColorMsg(PTWAIN_MSG ptwMsg){ m_twStatus.ConditionCode = TWCC_BUMMER; return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::OnJPEGCompressionMsg(PTWAIN_MSG ptwMsg){ m_twStatus.ConditionCode = TWCC_BUMMER; return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::OnIdentityMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnIdentityMsg()); TW_UINT16 twRc = TWRC_SUCCESS; if (ptwMsg) { switch (ptwMsg->MSG) { case MSG_OPENDS:
#ifdef DEBUG_ME
MessageBox(NULL,TEXT("MSG_OPENDS - Attach me to a debugger"),TEXT("Attach me to a debugger"),MB_OK);#endif
twRc = OpenDS(ptwMsg); break; case MSG_CLOSEDS: twRc = CloseDS(ptwMsg); break; case MSG_GET: if (!IsBadWritePtr(ptwMsg->pData, sizeof(TW_IDENTITY))) { *(TW_IDENTITY*)ptwMsg->pData = m_dsIdentity; DBG_TRC(("CWiaDataSrc::OnIdentityMsg(), Reported TW_IDENTITY from data source")); DBG_TRC(("Id = %d",m_dsIdentity.Id)); DBG_TRC(("Manufacturer = %s",m_dsIdentity.Manufacturer)); DBG_TRC(("ProductFamily = %s",m_dsIdentity.ProductFamily)); DBG_TRC(("ProductName = %s",m_dsIdentity.ProductName)); DBG_TRC(("ProtocolMajor = %d",m_dsIdentity.ProtocolMajor)); DBG_TRC(("ProtocolMinor = %d",m_dsIdentity.ProtocolMinor)); DBG_TRC(("SupportedGrps = %d",m_dsIdentity.SupportedGroups)); DBG_TRC(("Ver Country = %d",m_dsIdentity.Version.Country)); DBG_TRC(("Ver Info = %s",m_dsIdentity.Version.Info)); DBG_TRC(("Ver Language = %d",m_dsIdentity.Version.Language)); DBG_TRC(("Ver MajorNum = %d",m_dsIdentity.Version.MajorNum)); DBG_TRC(("Ver MinorNum = %d",m_dsIdentity.Version.MinorNum)); twRc = TWRC_SUCCESS; } else { twRc = TWCC_BADVALUE; } break; default: m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; DSError(); break; } } return twRc;}
TW_UINT16 CWiaDataSrc::OnUserInterfaceMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnUserInterfaceMsg()); TW_UINT16 twRc = TWRC_SUCCESS;
switch (ptwMsg->MSG) { case MSG_ENABLEDS: switch (GetTWAINState()) { case DS_STATE_5: case DS_STATE_6: case DS_STATE_7: m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; break; default: twRc = EnableDS((TW_USERINTERFACE*)ptwMsg->pData); break; } break; case MSG_DISABLEDS: twRc = DisableDS((TW_USERINTERFACE*)ptwMsg->pData); break; default: m_twStatus.ConditionCode = TWCC_BADPROTOCOL; twRc = TWRC_FAILURE; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::OnCapabilityMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnCapabilityMsg()); TW_UINT16 twRc = TWRC_SUCCESS; TW_UINT16 twCC = TWCC_SUCCESS;
TW_CAPABILITY *ptwCap = (TW_CAPABILITY *)ptwMsg->pData; if (!ptwCap) { m_twStatus.ConditionCode = TWCC_BADCAP; return TWRC_FAILURE; } if (CAP_SUPPORTEDCAPS == ptwCap->Cap) { switch(ptwMsg->MSG) { case MSG_SET: case MSG_RESET: { //
// MSG_SET, MSG_RESET shouldn't be able to be called on CAP_SUPPORTEDCAPS!!
//
twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_CAPBADOPERATION; return twRc; } default: break; }
//
// get number of PRIVATE TWAIN capabilities from WIA driver
// and add them to our CAP_SUPPORTEDCAPS list.
//
LONG lNumPrivateCaps = 0; LONG *pPrivateCapArray = NULL; lNumPrivateCaps = GetPrivateSupportedCapsFromWIADevice(&pPrivateCapArray);
ptwCap->ConType = TWON_ARRAY; ptwCap->hContainer = GlobalAlloc(GHND, sizeof(TW_ARRAY) + sizeof(TW_UINT16) * (m_NumCaps + lNumPrivateCaps) ); if (ptwCap->hContainer) { TW_ARRAY *pCapIdArray = (TW_ARRAY *) GlobalLock(ptwCap->hContainer); if (pCapIdArray) { TW_UINT32 i = 0; pCapIdArray->ItemType = TWTY_UINT16; TW_UINT16 *ItemList; ItemList = (TW_UINT16 *)pCapIdArray->ItemList;
//
// fill in TWAIN compat layer's supported CAPS first
//
for (i = 0; i < m_NumCaps; i++) { ItemList[i] = m_CapList[i].GetCapId(); }
//
// fill in WIA driver's private supported CAPS next
//
int PrivateCapIndex = 0; for(i = m_NumCaps; i < (m_NumCaps + lNumPrivateCaps);i++){ ItemList[i] = (TW_UINT16)pPrivateCapArray[PrivateCapIndex]; DBG_TRC(("(%d) Private Capability ID reported = %x",(PrivateCapIndex + 1), ItemList[i])); PrivateCapIndex++; }
//
// finally set NumItems
//
pCapIdArray->NumItems = (m_NumCaps + lNumPrivateCaps);
GlobalUnlock(ptwCap->hContainer); } else { GlobalFree(ptwCap->hContainer); ptwCap->hContainer = NULL; twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_LOWMEMORY; } } else { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_LOWMEMORY; }
//
// delete Private capability array, if it was allocated
//
if(pPrivateCapArray){ GlobalFree(pPrivateCapArray); pPrivateCapArray = NULL; }
return twRc; }
CCap *pCap = FindCap(ptwCap->Cap); if (!pCap) { DBG_TRC(("Couldn't find the CCap object for CAP ID %x in TWAIN Compat layer CAP list, try WIA driver's private TWAIN cap list", ptwCap->Cap)); if (m_pDevice->TwainCapabilityPassThrough()) { return OnPrivateCapabilityMsg(ptwMsg); } else { m_twStatus.ConditionCode = TWCC_BADCAP; return TWRC_FAILURE; } } switch (ptwMsg->MSG) { case MSG_GET: if(ptwCap->Cap == ICAP_IMAGEDATASET) twCC = pCap->GetCurrent(ptwCap); else twCC = pCap->Get(ptwCap); break; case MSG_GETDEFAULT: twCC = pCap->GetDefault(ptwCap); break; case MSG_GETCURRENT: twCC = pCap->GetCurrent(ptwCap); break; case MSG_SET: switch (GetTWAINState()) { case DS_STATE_7: twCC = TWCC_SEQERROR; twRc = TWRC_FAILURE; break; default: twCC = SetCapability(pCap, ptwCap); break; } break; case MSG_RESET: switch (GetTWAINState()) { case DS_STATE_5: case DS_STATE_6: case DS_STATE_7: twCC = TWCC_SEQERROR; twRc = TWRC_FAILURE; break; default: { // ptwCap->Cap,
// ptwCap->ConType,
// ptwCap->hContainer);
twCC = pCap->Reset();
//
// According to the TWAIN spec, a MSG_RESET can be sent down meaning more than just
// RESET!!! It is stated that it can mean GET_DEFAULT/CURRENT, and RESET in a single call.
// Applications choose to ignore the value returned if they don't care, But if they
// attempt to read the value as the DEFAULT/CURRENT value...it must be set correctly in the
// container.
//
//
// fill the container with the current value, after the
// RESET call.
//
twCC = pCap->GetCurrent(ptwCap);
// ptwCap->ConType);
} break; } break; default: twCC = TWCC_BADPROTOCOL; DSError(); break; }
m_twStatus.ConditionCode = twCC;
if (TWCC_SUCCESS != twCC) { twRc = TWRC_FAILURE; } return twRc;}
TW_UINT16 CWiaDataSrc::OnPrivateCapabilityMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnPrivateCapabilityMsg()); TW_UINT16 twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADCAP;
if (ptwMsg) {
if (ptwMsg->MSG == MSG_SET) { TW_CAPABILITY *ptwCap = (TW_CAPABILITY *)ptwMsg->pData; if (ptwCap) { if ((NULL == ptwCap->hContainer)||(INVALID_HANDLE_VALUE == ptwCap->hContainer)) { return twRc; } } }
if (m_pCurrentIWiaItem) {
//
// Get the IWiaItemExtras Interface
//
IWiaItemExtras *pIWiaItemExtras = NULL; HRESULT hr = m_pCurrentIWiaItem->QueryInterface(IID_IWiaItemExtras,(void **)&pIWiaItemExtras); if (S_OK == hr) {
//
// we have an IWiaItemExtras Interface, so lets talk to the WIA device about
// the capability message
//
TW_CAPABILITY *ptwCap = (TW_CAPABILITY *)ptwMsg->pData; if (ptwCap) {
//
// Initialize the common header
//
TWAIN_CAPABILITY twCap; twCap.lSize = sizeof(twCap); // size of TWAIN_CAPABILITY structure
twCap.lMSG = ptwMsg->MSG; // TWAIN message
twCap.lCapID = ptwCap->Cap; // TWAIN capability ID
twCap.lConType = ptwCap->ConType; // TWAIN container type
twCap.lCC = TWCC_BADCAP; // TWAIN return code
twCap.lRC = TWRC_FAILURE; // TWAIN condition code
twCap.lDataSize= 0; // TWAIN capability data size
twCap.Data[0] = 0; // TWAIN capability data (first byte)
DBG_TRC(("== Private TWAIN_CAPABILITY data Header ==")); DBG_TRC(("twCap.lSize = %d", twCap.lSize)); DBG_TRC(("twCap.lMSG = %d", twCap.lMSG)); DBG_TRC(("twCap.lCapID = %x", twCap.lCapID)); DBG_TRC(("twCap.lConType = %d", twCap.lConType)); DBG_TRC(("twCap.lCC = %d", twCap.lCC)); DBG_TRC(("twCap.lRC = %d", twCap.lRC));
DWORD dwInDataSize = 0; DWORD dwOutDataSize = 0; DWORD dwContainerSize = 0; DWORD dwActualOutDataSize = 0;
BYTE *pInData = NULL; BYTE *pOutData = NULL; BYTE *pContainerData = NULL; TWAIN_CAPABILITY *pHeader = NULL;
//
// Depending on the Message type GET ot SET we do different things
//
//
// For a SET or RESET message, we just send the IN buffer, with an OUT buffer
// containing the header.
//
if ((ptwMsg->MSG == MSG_SET) || (ptwMsg->MSG == MSG_RESET)) {
dwContainerSize = 0;
if (ptwMsg->MSG == MSG_SET) {
//
// only check container size, when the TWAIN message is a MSG_SET
// MSG_RESET operations do not have containers attached.
//
dwContainerSize = (DWORD)GlobalSize(ptwCap->hContainer); }
dwInDataSize = dwContainerSize + sizeof(twCap); dwOutDataSize = sizeof(twCap); dwActualOutDataSize = dwOutDataSize;
twCap.lDataSize = dwContainerSize; DBG_TRC(("twCap.lDataSize = %d", twCap.lDataSize));
DBG_TRC(("== Processing MSG_SET or MSG_RESET Capability Message ==")); DBG_TRC(("dwInDataSize = %d",dwInDataSize)); DBG_TRC(("dwOutDataSize = %d",dwOutDataSize)); DBG_TRC(("dwActualOutDataSize = %d",dwActualOutDataSize)); DBG_TRC(("dwContainerSize = %d",dwContainerSize));
//
// allocate IN buffer and write TWAIN_CAPABILITY header
//
if (TWRC_SUCCESS == AllocatePrivateCapBuffer(&twCap,&pInData,dwInDataSize)) {
if (ptwMsg->MSG == MSG_SET) {
//
// copy TWAIN container data to IN buffer
//
if (TWRC_SUCCESS == CopyContainerToPrivateCapBuffer(pInData,ptwCap->hContainer)) {
//
// container data was copied to IN buffer
//
DBG_TRC(("Container data was successfully copied, we are processing a MSG_SET"));
} else {
//
// could not copy TWAIN container data into private capability IN buffer
//
DBG_ERR(("could not copy TWAIN container data into private capability IN buffer"));
if(pInData){ GlobalFree(pInData); pInData = NULL; }
return twRc; // return here, becuase we can not continue
}
} else {
//
// no container data needs to be copied
//
DBG_TRC(("No Container data was copied, because we are processing a MSG_RESET"));
}
//
// allocate OUT buffer and write TWAIN_CAPABILITY header
//
if (TWRC_SUCCESS == AllocatePrivateCapBuffer(&twCap,&pOutData,dwOutDataSize)) { hr = pIWiaItemExtras->Escape(ESC_TWAIN_CAPABILITY, pInData, dwInDataSize, pOutData, dwOutDataSize, &dwActualOutDataSize); if (S_OK == hr) { pHeader = (TWAIN_CAPABILITY*)pOutData; DBG_TRC(("== Returned TWAIN_CAPABILITY data Header from WIA device ==")); DBG_TRC(("pHeader->lSize = %d", pHeader->lSize)); DBG_TRC(("pHeader->lMSG = %d", pHeader->lMSG)); DBG_TRC(("pHeader->lCapID = %x", pHeader->lCapID)); DBG_TRC(("pHeader->lConType = %d", pHeader->lConType)); DBG_TRC(("pHeader->lCC = %d", pHeader->lCC)); DBG_TRC(("pHeader->lRC = %d", pHeader->lRC)); DBG_TRC(("pHeader->lDataSize = %d", pHeader->lDataSize));
twRc = (TW_UINT16)pHeader->lRC; m_twStatus.ConditionCode = (TW_UINT16)pHeader->lCC; } else {
//
// pIWiaItemExtras->Escape call failed,
// a failure means that we do not respond with a success to the TWAIN application
//
DBG_ERR(("pIWiaItemExtras->Escape Failed")); DBG_TRC(("Escape(code = %d, pInData = %p, dwInDataSize = %d, pOutData = %p, dwOutDataSize = %d,dwActualOutDataSize = %p)", ESC_TWAIN_CAPABILITY, pInData, dwInDataSize, pOutData, dwOutDataSize, &dwActualOutDataSize)); } } else {
//
// could not allocate memory for private capability OUT buffer
//
DBG_ERR(("could not allocate memory for private capability OUT buffer"));
}
} else {
//
// could not allocate memory for private capability IN buffer
//
DBG_ERR(("could not allocate memory for private capability IN buffer"));
} } else if ((ptwMsg->MSG == MSG_GET) || (ptwMsg->MSG == MSG_GETCURRENT) || (ptwMsg->MSG == MSG_GETDEFAULT)) {
dwContainerSize = 0; dwInDataSize = sizeof(twCap); dwOutDataSize = dwInDataSize; dwActualOutDataSize = dwInDataSize;
twCap.lDataSize = dwContainerSize; DBG_TRC(("twCap.lDataSize = %d", twCap.lDataSize));
DBG_TRC(("== Processing MSG_GET, MSG_GETCURRENT, or MSG_GETDEFAULT Capability Message ==")); DBG_TRC(("dwInDataSize = %d",dwInDataSize)); DBG_TRC(("dwOutDataSize = %d",dwOutDataSize)); DBG_TRC(("dwActualOutDataSize = %d",dwActualOutDataSize)); DBG_TRC(("dwContainerSize = %d",dwContainerSize));
//
// allocate IN buffer and write TWAIN_CAPABILITY header
//
if (TWRC_SUCCESS == AllocatePrivateCapBuffer(&twCap,&pInData,dwInDataSize)) {
//
// ask the WIA driver how large is the data, so
// we can allocate the proper OUT buffer
//
//
// allocate OUT buffer and write TWAIN_CAPABILITY header
//
if (TWRC_SUCCESS == AllocatePrivateCapBuffer(&twCap,&pOutData,dwOutDataSize)) {
hr = pIWiaItemExtras->Escape(ESC_TWAIN_CAPABILITY, pInData, dwInDataSize, pOutData, dwOutDataSize, &dwActualOutDataSize); if (S_OK == hr) {
//
// make sure that the returned data is large enough to
// contain a proper header.
//
if (dwActualOutDataSize == dwInDataSize) {
pHeader = (TWAIN_CAPABILITY*)pOutData; DBG_TRC(("== Returned TWAIN_CAPABILITY data Header from WIA device ==")); DBG_TRC(("pHeader->lSize = %d", pHeader->lSize)); DBG_TRC(("pHeader->lMSG = %d", pHeader->lMSG)); DBG_TRC(("pHeader->lCapID = %x", pHeader->lCapID)); DBG_TRC(("pHeader->lConType = %d", pHeader->lConType)); DBG_TRC(("pHeader->lCC = %d", pHeader->lCC)); DBG_TRC(("pHeader->lRC = %d", pHeader->lRC)); DBG_TRC(("pHeader->lDataSize = %d", pHeader->lDataSize));
if (pHeader->lDataSize > 0) {
//
// update common header data size from information returned
// to create OUT buffer header
//
twCap.lDataSize = pHeader->lDataSize;
//
// set new out data size to (data + header) size
//
dwOutDataSize = (pHeader->lDataSize + sizeof(twCap));
//
// update InBuffer header data size from the common header
//
pHeader = (TWAIN_CAPABILITY*)pInData; pHeader->lDataSize = twCap.lDataSize;
//
// free old out buffer, before allocating new one
//
if (pOutData) { GlobalFree(pOutData); pOutData = NULL; }
//
// allocate OUT buffer and write TWAIN_CAPABILITY header
//
if (TWRC_SUCCESS == AllocatePrivateCapBuffer(&twCap,&pOutData,dwOutDataSize)) { hr = pIWiaItemExtras->Escape(ESC_TWAIN_CAPABILITY, pInData, dwInDataSize, pOutData, dwOutDataSize, &dwActualOutDataSize); if (S_OK == hr) { pHeader = (TWAIN_CAPABILITY*)pOutData; DBG_TRC(("== Returned TWAIN_CAPABILITY data Header from WIA device ==")); DBG_TRC(("pHeader->lSize = %d", pHeader->lSize)); DBG_TRC(("pHeader->lMSG = %d", pHeader->lMSG)); DBG_TRC(("pHeader->lCapID = %x", pHeader->lCapID)); DBG_TRC(("pHeader->lConType = %d", pHeader->lConType)); DBG_TRC(("pHeader->lCC = %d", pHeader->lCC)); DBG_TRC(("pHeader->lRC = %d", pHeader->lRC)); DBG_TRC(("pHeader->lDataSize = %d", pHeader->lDataSize)); twRc = (TW_UINT16)pHeader->lRC; m_twStatus.ConditionCode = (TW_UINT16)pHeader->lCC; if (TWRC_SUCCESS == twRc) { if (TWRC_SUCCESS == CopyPrivateCapBufferToContainer(&ptwCap->hContainer,pOutData,pHeader->lDataSize)) { ptwCap->ConType = (TW_UINT16)pHeader->lConType; } else {
//
// could not copy private capability buffer into TWAIN container data
//
DBG_ERR(("could not copy private capability buffer into TWAIN container data"));
} } else {
//
// WIA driver failed the TWAIN capability request, by returning a TWAIN failure
// return code in the OUT header.
//
DBG_ERR(("WIA driver failed the TWAIN capability request, by returning a TWAIN failure return code in the OUT header."));
} } else {
//
// pIWiaItemExtras->Escape call failed, (sending passthrough operation)
// a failure means that we do not respond with a success to the TWAIN application
//
DBG_ERR(("pIWiaItemExtras->Escape Failed (sending passthrough operation)")); DBG_TRC(("Escape(code = %d, pInData = %p, dwInDataSize = %d, pOutData = %p, dwOutDataSize = %d,dwActualOutDataSize = %d)", ESC_TWAIN_CAPABILITY, pInData, dwInDataSize, pOutData, dwOutDataSize, dwActualOutDataSize));
} } else {
//
// could not allocate memory for private capability OUT buffer
//
DBG_ERR(("could not allocate memory for private capability OUT buffer"));
} } else {
//
// OUT buffer size returned from the WIA driver is too small to contain a
// proper header.
//
DBG_ERR(("OUT buffer size (%d) returned from the WIA driver is too small to contain data",pHeader->lDataSize));
} } else {
//
// OUT buffer size returned from the WIA driver is too small to contain a
// proper header.
//
DBG_ERR(("OUT buffer size (%d) returned from the WIA driver is too small to contain a proper header",dwActualOutDataSize));
} } else {
//
// pIWiaItemExtras->Escape call failed, (requesting OUT buffer size)
// a failure means that we do not respond with a success to the TWAIN application
//
DBG_ERR(("pIWiaItemExtras->Escape Failed (requesting OUT buffer size)")); DBG_TRC(("Escape(code = %d, pInData = %p, dwInDataSize = %d, pOutData = %p, dwOutDataSize = %d,dwActualOutDataSize = %d)", ESC_TWAIN_CAPABILITY, pInData, dwInDataSize, pInData, dwInDataSize, dwActualOutDataSize)); } } else {
//
// could not allocate memory for private capability OUT buffer
//
DBG_ERR(("could not allocate memory for private capability OUT buffer"));
} } else {
//
// could not allocate memory for private capability IN buffer
//
DBG_ERR(("could not allocate memory for private capability IN buffer"));
} }
//
// free IN buffer
//
if (pInData) { GlobalFree(pInData); pInData = NULL; }
//
// free OUT buffer
//
if (pOutData) { GlobalFree(pOutData); pOutData = NULL; } } else {
//
// could not get TWAIN capability from TWAIN message
//
DBG_ERR(("could not get TWAIN capability from TWAIN message")); }
//
// release IWiaItemExtras Interface
//
if (pIWiaItemExtras) { pIWiaItemExtras->Release(); pIWiaItemExtras = NULL; } } else {
//
// QI for IWiaItemExtras Failed
//
DBG_ERR(("QueryInterface for IWiaItemExtras Failed"));
} } else {
//
// no current item selected
//
DBG_ERR(("no current item selected for use"));
} } else {
//
// imcoming TWAIN capability is NULL
//
DBG_ERR(("incoming TWAIN capability is NULL"));
} return twRc;}
TW_UINT16 CWiaDataSrc::AllocatePrivateCapBuffer(TWAIN_CAPABILITY *pHeader, BYTE** ppBuffer, DWORD dwSize){ DBG_FN_DS(CWiaDataSrc::AllocatePrivateCapBuffer()); if(dwSize < sizeof(TWAIN_CAPABILITY) || (!ppBuffer)|| (!pHeader)){ return TWRC_FAILURE; }
*ppBuffer = (BYTE*)GlobalAlloc(GPTR,dwSize); if(*ppBuffer){ memcpy(*ppBuffer, pHeader,sizeof(TWAIN_CAPABILITY)); } else { return TWRC_FAILURE; }
return TWRC_SUCCESS;}
TW_UINT16 CWiaDataSrc::CopyContainerToPrivateCapBuffer(BYTE* pBuffer, HGLOBAL hContainer){ DBG_FN_DS(CWiaDataSrc::CopyContainerToPrivateCapBuffer()); if((!pBuffer)||(!hContainer)){ return TWRC_FAILURE; }
DWORD dwContainerSize = (DWORD)GlobalSize(hContainer); BYTE *pContainerBuffer = (BYTE*)GlobalLock(hContainer); if(!pContainerBuffer){ return TWRC_FAILURE; }
TWAIN_CAPABILITY *pHeader = (TWAIN_CAPABILITY*)pBuffer; memcpy((BYTE*)pHeader->Data,pContainerBuffer,dwContainerSize);
//
// unlock handle before returning
//
GlobalUnlock(hContainer);
return TWRC_SUCCESS;}
TW_UINT16 CWiaDataSrc::CopyPrivateCapBufferToContainer(HGLOBAL *phContainer, BYTE* pBuffer, DWORD dwSize){ DBG_FN_DS(CWiaDataSrc::CopyPrivateCapBufferToContainer()); if((!phContainer) || (!pBuffer) || (dwSize <= 0)){ return TWRC_FAILURE; }
*phContainer = NULL; *phContainer = (HGLOBAL)GlobalAlloc(GHND,dwSize); if(!*phContainer){ return TWRC_FAILURE; }
BYTE *pContainerBuffer = (BYTE*)GlobalLock(*phContainer); if(!pContainerBuffer){ GlobalFree(*phContainer); *phContainer = NULL; return TWRC_FAILURE; }
TWAIN_CAPABILITY *pHeader = (TWAIN_CAPABILITY*)pBuffer;
memcpy(pContainerBuffer,(BYTE*)pHeader->Data,dwSize);
//
// unlock handle before returning
//
GlobalUnlock(*phContainer);
return TWRC_SUCCESS;}
TW_UINT16 CWiaDataSrc::SetCapability(CCap *pCap,TW_CAPABILITY *ptwCap){ DBG_FN_DS(CWiaDataSrc::SetCapability()); if (!pCap || !ptwCap) { m_twStatus.ConditionCode = TWCC_BADCAP; return TWRC_FAILURE; }
return pCap->Set(ptwCap);}
TW_UINT16 CWiaDataSrc::OnStatusMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnStatusMsg()); TW_UINT16 twRc = TWRC_SUCCESS;
if (MSG_GET == ptwMsg->MSG) { *((TW_STATUS*)ptwMsg->pData) = m_twStatus; twRc = TWRC_SUCCESS; } else { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; DSError(); } return twRc;}
TW_UINT16 CWiaDataSrc::OnPendingXfersMsg(PTWAIN_MSG ptwMsg){ m_twStatus.ConditionCode = TWCC_BUMMER; return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::OnImageMemXferMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnImageMemXferMsg()); TW_UINT16 twRc = TWRC_SUCCESS; HRESULT hr = E_FAIL; switch (GetTWAINState()) { case DS_STATE_6: case DS_STATE_7: { if (MSG_GET == ptwMsg->MSG) { TW_IMAGEMEMXFER *pMemXfer = (TW_IMAGEMEMXFER *)ptwMsg->pData;
if ((m_hMemXferBits == NULL)) {
m_LinesTransferred = 0;
GUID guidFormat = GUID_NULL;
DBG_WRN(("Transferring %d bit data",m_MemoryTransferInfo.mtiBitsPerPixel)); if (m_MemoryTransferInfo.mtiBitsPerPixel > 32) {
//
// Load image into memory for memory transfer (hi-color images)
//
guidFormat = WiaImgFmt_RAWRGB; } else {
//
// The TWAIN compatibility layer has the ability to transfer images
// 1,2,4,8,16,24 and 32 bit when using MEMORYBMP.
//
guidFormat = WiaImgFmt_MEMORYBMP; }
twRc = TransferToMemory(guidFormat);
if (TWRC_SUCCESS != twRc) { return twRc; } else {
//
// transition to STATE_7
//
SetTWAINState(DS_STATE_7); } }
//
// turn off the Image caching flag
//
m_bCacheImage = FALSE;
//
// Lock down the memory and get the address to the bits
//
GetMemoryTransferBits((BYTE*)GlobalLock(m_hMemXferBits));
m_pMemXferBits = m_MemoryTransferInfo.mtipBits;
if (m_pMemXferBits) { if(m_MemoryTransferInfo.mtiHeightPixels == 0){ m_MemoryTransferInfo.mtiHeightPixels = m_ImageHeight; }
if(m_MemoryTransferInfo.mtiguidFormat == WiaImgFmt_MEMORYBMP){
//
// adjust the image information to report the actual information
// reported in the BITMAPINFO header.
//
//
// only change these values, if the current information does not
// match the image header. (always take the header's values)
//
if(m_MemoryTransferInfo.mtiHeightPixels != m_ImageHeight){ m_MemoryTransferInfo.mtiHeightPixels = m_ImageHeight; }
if(m_MemoryTransferInfo.mtiWidthPixels != m_ImageWidth){ m_MemoryTransferInfo.mtiWidthPixels = m_ImageWidth; }
}
DBG_TRC(("CWiaDataSrc::OnImageMemXferMsg(), Transferring (%d) of (%d) total lines of image data.",m_LinesTransferred,m_MemoryTransferInfo.mtiHeightPixels)); if (m_LinesTransferred >= (TW_UINT32)m_MemoryTransferInfo.mtiHeightPixels) {
//
// we have completed the transfer, or we are out
// of scan lines to copy..so return XFERDONE
//
//
// unlock memory before bailing
//
// Keep unlock and NULLing together
GlobalUnlock(m_hMemXferBits); m_pMemXferBits = NULL;
ResetMemXfer(); m_twStatus.ConditionCode = TWCC_SUCCESS;
return TWRC_XFERDONE; } else {
//
// looks like we are working with transfer data
//
BYTE * pAppBuffer = NULL; if (pMemXfer->Memory.Flags & TWMF_HANDLE) {
DBG_TRC(("TWAIN Application wants to work with a HANDLE"));
//
// if the memory is a HANDLE, lock it first
//
pAppBuffer = (LPBYTE)GlobalLock(pMemXfer->Memory.TheMem); } else if (pMemXfer->Memory.Flags & TWMF_POINTER) {
DBG_TRC(("TWAIN Application wants to work with a POINTER"));
//
// if the memory is a POINTER, then proceed
//
pAppBuffer = (LPBYTE)pMemXfer->Memory.TheMem; } else {
DBG_TRC(("TWAIN Application gave us nothing to work with"));
//
// we have no memory, so set it to NULL
//
pAppBuffer = NULL; }
//
// if (there is no Memory to write to), or
// (the app doesn't own the memory), or
// (the length is less than MIN_ ), or
// (the length is greater than MAX),
// return a FAILURE!, and a CC of BADVALUE
//
if (!pAppBuffer || !(pMemXfer->Memory.Flags & TWMF_APPOWNS) || pMemXfer->Memory.Length < MIN_MEMXFER_SIZE || pMemXfer->Memory.Length > MAX_MEMXFER_SIZE) {
twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADVALUE;
} else {
//
// set memory Xfer values
//
UINT ScanlinesToCopy = 0; pMemXfer->BytesPerRow = GetLineSize(&m_MemoryTransferInfo); ScanlinesToCopy = min(pMemXfer->Memory.Length / pMemXfer->BytesPerRow, (TW_UINT32)(m_MemoryTransferInfo.mtiHeightPixels - m_LinesTransferred));
pMemXfer->Compression = TWCP_NONE; pMemXfer->Columns = m_MemoryTransferInfo.mtiWidthPixels; pMemXfer->Rows = ScanlinesToCopy; pMemXfer->XOffset = 0; pMemXfer->YOffset = m_LinesTransferred; pMemXfer->BytesWritten = pMemXfer->BytesPerRow * ScanlinesToCopy;
#ifdef DEBUG_MEMXFER
DBG_TRC(("CWiaDataSrc::OnImageMemXferMsg(), Reports TW_IMAGEMEMXFER")); DBG_TRC(("pMemXfer->Compression = %d",pMemXfer->Compression)); DBG_TRC(("pMemXfer->Columns = %d",pMemXfer->Columns)); DBG_TRC(("pMemXfer->Rows = %d",pMemXfer->Rows)); DBG_TRC(("pMemXfer->XOffset = %d",pMemXfer->XOffset)); DBG_TRC(("pMemXfer->YOffset = %d",pMemXfer->YOffset)); DBG_TRC(("pMemXfer->BytesPerRow = %d",pMemXfer->BytesPerRow)); DBG_TRC(("pMemXfer->BytesWritten = %d",pMemXfer->BytesWritten)); DBG_TRC(("pAppBuffer = %p, m_pMemXferBits = %p",pAppBuffer,m_pMemXferBits));#endif
//
// Transfer one-line strips in a loop to Application supplied buffer
//
LPBYTE pTo = pAppBuffer; LPBYTE pFrom = m_pMemXferBits + m_LinesTransferred * GetLineSize(&m_MemoryTransferInfo); for (UINT i=0;i < ScanlinesToCopy;i++ ) {
//
// swap color values, if needed
//
if (m_MemoryTransferInfo.mtiBitsPerPixel == 24) { for (ULONG ulIndex = 0; ulIndex < pMemXfer->BytesPerRow; ulIndex+= 3) {
// 1 2 3
// RED-GREEN-BLUE
//
BYTE bFirst = pFrom[ulIndex]; pFrom[ulIndex] = pFrom[ulIndex+2]; pFrom[ulIndex+2] = bFirst; } }
/*
if(m_MemoryTransferInfo.mtiBitsPerPixel == 48){ for(j = 0; j < pMemXfer->BytesPerRow; j+=6){
// 1 2 1 2 1 2
// REDRED-GREENGREEN-BLUEBLUE
//
BYTE bFirst = pFrom[j]; BYTE bSecond = pFrom[j+1]; pFrom[j] = pFrom[j+4]; pFrom[j+1] = pFrom[j+5]; pFrom[j+4] = bFirst; pFrom[j+5] = bSecond; } } */
//
// copy line to application supplied buffer
//
memcpy(pTo,pFrom,pMemXfer->BytesPerRow); pFrom+=GetLineSize(&m_MemoryTransferInfo); pTo+=pMemXfer->BytesPerRow; }
//
// calculate lines transferred
//
m_LinesTransferred += ScanlinesToCopy; if (m_LinesTransferred >= (TW_UINT32)m_MemoryTransferInfo.mtiHeightPixels) {
//
// we have completed the transfer, or we are out
// of scan lines to copy..so return XFERDONE
//
twRc = TWRC_XFERDONE; m_twStatus.ConditionCode = TWCC_SUCCESS;
// Keep unlock and NULLing together
GlobalUnlock(m_hMemXferBits); m_pMemXferBits = NULL;
ResetMemXfer();
//
// if we are working with an application provided HANDLE,
// GlobalUnlock it before continuing
//
if (pMemXfer->Memory.Flags & TWMF_HANDLE) { GlobalUnlock(pMemXfer->Memory.TheMem); }
return twRc; }
//
// if we are working with an application provided HANDLE,
// GlobalUnlock it before continuing
//
if (pMemXfer->Memory.Flags & TWMF_HANDLE) { GlobalUnlock(pMemXfer->Memory.TheMem); } } }
//
// unlock buffer when finished
//
// Keep unlock and NULLing together
GlobalUnlock(m_hMemXferBits); m_pMemXferBits = NULL;
} else {
//
// Could not lock down memory for transfer
//
m_twStatus.ConditionCode = TWCC_LOWMEMORY; return TWRC_FAILURE; }
} else {
//
// we recieved a message other than the expected MSG_GET
//
twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; } } break; default: { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_SEQERROR; return twRc; break; } break; }
//
// if we failed, report it properly
//
if (TWRC_FAILURE == twRc) DSError();
return twRc;}
TW_UINT16 CWiaDataSrc::OnImageFileXferMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnImageFileXferMsg()); TW_UINT16 twRc = TWRC_SUCCESS;
if (MSG_GET == ptwMsg->MSG) { GUID guidFileFormat = WiaImgFmt_BMP;
CCap *pCap = FindCap(ICAP_IMAGEFILEFORMAT); if(pCap){ guidFileFormat = ICAP_IMAGEFILEFORMAT_TO_WIA_IPA_FORMAT((TW_UINT16)pCap->GetCurrent()); }
twRc = TransferToFile(guidFileFormat); if(TWRC_XFERDONE == twRc) { SetTWAINState(DS_STATE_7); } else { DBG_ERR(("CWiaDataSrc::OnImageFileXferMsg(), TransferToFile() failed")); } } else { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; }
if (TWRC_FAILURE == twRc){ DSError(); }
return twRc;}
TW_UINT16 CWiaDataSrc::OnImageNativeXferMsg(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OnImageNativeXferMsg()); TW_UINT16 twRc = TWRC_SUCCESS;
HGLOBAL hDIB = NULL;
switch (GetTWAINState()) { case DS_STATE_6: { if (MSG_GET == ptwMsg->MSG) { twRc = TransferToDIB(&hDIB); if (TWRC_XFERDONE == twRc) { SetTWAINState(DS_STATE_7); *(TW_UINT32*)ptwMsg->pData = (TW_UINT32)(INT_PTR)hDIB; } else { DBG_ERR(("CWiaDataSrc::OnImageNativeXferMsg(), TransferToDIB() failed")); } } else { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BADPROTOCOL; } } break; default: twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_SEQERROR; break; }
if (TWRC_FAILURE == twRc){ DSError(); } return twRc;}
TW_UINT16 CWiaDataSrc::OpenDS(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::OpenDS()); TW_UINT16 twRc = TWRC_SUCCESS;
if (DS_STATE_3 == GetTWAINState()) { //
// No multiple clients are allowed.
// This is enforced by making sure that our identity's id field
// has a value of 0.
if (m_dsIdentity.Id) {
m_twStatus.ConditionCode = TWCC_MAXCONNECTIONS; twRc = TWRC_FAILURE; } else { //
// make a copy of the caller's identity
//
m_AppIdentity = *ptwMsg->AppId; m_dsIdentity = *((TW_IDENTITY *)ptwMsg->pData); HRESULT hr = S_OK; hr = m_pDevice->Open(CWiaDataSrc::DeviceEventCallback, (LPARAM)this); if (FAILED(hr)) { twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_BUMMER; } } } else { m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; }
if (TWRC_SUCCESS == twRc) {
//
// transition to STATE_4
//
SetTWAINState(DS_STATE_4); }
if (TWRC_SUCCESS != twRc) { } return twRc;}
TW_UINT16 CWiaDataSrc::CloseDS(PTWAIN_MSG ptwMsg){ DBG_FN_DS(CWiaDataSrc::CloseDS()); TW_UINT16 twRc = TWRC_SUCCESS;
switch (GetTWAINState()) { case DS_STATE_7: case DS_STATE_6: case DS_STATE_5: case DS_STATE_4: m_pDevice->Close(); //DBG_TRC(("Calling ResetMemXfer because CLOSEDS was called"));
ResetMemXfer(); //
// We are up for sale again.
//
m_AppIdentity.Id = 0;
//
// transition to STATE_3
//
SetTWAINState(DS_STATE_3);
if (m_pIWiaItems) delete [] m_pIWiaItems; m_pIWiaItems = NULL; m_NumIWiaItems = 0; m_NextIWiaItemIndex = 0; break; default: m_twStatus.ConditionCode = TWCC_SEQERROR; twRc = TWRC_FAILURE; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::EnableDS(TW_USERINTERFACE *pUI){ return TWRC_FAILURE;}
TW_UINT16 CWiaDataSrc::DisableDS(TW_USERINTERFACE *pUI){ DBG_FN_DS(CWiaDataSrc::DisableDS()); TW_UINT16 twRc = TWRC_SUCCESS; switch (GetTWAINState()) { case DS_STATE_5:
//
// transition to STATE_4
//
SetTWAINState(DS_STATE_4); break; default: twRc = TWRC_FAILURE; m_twStatus.ConditionCode = TWCC_SEQERROR; DSError(); break; } return twRc;}
TW_UINT16 CWiaDataSrc::CreateCapList(TW_UINT32 NumCaps,PCAPDATA pCapData){ DBG_FN_DS(CWiaDataSrc::CreateCapList()); if (!NumCaps || !pCapData) return TWCC_BADVALUE;
TW_UINT16 twCc = TWCC_SUCCESS;
DestroyCapList(); m_CapList = new CCap[NumCaps]; if (m_CapList) {
for (m_NumCaps = 0; m_NumCaps < NumCaps; m_NumCaps++) { twCc = m_CapList[m_NumCaps].ICap(&pCapData[m_NumCaps]); if (TWCC_SUCCESS != twCc) { break; } } m_NumCaps = NumCaps;
} else { twCc = TWCC_LOWMEMORY; }
if (TWCC_SUCCESS != twCc && m_CapList) { DestroyCapList(); }
return twCc;}
TW_UINT16 CWiaDataSrc::DestroyCapList(){ DBG_FN_DS(CWiaDataSrc::DestroyCapList()); if (m_CapList) { delete [] m_CapList; m_CapList = NULL; } m_NumCaps = 0; return TWCC_SUCCESS;}
CCap * CWiaDataSrc::FindCap(TW_UINT16 CapId){ TW_UINT32 ui32; for (ui32 = 0; ui32 < m_NumCaps; ui32++) { if (m_CapList[ui32].GetCapId() == CapId) return &m_CapList[ui32]; } return NULL;}
void CWiaDataSrc::DSError(){ DBG_FN_DS(CWiaDataSrc::DSError()); NotifyCloseReq();}
HRESULT CALLBACK CWiaDataSrc::DeviceEventCallback(LONG lEvent,LPARAM lParam){ CWiaDataSrc *pDataSrc = NULL; pDataSrc = (CWiaDataSrc *)lParam; if (pDataSrc) { pDataSrc->NotifyCloseReq(); return S_OK; } return E_FAIL;}
DS_STATE CWiaDataSrc::SetTWAINState(DS_STATE NewTWAINState){ DBG_TRC(("(Transitioning From TWAIN STATE %d to TWAIN STATE %d)",m_dsState,NewTWAINState)); m_dsState = NewTWAINState; return m_dsState;}
DS_STATE CWiaDataSrc::GetTWAINState(){ return m_dsState;}
TW_UINT16 CWiaDataSrc::SetStatusTWCC(TW_UINT16 NewConditionCode){ m_twStatus.ConditionCode = NewConditionCode; return NewConditionCode;}
float CWiaDataSrc::ConvertToTWAINUnits(LONG lValue, LONG lResolution){ float fReturnValue = 0.0f; CCap *pUnits = FindCap(ICAP_UNITS); if(pUnits){ switch (pUnits->GetCurrent()) { case TWUN_INCHES: fReturnValue = (float)lValue / (float)lResolution; break; case TWUN_CENTIMETERS: fReturnValue = (float)((lValue * 2.54) / (float)lResolution); break; case TWUN_PICAS: fReturnValue = (float)((lValue * 6.00) / (float)lResolution); break; case TWUN_POINTS: fReturnValue = (float)(((float)lValue * 72.0) / (float)lResolution); break; case TWUN_PIXELS: default: fReturnValue = (float)lValue; break; } } return fReturnValue;}
LONG CWiaDataSrc::ConvertFromTWAINUnits(float fValue, LONG lResolution){ LONG lReturnValue = 0; CCap *pUnits = FindCap(ICAP_UNITS); if (pUnits) { switch (pUnits->GetCurrent()) { case TWUN_INCHES: lReturnValue = (LONG)((float)fValue * (float)lResolution); break; case TWUN_CENTIMETERS: lReturnValue = (LONG)(((float)fValue / 2.54) * (float)lResolution); break; case TWUN_PICAS: lReturnValue = (LONG)(((float)fValue / 6.00) * (float)lResolution); break; case TWUN_POINTS: lReturnValue = (LONG)(((float)fValue / 72.0) * (float)lResolution); break; case TWUN_PIXELS: default: lReturnValue = (LONG)fValue; break; } } return lReturnValue;}
DWORD CWiaDataSrc::ReadTwainRegistryDWORDValue(LPTSTR szRegValue, DWORD dwDefault){ DBG_FN_DS(CWiaDataSrc::ReadTwainRegistryDWORDValue()); DWORD dwValue = 0; DWORD dwType = REG_DWORD; DWORD dwDataSize = sizeof(DWORD); DWORD dwDisposition = REG_OPENED_EXISTING_KEY; HKEY hTwainRootKey = NULL; if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER,TWAIN_REG_KEY,0,NULL,REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS, NULL,&hTwainRootKey,&dwDisposition)){
if(dwDisposition == REG_CREATED_NEW_KEY){ DBG_WRN(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Created Root Twain Registry Key")); }
if (ERROR_SUCCESS == RegQueryValueEx(hTwainRootKey,szRegValue,NULL,&dwType,(BYTE*)&dwValue,&dwDataSize)) { #ifdef UNICODE
DBG_TRC(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Reading %ws Registry Key Value = %d",szRegValue,dwValue)); #else
DBG_TRC(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Reading %s Registry Key Value = %d",szRegValue,dwValue)); #endif
} else { // reset sizes, just for safety
dwType = REG_DWORD; dwDataSize = sizeof(DWORD); dwValue = dwDefault; if(ERROR_SUCCESS == RegSetValueEx(hTwainRootKey,szRegValue,NULL,dwType,(BYTE*)&dwDefault,dwDataSize)){ #ifdef UNICODE
DBG_TRC(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Writing Default Value for %ws Registry Key Value = %d",szRegValue,dwDefault)); #else
DBG_TRC(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Writing Default Value for %s Registry Key Value = %d",szRegValue,dwDefault)); #endif
} else { #ifdef UNICODE
DBG_TRC(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Error Reading %ws Registry Key Value",szRegValue)); #else
DBG_TRC(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), Error Reading %s Registry Key Value",szRegValue)); #endif
} }
RegCloseKey(hTwainRootKey); hTwainRootKey = NULL; } else { DBG_ERR(("CWiaDataSrc::ReadTwainRegistryDWORDValue(), could not open Root TWAIN Registry Key")); } return dwValue;}
LONG CWiaDataSrc::GetPrivateSupportedCapsFromWIADevice(LONG **ppCapArray){ DBG_FN_DS(CWiaDataSrc::GetPrivateSupportedCapsFromWIADevice()); if (!ppCapArray) { DBG_ERR(("CWiaDataSrc::GetPrivateSupportedCapsFromWIADevice(), ppCapArray is NULL")); return 0; }
*ppCapArray = NULL; LONG lNumPrivateCaps = 0; if (m_pDevice) { if (m_pDevice->TwainCapabilityPassThrough()) { if (m_pCurrentIWiaItem) {
//
// Get the IWiaItemExtras Interface
//
IWiaItemExtras *pIWiaItemExtras = NULL; HRESULT hr = m_pCurrentIWiaItem->QueryInterface(IID_IWiaItemExtras,(void **)&pIWiaItemExtras); if (S_OK == hr) {
//
// set data sizes
//
DWORD dwInDataSize = 0; DWORD dwOutDataSize = 0; DWORD dwActualOutDataSize = 0;
BYTE *pInData = NULL; BYTE *pOutData = NULL;
LONG lCapabilityDataSize = sizeof(LONG); pOutData = (BYTE*)&lCapabilityDataSize; pInData = (BYTE*)&lCapabilityDataSize;
dwActualOutDataSize = sizeof(LONG); dwInDataSize = dwActualOutDataSize; dwOutDataSize = dwActualOutDataSize;
//
// ask how many bytes are needed to store the private TWAIN capabilities the WIA driver supports
//
hr = pIWiaItemExtras->Escape(ESC_TWAIN_PRIVATE_SUPPORTED_CAPS, pInData, dwInDataSize, pOutData, dwOutDataSize, &dwActualOutDataSize); if (S_OK == hr) {
lCapabilityDataSize = (LONG)(*pOutData);
lNumPrivateCaps = (lCapabilityDataSize / sizeof(LONG));
DBG_TRC(("WIA device reported %d private TWAIN supported CAPS",lNumPrivateCaps));
if (lNumPrivateCaps > 0) {
//
// allocate an array of LONGs for the WIA driver to fill with
// CAP ids.
//
dwOutDataSize = (lCapabilityDataSize + PRIVATE_CAP_ARRAY_PADDING); dwActualOutDataSize = dwOutDataSize;
*ppCapArray = (LONG*)GlobalAlloc(GPTR,dwOutDataSize); if (*ppCapArray) {
pOutData = (BYTE*)*ppCapArray;
//
// ask the WIA driver to fill the array of LONGS
//
hr = pIWiaItemExtras->Escape(ESC_TWAIN_PRIVATE_SUPPORTED_CAPS, pInData, dwInDataSize, pOutData, dwOutDataSize, &dwActualOutDataSize); if (FAILED(hr)) {
//
// pIWiaItemExtras->Escape call failed,
// a failure means that there are no private supported capabilities
//
DBG_ERR(("pIWiaItemExtras->Escape Failed (sending a request for the cability array data)")); DBG_TRC(("Escape(code = %d, pInData = %p, dwInDataSize = %d, pOutData = %p, dwOutDataSize = %d,dwActualOutDataSize = %d)", ESC_TWAIN_PRIVATE_SUPPORTED_CAPS, pInData, dwInDataSize, pOutData, dwOutDataSize, dwActualOutDataSize)); } } else { DBG_ERR(("could not allocate memory for private capability array of %d items (%d bytes - this includes padding)",lNumPrivateCaps,dwOutDataSize)); lNumPrivateCaps = 0; *ppCapArray = NULL; } } else {
//
// no supported caps
//
DBG_TRC(("No private supported caps reported from WIA device"));
}
} else {
//
// pIWiaItemExtras->Escape call failed,
// a failure means that there are no private supported capabilities
//
DBG_ERR(("pIWiaItemExtras->Escape Failed (sending a request for the number of capabilities)")); DBG_TRC(("Escape(code = %d, pInData = %p, dwInDataSize = %d, pOutData = %p, dwOutDataSize = %d,dwActualOutDataSize = %d)", ESC_TWAIN_PRIVATE_SUPPORTED_CAPS, pInData, dwInDataSize, pOutData, dwOutDataSize, dwActualOutDataSize)); }
//
// release IWiaItemExtras Interface
//
if (pIWiaItemExtras) { pIWiaItemExtras->Release(); pIWiaItemExtras = NULL; } } else {
//
// QI for IWiaItemExtras Failed
//
DBG_ERR(("QueryInterface for IWiaItemExtras Failed"));
} } else {
//
// no current item selected
//
DBG_ERR(("no current item selected for use"));
} } } else {
//
// m_pDevice is NULL
//
DBG_ERR(("CWiaDataSrc::GetPrivateSupportedCapsFromWIADevice(), m_pDevice is NULL")); } return lNumPrivateCaps;}
TW_UINT16 CWiaDataSrc::TransferToFile(GUID guidFormatID){ DBG_FN_DS(CWiaDataSrc::TransferToFile()); TW_UINT16 twRc = TWRC_FAILURE; HRESULT hr = E_FAIL;
CWiaDataCallback DataCallback; CCap *pCap = NULL; pCap = FindCap(CAP_INDICATORS); if(pCap){ DataCallback.Initialize(NULL,pCap->GetCurrent()); } else { DataCallback.Initialize(NULL,TRUE); }
IWiaDataCallback *pIDataCB = NULL; hr = DataCallback.QueryInterface(IID_IWiaDataCallback,(void **)&pIDataCB); if (SUCCEEDED(hr)) { hr = m_pDevice->LoadImageToDisk(m_pCurrentIWiaItem, m_FileXferName, guidFormatID, pIDataCB); if (SUCCEEDED(hr)) { twRc = TWRC_XFERDONE; m_twStatus.ConditionCode = TWCC_SUCCESS; } pIDataCB->Release(); pIDataCB = NULL; }
//
// check for a cancel, or out-of-paper error (scanners could return this)
//
if ((S_FALSE == hr) || (WIA_ERROR_PAPER_EMPTY == hr)) { m_twStatus.ConditionCode = TWCC_SUCCESS;
if(WIA_ERROR_PAPER_EMPTY == hr) { DBG_TRC(("CWiaDataSrc::TransferToFile(), WIA_ERROR_PAPER_EMPTY returned from source.")); }
//
// set XFERCOUNT
//
CCap *pxferCap = FindCap(CAP_XFERCOUNT); if (pxferCap) { pxferCap->SetCurrent((TW_UINT32)0); }
//
// return a cancel to abort the transfer.
// Applications will most commonly delete the current
// image, and keep the previous images.
//
twRc = TWRC_CANCEL; } else if (FAILED(hr)) { m_twStatus.ConditionCode = TWCC_FROM_HRESULT(hr); twRc = TWRC_FAILURE; }
return twRc;}
TW_UINT16 CWiaDataSrc::TransferToDIB(HGLOBAL *phDIB){ DBG_FN_DS(CWiaDataSrc::TransferToDIB()); TW_UINT16 twRc = TWRC_FAILURE; HRESULT hr = E_FAIL;
CWiaDataCallback DataCallback; CCap *pCap = NULL; pCap = FindCap(CAP_INDICATORS); if(pCap){ DataCallback.Initialize(NULL,pCap->GetCurrent()); } else { DataCallback.Initialize(NULL,TRUE); }
IWiaDataCallback *pIDataCB = NULL; hr = DataCallback.QueryInterface(IID_IWiaDataCallback,(void **)&pIDataCB); if (SUCCEEDED(hr)) { hr = m_pDevice->LoadImage(m_pCurrentIWiaItem, WiaImgFmt_MEMORYBMP, pIDataCB); // memory bmp only
if (SUCCEEDED(hr)) { if(SUCCEEDED(DataCallback.GetImage(phDIB, NULL))){
//
// DIB data (special case) - NATIVE TWAIN transfers are in DIB format always
// If we are acquiring DIB data, then we have to apply the
// height rules:
// positive = image is right side up
// negative = image is up side down
// zero = image has an unknown length (and assumed to be upside down)
if(FlipDIB(*phDIB)){ twRc = TWRC_XFERDONE; m_ImageHeight = (TW_UINT32)DataCallback.GetImageHeight(); m_ImageWidth = (TW_UINT32)DataCallback.GetImageWidth(); } } } pIDataCB->Release(); pIDataCB = NULL; }
//
// check for a cancel, or out-of-paper error (scanners could return this)
//
if ((S_FALSE == hr) || (WIA_ERROR_PAPER_EMPTY == hr)) { m_twStatus.ConditionCode = TWCC_SUCCESS;
if(WIA_ERROR_PAPER_EMPTY == hr) { DBG_TRC(("CWiaDataSrc::TransferToDIB(), WIA_ERROR_PAPER_EMPTY returned from source.")); }
//
// set XFERCOUNT
//
CCap *pxferCap = FindCap(CAP_XFERCOUNT); if (pxferCap) { pxferCap->SetCurrent((TW_UINT32)0); }
//
// return a cancel to abort the transfer.
// Applications will most commonly delete the current
// image, and keep the previous images.
//
twRc = TWRC_CANCEL; } else if (FAILED(hr)) { m_twStatus.ConditionCode = TWCC_FROM_HRESULT(hr); twRc = TWRC_FAILURE; }
return twRc;}
TW_UINT16 CWiaDataSrc::TransferToMemory(GUID guidFormatID){ DBG_FN_DS(CWiaDataSrc::TransferToMemory());
//
// set WIA format in Transfer Information structure
//
m_MemoryTransferInfo.mtiguidFormat = guidFormatID;
TW_UINT16 twRc = TWRC_FAILURE; HRESULT hr = E_FAIL; CWiaDataCallback DataCallback; CCap *pCap = NULL; pCap = FindCap(CAP_INDICATORS); if(pCap){ DataCallback.Initialize(NULL,pCap->GetCurrent()); } else { DataCallback.Initialize(NULL,TRUE); }
IWiaDataCallback *pIDataCB = NULL; hr = DataCallback.QueryInterface(IID_IWiaDataCallback,(void **)&pIDataCB); if (SUCCEEDED(hr)) { hr = m_pDevice->LoadImage(m_pCurrentIWiaItem, guidFormatID, pIDataCB); if (SUCCEEDED(hr)) { if(SUCCEEDED(DataCallback.GetImage(&m_hMemXferBits, NULL))){
//
// check for DIB data (special case)
// If we are acquiring DIB data, then we have to apply the
// height rules:
// positive = image is right side up
// negative = image is up side down
// zero = image has an unknown length (and assumed to be upside down)
if(WiaImgFmt_MEMORYBMP == guidFormatID){
//
// for memory transfers we need to make sure that the image
// is upside down in memory, so the application can assemble
// the bands correctly.
//
FlipDIB(m_hMemXferBits, TRUE); }
m_ImageHeight = (TW_UINT32)DataCallback.GetImageHeight(); m_ImageWidth = (TW_UINT32)DataCallback.GetImageWidth(); m_hCachedImageData = m_hMemXferBits; twRc = TWRC_SUCCESS; } } pIDataCB->Release(); pIDataCB = NULL; }
//
// check for a cancel, or out-of-paper error (scanners could return this)
//
if ((S_FALSE == hr) || (WIA_ERROR_PAPER_EMPTY == hr)) { m_twStatus.ConditionCode = TWCC_SUCCESS;
if(WIA_ERROR_PAPER_EMPTY == hr) { DBG_TRC(("CWiaDataSrc::TransferToMemory(), WIA_ERROR_PAPER_EMPTY returned from source.")); }
//
// set XFERCOUNT
//
CCap *pxferCap = FindCap(CAP_XFERCOUNT); if (pxferCap) { pxferCap->SetCurrent((TW_UINT32)0); }
//
// return a cancel to abort the transfer.
// Applications will most commonly delete the current
// image, and keep the previous images.
//
twRc = TWRC_CANCEL; } else if (FAILED(hr)) { m_twStatus.ConditionCode = TWCC_FROM_HRESULT(hr); twRc = TWRC_FAILURE; }
return twRc;}
TW_UINT16 CWiaDataSrc::GetCachedImage(HGLOBAL *phImage){ DBG_FN_DS(CWiaDataSrc::GetCachedImage()); TW_UINT16 twRc = TWRC_FAILURE; if(phImage){ if (m_hCachedImageData) { *phImage = m_hCachedImageData;
//
// since we are giving out the cached data
// reset the cache handle to NULL;
//
m_hCachedImageData = NULL; m_hMemXferBits = NULL; twRc = TWRC_SUCCESS; } } return twRc;}
TW_UINT16 CWiaDataSrc::TransferToThumbnail(HGLOBAL *phThumbnail){ DBG_FN_DS(CWiaDataSrc::TransferToThumbnail()); TW_UINT16 twRc = TWRC_FAILURE; HRESULT hr = E_FAIL; hr = m_pDevice->LoadThumbnail(m_pCurrentIWiaItem,phThumbnail,NULL); if (SUCCEEDED(hr)) { twRc = TWRC_XFERDONE; } return twRc;}
TW_UINT16 CWiaDataSrc::GetCommonSettings(){ DBG_FN_DS(CWiaDataSrc::GetCommonSettings()); TW_UINT16 twRc = TWRC_FAILURE;
//
// Some TWAIN applications make the assumption that the TWAIN data source
// defaults to BMP/DIB data formats. This is on the basis that TWAIN
// spec minimal requirements are BMP/DIB. WIA minimal requirements are
// BMP/DIB. Set the current Format GUID to MEMORYBMP, and TYMED to
// TYMED_CALLBACK. This will set the WIA driver to transfer bitmap data
// by default. This does not limit the data types in any way. A high
// end application will properly read the valid TWAIN values and configure
// the device to do the correct thing.
//
//
// before configuring TWAIN valid values, set the WIA device to TYMED_CALLBACK, MEMORYBMP.
//
HRESULT hr = S_OK; CWiahelper WIA; hr = WIA.SetIWiaItem(m_pCurrentIWiaItem); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::GetCommonSettings(), failed to set IWiaItem for property writing")); return twRc; }
hr = WIA.WritePropertyLong(WIA_IPA_TYMED,TYMED_CALLBACK); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::GetCommonSettings(), failed to set TYMED_CALLBACK as a default setting")); return twRc; }
hr = WIA.WritePropertyGUID(WIA_IPA_FORMAT,WiaImgFmt_MEMORYBMP); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::GetCommonSettings(), failed to set WiaImgFmt_MEMORYBMP as a default setting")); return twRc; }
if (TWRC_SUCCESS == GetPixelTypes()) { if (TWRC_SUCCESS == GetCompressionTypes()) { if (TWRC_SUCCESS == GetBitDepths()) { if (TWRC_SUCCESS == GetImageFileFormats()) { twRc = TWRC_SUCCESS; } else { DBG_ERR(("CWiaDataSrc::GetCommonSettings(), GetImageFileFormats()")); } } else { DBG_ERR(("CWiaDataSrc::GetCommonSettings(), GetBitDepths() failed")); } } else { DBG_ERR(("CWiaDataSrc::GetCommonSettings(), GetCompressionTypes() failed")); } } else { DBG_ERR(("CWiaDataSrc::GetCommonSettings(), GetPixelTypes() failed")); }
return twRc;}
TW_UINT16 CWiaDataSrc::GetCommonDefaultSettings(){ DBG_FN_DS(CWiaDataSrc::GetCommonDefaultSettings()); TW_UINT16 twRc = TWRC_FAILURE; CCap *pCap = NULL; TW_UINT16 CapDataArray[1];
pCap = FindCap(ICAP_PIXELTYPE); if (pCap) { CapDataArray[0] = TWPT_RGB; twRc = pCap->Set(0,0,1,(BYTE*)CapDataArray); if (TWRC_SUCCESS == twRc) {
pCap = FindCap(ICAP_COMPRESSION); if (pCap) { CapDataArray[0] = TWCP_NONE; twRc = pCap->Set(0,0,1,(BYTE*)CapDataArray);
pCap = FindCap(ICAP_BITDEPTH); if (pCap) { CapDataArray[0] = 24; twRc = pCap->Set(0,0,1,(BYTE*)CapDataArray); if (TWRC_SUCCESS == twRc) {
pCap = FindCap(ICAP_IMAGEFILEFORMAT); if (pCap) { CapDataArray[0] = TWFF_BMP; twRc = pCap->Set(0,0,1,(BYTE*)CapDataArray); if (TWRC_SUCCESS == twRc) {
} } } } } } } return twRc;}
TW_UINT16 CWiaDataSrc::GetPixelTypes(){ DBG_FN_DS(CWiaScannerDS::GetPixelTypes()); TW_UINT16 twRc = TWRC_FAILURE;
CCap *pCap = FindCap(ICAP_PIXELTYPE); if (pCap) {
HRESULT hr = S_OK; CWiahelper WIA; hr = WIA.SetIWiaItem(m_pCurrentIWiaItem); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::GetPixelTypes(), failed to set IWiaItem for property reading")); return twRc; }
TW_UINT32 ActualCount = 0; TW_UINT32 CurrentIndex = 0; TW_UINT32 DefaultIndex = 0; TW_UINT16 *pPixelTypeArray = NULL;
//
// read current value, for default and current index settings
//
LONG lCurrentDataTypeValue = WIA_DATA_COLOR;
//
// read current WIA_IPA_DATATYPE setting
//
hr = WIA.ReadPropertyLong(WIA_IPA_DATATYPE,&lCurrentDataTypeValue); if (SUCCEEDED(hr)) {
//
// read valid values for WIA_IPA_DATATYPE
//
PROPVARIANT pv; memset(&pv,0,sizeof(pv)); LONG lAccessFlags = 0; hr = WIA.ReadPropertyAttributes(WIA_IPA_DATATYPE,&lAccessFlags,&pv); if (SUCCEEDED(hr)) { if (lAccessFlags & WIA_PROP_LIST) {
//
// for each valid WIA value in the LIST, set a corresponding
// TWAIN value
//
pPixelTypeArray = new TW_UINT16[WIA_PROP_LIST_COUNT(&pv)]; if (pPixelTypeArray) { memset(pPixelTypeArray,0,(sizeof(TW_UINT16)*WIA_PROP_LIST_COUNT(&pv))); for (ULONG i = 0; i < WIA_PROP_LIST_COUNT(&pv);i++) {
switch (pv.caul.pElems[i+2]) { case WIA_DATA_THRESHOLD: pPixelTypeArray[ActualCount] = (TW_UINT16)TWPT_BW; if (lCurrentDataTypeValue == WIA_DATA_THRESHOLD) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_DATA_THERSHOLD -> TWPT_BW")); break; case WIA_DATA_GRAYSCALE: pPixelTypeArray[ActualCount] = (TW_UINT16)TWPT_GRAY; if (lCurrentDataTypeValue == WIA_DATA_GRAYSCALE) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_DATA_GRAYSCALE -> TWPT_GRAY")); break; case WIA_DATA_COLOR: pPixelTypeArray[ActualCount] = (TW_UINT16)TWPT_RGB; if (lCurrentDataTypeValue == WIA_DATA_COLOR) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_DATA_COLOR -> TWPT_RGB")); break; case WIA_DATA_DITHER: case WIA_DATA_COLOR_THRESHOLD: case WIA_DATA_COLOR_DITHER: ////////////////////////////////
// NO TWAIN -> WIA CONVERSION //
////////////////////////////////
//
// TWPT_PALETTE
// TWPT_CMY
// TWPT_CMYK
// TWPT_YUV
// TWPT_YUVK
// TWPT_CIEXYZ
default: DBG_TRC(("WIA Data Type (%d) does not MAP to TWAIN a pixel type",pv.caul.pElems[i+2])); break; } } } else { DBG_ERR(("CWiaDataSrc::GetPixelTypes(), failed to allocate Pixel Type Array Memory")); } } else {
//
// we only have 1 value, so make it the current, default and valid value.
//
pPixelTypeArray = new TW_UINT16[1]; if (pPixelTypeArray) { memset(pPixelTypeArray,0,(sizeof(TW_UINT16)));
switch (lCurrentDataTypeValue) { case WIA_DATA_THRESHOLD: pPixelTypeArray[ActualCount] = (TW_UINT16)TWPT_BW; if (lCurrentDataTypeValue == WIA_DATA_THRESHOLD) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_DATA_THERSHOLD -> TWPT_BW")); break; case WIA_DATA_GRAYSCALE: pPixelTypeArray[ActualCount] = (TW_UINT16)TWPT_GRAY; if (lCurrentDataTypeValue == WIA_DATA_GRAYSCALE) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_DATA_GRAYSCALE -> TWPT_GRAY")); break; case WIA_DATA_COLOR: pPixelTypeArray[ActualCount] = (TW_UINT16)TWPT_RGB; if (lCurrentDataTypeValue == WIA_DATA_COLOR) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_DATA_COLOR -> TWPT_RGB")); break; case WIA_DATA_DITHER: case WIA_DATA_COLOR_THRESHOLD: case WIA_DATA_COLOR_DITHER: ////////////////////////////////
// NO TWAIN -> WIA CONVERSION //
////////////////////////////////
//
// TWPT_PALETTE
// TWPT_CMY
// TWPT_CMYK
// TWPT_YUV
// TWPT_YUVK
// TWPT_CIEXYZ
default: DBG_TRC(("WIA Data Type (%d) does not MAP to TWAIN a pixel type",lCurrentDataTypeValue)); break; } } else { DBG_ERR(("CWiaDataSrc::GetPixelTypes(), failed to allocate Pixel Type Array Memory")); } }
if (pPixelTypeArray) {
//
// default index is equal to current index, because we are stating that the WIA driver
// is a fresh start-up state.
//
DefaultIndex = CurrentIndex;
twRc = pCap->Set(DefaultIndex,CurrentIndex,ActualCount,(BYTE*)pPixelTypeArray,TRUE); // list
delete [] pPixelTypeArray; pPixelTypeArray = NULL;
//twRc = TWRC_SUCCESS;
}
PropVariantClear(&pv); } else { DBG_ERR(("CWiaDataSrc::GetPixelTypes(), failed to read WIA_IPS_DATATYPE attributes")); } } else { DBG_ERR(("CWiaDataSrc::GetPixelTypes(), failed to read WIA_IPS_DATATYPE current value")); } } return twRc;}
TW_UINT16 CWiaDataSrc::GetBitDepths(){ DBG_FN_DS(CWiaScannerDS::GetBitDepths()); TW_UINT16 twRc = TWRC_FAILURE;
CCap *pCap = FindCap(ICAP_BITDEPTH); if (pCap) {
HRESULT hr = S_OK; CWiahelper WIA; hr = WIA.SetIWiaItem(m_pCurrentIWiaItem); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::GetBitDepths(), failed to set IWiaItem for property reading")); return twRc; }
TW_UINT32 ActualCount = 0; TW_UINT32 CurrentIndex = 0; TW_UINT32 DefaultIndex = 0; TW_UINT16 BitDepthArray[MAX_BITDEPTHS]; memset(BitDepthArray,0,sizeof(BitDepthArray));
//
// read current value, for default and current index settings
//
LONG lCurrentDataTypeValue = WIA_DATA_COLOR; LONG lCurrentBitDepthValue = 24;
//
// read current WIA_IPA_DATATYPE setting
//
hr = WIA.ReadPropertyLong(WIA_IPA_DATATYPE,&lCurrentDataTypeValue); if (SUCCEEDED(hr)) {
//
// read current WIA_IPA_DEPTH setting
//
hr = WIA.ReadPropertyLong(WIA_IPA_DEPTH,&lCurrentBitDepthValue); if (SUCCEEDED(hr)) {
PROPVARIANT pv; memset(&pv,0,sizeof(pv)); LONG lAccessFlags = 0;
//
// read valid values for WIA_IPA_DATATYPE
//
hr = WIA.ReadPropertyAttributes(WIA_IPA_DATATYPE,&lAccessFlags,&pv); if (SUCCEEDED(hr)) {
//
// for each valid value, set it to the current setting, and read
// the valid values for WIA_IPA_DEPTH.
//
if (lAccessFlags & WIA_PROP_LIST) {
//
// set the WIA_IPA_DATATYPE to each valid value in the LIST
//
for (ULONG i = 0; i < WIA_PROP_LIST_COUNT(&pv);i++) {
hr = WIA.WritePropertyLong(WIA_IPA_DATATYPE,(LONG)pv.caul.pElems[i+2]); if (SUCCEEDED(hr)) {
//
// read valid values for WIA_IPA_DEPTH
//
lAccessFlags = 0; PROPVARIANT pvDepth; memset(&pvDepth,0,sizeof(pvDepth)); hr = WIA.ReadPropertyAttributes(WIA_IPA_DEPTH,&lAccessFlags,&pvDepth); if (SUCCEEDED(hr)) { LONG lBitDepth = 0; if (lAccessFlags & WIA_PROP_LIST) {
//
// copy each valid value in the LIST to the array
//
for (ULONG ulIndex = 0; ulIndex < WIA_PROP_LIST_COUNT(&pvDepth);ulIndex++) { lBitDepth = pvDepth.caul.pElems[ulIndex+2]; for (ULONG BitDepthArrayIndex = 0; BitDepthArrayIndex < MAX_BITDEPTHS; BitDepthArrayIndex++) {
if (BitDepthArray[BitDepthArrayIndex] == 0) {
//
// the current slot is (0) zero, so add the new bit depth value
//
BitDepthArray[BitDepthArrayIndex] = (TW_UINT16)lBitDepth; DBG_TRC(("WIA driver supports %d bit depth",lBitDepth)); ActualCount++;
//
// exit the loop
//
BitDepthArrayIndex = MAX_BITDEPTHS; } else if (BitDepthArray[BitDepthArrayIndex] == (TW_UINT16)lBitDepth) {
//
// bit depth is already in the list, so exit the loop
//
BitDepthArrayIndex = MAX_BITDEPTHS; } } } } else if (lAccessFlags & WIA_PROP_NONE) {
//
// read the current value for WIA_IPA_DEPTH
// and copy it to the array
//
hr = WIA.ReadPropertyLong(WIA_IPA_DEPTH,&lBitDepth); if (SUCCEEDED(hr)) { for (ULONG BitDepthArrayIndex = 0; BitDepthArrayIndex < MAX_BITDEPTHS; BitDepthArrayIndex++) {
if (BitDepthArray[BitDepthArrayIndex] == 0) {
//
// the current slot is (0) zero, so add the new bit depth value
//
BitDepthArray[BitDepthArrayIndex] = (TW_UINT16)lBitDepth; DBG_TRC(("WIA driver supports %d bit depth",lBitDepth)); ActualCount++;
//
// exit the loop
//
BitDepthArrayIndex = MAX_BITDEPTHS; } else if (BitDepthArray[BitDepthArrayIndex] == (TW_UINT16)lBitDepth) {
//
// bit depth is already in the list, so exit the loop
//
BitDepthArrayIndex = MAX_BITDEPTHS; } } } else { DBG_ERR(("CWiaDataSrc::GetBitDepths(), ReadPropertyLong(WIA_IPA_DEPTH) failed")); } }
//
// clean up the PROPVARIANT structure
//
PropVariantClear(&pvDepth); } } else { DBG_ERR(("CWiaDataSrc::GetBitDepths(), WritePropertyLong(WIA_IPA_DATATYPE) failed")); } } } else {
//
// we only have 1 value, so make it the current, default and valid value.
//
BitDepthArray[0] = (TW_UINT16)lCurrentBitDepthValue; ActualCount = 1; DBG_TRC(("WIA driver supports %d bit depth",lCurrentBitDepthValue)); }
//
// set the current values back
//
hr = WIA.WritePropertyLong(WIA_IPA_DATATYPE,lCurrentDataTypeValue); if (SUCCEEDED(hr)) { hr = WIA.WritePropertyLong(WIA_IPA_DEPTH,lCurrentBitDepthValue); }
for (ULONG BitDepthArrayIndex = 0; BitDepthArrayIndex < MAX_BITDEPTHS; BitDepthArrayIndex++) { if (BitDepthArray[BitDepthArrayIndex] == (TW_UINT16)lCurrentBitDepthValue) { CurrentIndex = BitDepthArrayIndex; BitDepthArrayIndex = MAX_BITDEPTHS; } }
//
// default index is equal to current index, because we are stating that the WIA driver
// is a fresh start-up state.
//
DefaultIndex = CurrentIndex;
twRc = pCap->Set(DefaultIndex,CurrentIndex,ActualCount,(BYTE*)BitDepthArray,TRUE); // list
//twRc = TWRC_SUCCESS;
PropVariantClear(&pv); } else { DBG_ERR(("CWiaDataSrc::GetBitDepths(), failed to read WIA_IPS_DATATYPE attributes")); } } else { DBG_ERR(("CWiaDataSrc::GetBitDepths(), ReadPropertyLong(WIA_IPA_DEPTH) failed")); } } else { DBG_ERR(("CWiaDataSrc::GetBitDepths(), ReadPropertyLong(WIA_IPA_DATATYPE) failed")); } }
return twRc;}
TW_UINT16 CWiaDataSrc::GetImageFileFormats(){ DBG_FN_DS(CWiaScannerDS::GetImageFileFormats()); TW_UINT16 twRc = TWRC_FAILURE;
CCap *pCap = FindCap(ICAP_IMAGEFILEFORMAT); if (pCap) {
HRESULT hr = S_OK; CWiahelper WIA; hr = WIA.SetIWiaItem(m_pCurrentIWiaItem); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::GetImageFileFormats(), failed to set IWiaItem for property reading")); return twRc; }
TW_UINT32 ActualCount = 0; TW_UINT32 CurrentIndex = 0; TW_UINT32 DefaultIndex = 0; TW_UINT16 *pFileTypeArray = NULL;
IWiaDataTransfer *pIWiaDataTransfer = NULL; TW_UINT32 TotalFileFormats = 0; IEnumWIA_FORMAT_INFO *pIEnumWIA_FORMAT_INFO = NULL; WIA_FORMAT_INFO pfe;
//
// read current value, for default and current index settings
//
GUID guidCurrentFileFormat = GUID_NULL; hr = WIA.ReadPropertyGUID(WIA_IPA_FORMAT,&guidCurrentFileFormat); if (SUCCEEDED(hr)) {
//
// collect valid values for image file format
//
hr = m_pCurrentIWiaItem->QueryInterface(IID_IWiaDataTransfer, (void **)&pIWiaDataTransfer); if (S_OK == hr) { hr = pIWiaDataTransfer->idtEnumWIA_FORMAT_INFO(&pIEnumWIA_FORMAT_INFO); if (SUCCEEDED(hr)) {
//
// count supported FILE formats
//
do { memset(&pfe,0,sizeof(pfe)); hr = pIEnumWIA_FORMAT_INFO->Next(1, &pfe, NULL); if (hr == S_OK) { if ((pfe.lTymed == TYMED_FILE) || (pfe.lTymed == TYMED_MULTIPAGE_FILE)) { TotalFileFormats++; } } } while (hr == S_OK);
//
// allocate supported FILE format array
//
pFileTypeArray = new TW_UINT16[TotalFileFormats]; if (pFileTypeArray) { memset(pFileTypeArray,0,(sizeof(TW_UINT16) * TotalFileFormats));
//
// reset enuerator
//
hr = pIEnumWIA_FORMAT_INFO->Reset(); if (SUCCEEDED(hr)) { do { memset(&pfe,0,sizeof(pfe)); hr = pIEnumWIA_FORMAT_INFO->Next(1, &pfe, NULL); if (hr == S_OK) {
if (pfe.lTymed == TYMED_MULTIPAGE_FILE) { if (pfe.guidFormatID == WiaImgFmt_TIFF) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_TIFFMULTI; if (guidCurrentFileFormat == WiaImgFmt_TIFF) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_TIFF (Multipage) -> TWFF_TIFFMULTI")); } }
if (pfe.lTymed == TYMED_FILE) { if (pfe.guidFormatID == WiaImgFmt_BMP) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_BMP; if (guidCurrentFileFormat == WiaImgFmt_BMP) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_BMP -> TWFF_BMP")); } else if (pfe.guidFormatID == WiaImgFmt_JPEG) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_JFIF; if (guidCurrentFileFormat == WiaImgFmt_JPEG) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_JPEG -> TWFF_JFIF")); } else if (pfe.guidFormatID == WiaImgFmt_TIFF) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_TIFF; if (guidCurrentFileFormat == WiaImgFmt_TIFF) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_TIFF -> TWFF_TIFF")); } else if (pfe.guidFormatID == WiaImgFmt_PICT) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_PICT; if (guidCurrentFileFormat == WiaImgFmt_PICT) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_PICT -> TWFF_PICT")); } else if (pfe.guidFormatID == WiaImgFmt_PNG) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_PNG; if (guidCurrentFileFormat == WiaImgFmt_PNG) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_PNG -> WiaImgFmt_PNG")); } else if (pfe.guidFormatID == WiaImgFmt_EXIF) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_EXIF; if (guidCurrentFileFormat == WiaImgFmt_EXIF) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_EXIF -> TWFF_EXIF")); } else if (pfe.guidFormatID == WiaImgFmt_FLASHPIX) { pFileTypeArray[ActualCount] = (TW_UINT16)TWFF_FPX; if (guidCurrentFileFormat == WiaImgFmt_FLASHPIX) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WiaImgFmt_FLASHPIX -> TWFF_FPX")); } else if (pfe.guidFormatID == WiaImgFmt_UNDEFINED) { DBG_TRC(("WIA File Format WiaImgFmt_UNDEFINED does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_EMF) { DBG_TRC(("WIA File Format WiaImgFmt_EMF does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_WMF) { DBG_TRC(("WIA File Format WiaImgFmt_WMF does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_GIF) { DBG_TRC(("WIA File Format WiaImgFmt_GIF does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_PHOTOCD) { DBG_TRC(("WIA File Format WiaImgFmt_PHOTOCD does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_ICO) { DBG_TRC(("WIA File Format WiaImgFmt_ICO does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_CIFF) { DBG_TRC(("WIA File Format WiaImgFmt_CIFF does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_JPEG2K) { DBG_TRC(("WIA File Format WiaImgFmt_JPEG2K does not MAP to TWAIN a file format")); } else if (pfe.guidFormatID == WiaImgFmt_JPEG2KX) { DBG_TRC(("WIA File Format WiaImgFmt_JPEG2KX does not MAP to TWAIN a file format")); } else {
}
////////////////////////////////
// NO TWAIN -> WIA CONVERSION //
////////////////////////////////
//
// TWFF_XBM
// TWFF_SPIFF
} } } while (hr == S_OK); }
if (pFileTypeArray) {
//
// default index is equal to current index, because we are stating that the WIA driver
// is a fresh start-up state.
//
DefaultIndex = CurrentIndex;
twRc = pCap->Set(DefaultIndex,CurrentIndex,ActualCount,(BYTE*)pFileTypeArray,TRUE); // list
delete [] pFileTypeArray; pFileTypeArray = NULL; //twRc = TWRC_SUCCESS;
} }
pIEnumWIA_FORMAT_INFO->Release(); pIEnumWIA_FORMAT_INFO = NULL; } else { DBG_ERR(("CWiaDataSrc::GetImageFileFormats(), pIWiaDataTransfer->idtEnumWIA_FORMAT_INFO() failed to enumerate supported file formats")); } pIWiaDataTransfer->Release(); pIWiaDataTransfer = NULL; } else { DBG_ERR(("CWiaDataSrc::GetImageFileFormats(), QueryInterface(IID_IWiaDataTransfer) failed")); } } } return twRc;}
TW_UINT16 CWiaDataSrc::GetCompressionTypes(){ DBG_FN_DS(CWiaScannerDS::GetCompressionTypes()); TW_UINT16 twRc = TWRC_FAILURE;
CCap *pCap = FindCap(ICAP_COMPRESSION); if (pCap) {
#ifdef SUPPORT_COMPRESSION_TYPES
HRESULT hr = S_OK; CWiahelper WIA; hr = WIA.SetIWiaItem(m_pCurrentIWiaItem); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::GetCompressionTypes(), failed to set IWiaItem for property reading")); return twRc; }
TW_UINT32 ActualCount = 0; TW_UINT32 CurrentIndex = 0; TW_UINT32 DefaultIndex = 0; TW_UINT16 *pCompressionTypeArray = NULL;
//
// read current value, for default and current index settings
//
LONG lCurrentCompressionTypeValue = WIA_COMPRESSION_NONE; hr = WIA.ReadPropertyLong(WIA_IPA_COMPRESSION,&lCurrentCompressionTypeValue); if (SUCCEEDED(hr)) {
PROPVARIANT pv; memset(&pv,0,sizeof(pv)); LONG lAccessFlags = 0; hr = WIA.ReadPropertyAttributes(WIA_IPA_COMPRESSION,&lAccessFlags,&pv); if (SUCCEEDED(hr)) {
//
// collect valid values for compression type
//
if (lAccessFlags & WIA_PROP_LIST) { pCompressionTypeArray = new TW_UINT16[WIA_PROP_LIST_COUNT(&pv)]; if (pCompressionTypeArray) { memset(pCompressionTypeArray,0,(sizeof(TW_UINT16)*WIA_PROP_LIST_COUNT(&pv))); for (ULONG i = 0; i < WIA_PROP_LIST_COUNT(&pv);i++) {
switch (pv.caul.pElems[i+2]) { case WIA_COMPRESSION_NONE: pCompressionTypeArray[ActualCount] = (TW_UINT16)TWCP_NONE; if (lCurrentCompressionTypeValue == WIA_COMPRESSION_NONE) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_COMPRESSION_NONE -> TWCP_NONE")); break; case WIA_COMPRESSION_G3: pCompressionTypeArray[ActualCount] = (TW_UINT16)TWCP_GROUP31D; if (lCurrentCompressionTypeValue == WIA_COMPRESSION_G3) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_COMPRESSION_G3 -> TWCP_GROUP31D")); break; case WIA_COMPRESSION_G4: pCompressionTypeArray[ActualCount] = (TW_UINT16)TWCP_GROUP4; if (lCurrentCompressionTypeValue == WIA_COMPRESSION_G4) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_COMPRESSION_G4 -> TWCP_GROUP4")); break; case WIA_COMPRESSION_JPEG: pCompressionTypeArray[ActualCount] = (TW_UINT16)TWCP_JPEG; if (lCurrentCompressionTypeValue == WIA_COMPRESSION_JPEG) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_COMPRESSION_JPEG -> TWCP_JPEG")); break; case WIA_COMPRESSION_BI_RLE4: pCompressionTypeArray[ActualCount] = (TW_UINT16)TWCP_RLE4; if (lCurrentCompressionTypeValue == WIA_COMPRESSION_BI_RLE4) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_COMPRESSION_BI_RLE4 -> TWCP_RLE4")); break; case WIA_COMPRESSION_BI_RLE8: pCompressionTypeArray[ActualCount] = (TW_UINT16)TWCP_RLE8; if (lCurrentCompressionTypeValue == WIA_COMPRESSION_BI_RLE8) { CurrentIndex = ActualCount; } ActualCount++; DBG_TRC(("WIA driver supports WIA_COMPRESSION_BI_RLE8 -> TWCP_RLE8")); break; ////////////////////////////////
// NO TWAIN -> WIA CONVERSION //
////////////////////////////////
//
// TWCP_PACKBITS
// TWCP_GROUP31D
// TWCP_GROUP31DEOL
// TWCP_GROUP32D
//
//
// TWCP_LZW
// TWCP_JBIG
default: DBG_TRC(("WIA Compression Type (%d) does not MAP to TWAIN a compression type",pv.caul.pElems[i+2])); break; } } } else { DBG_ERR(("CWiaDataSrc::GetCompressionTypes(), failed to allocate Compression Type Array Memory")); } } else {
//
// current value becomes the only valid value
//
CurrentIndex = 0; ActualCount = 1;
pCompressionTypeArray = new TW_UINT16[1]; if (pCompressionTypeArray) { switch (lCurrentCompressionTypeValue) { case WIA_COMPRESSION_NONE: pCompressionTypeArray[0] = (TW_UINT16)TWCP_NONE; DBG_TRC(("WIA driver supports WIA_COMPRESSION_NONE -> TWCP_NONE")); break; case WIA_COMPRESSION_G3: pCompressionTypeArray[0] = (TW_UINT16)TWCP_GROUP31D; DBG_TRC(("WIA driver supports WIA_COMPRESSION_G3 -> TWCP_GROUP31D")); break; case WIA_COMPRESSION_G4: pCompressionTypeArray[0] = (TW_UINT16)TWCP_GROUP4; DBG_TRC(("WIA driver supports WIA_COMPRESSION_G4 -> TWCP_GROUP4")); break; case WIA_COMPRESSION_JPEG: pCompressionTypeArray[0] = (TW_UINT16)TWCP_JPEG; DBG_TRC(("WIA driver supports WIA_COMPRESSION_JPEG -> TWCP_JPEG")); break; case WIA_COMPRESSION_BI_RLE4: pCompressionTypeArray[0] = (TW_UINT16)TWCP_RLE4; DBG_TRC(("WIA driver supports WIA_COMPRESSION_BI_RLE4 -> TWCP_RLE4")); break; case WIA_COMPRESSION_BI_RLE8: pCompressionTypeArray[0] = (TW_UINT16)TWCP_RLE8; DBG_TRC(("WIA driver supports WIA_COMPRESSION_BI_RLE8 -> TWCP_RLE8")); break; ////////////////////////////////
// NO TWAIN -> WIA CONVERSION //
////////////////////////////////
//
// TWCP_PACKBITS
// TWCP_GROUP31D
// TWCP_GROUP31DEOL
// TWCP_GROUP32D
//
//
// TWCP_LZW
// TWCP_JBIG
default: DBG_TRC(("WIA Compression Type (%d) does not MAP to TWAIN a compression type",lCurrentCompressionTypeValue)); break; } } }
if (pCompressionTypeArray) {
//
// default index is equal to current index, because we are stating that the WIA driver
// is a fresh start-up state.
//
DefaultIndex = CurrentIndex;
twRc = pCap->Set(DefaultIndex,CurrentIndex,ActualCount,(BYTE*)pCompressionTypeArray,TRUE); // list
delete [] pCompressionTypeArray; pCompressionTypeArray = NULL;
//twRc = TWRC_SUCCESS;
}
PropVariantClear(&pv); } else { DBG_ERR(("CWiaDataSrc::GetCompressionTypes(), failed to read WIA_IPA_COMPRESSION attributes")); } } else { DBG_ERR(("CWiaDataSrc::GetCompressionTypes(), failed to read WIA_IPA_COMPRESSION current value")); }#else // SUPPORT_COMPRESSION_TYPES
//
// support only TWCP_NONE (no Compression)
//
TW_UINT16 CapDataArray[1]; CapDataArray[0] = TWCP_NONE; twRc = pCap->Set(0,0,1,(BYTE*)CapDataArray);
#endif // SUPPORT_COMPRESSION_TYPES
} return twRc;}
TW_UINT16 CWiaDataSrc::SetCommonSettings(CCap *pCap){ DBG_FN_DS(CWiaScannerDS::SetCommonSettings()); HRESULT hr = S_OK; LONG lValue = 0; CWiahelper WIA; IWiaItem *pIRootItem = NULL; hr = WIA.SetIWiaItem(m_pCurrentIWiaItem); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::SetCommonSettings(), failed to set IWiaItem for property reading")); }
//
// determine if it is a Capability that the device really needs to know
// about.
//
switch (pCap->GetCapId()) { case ICAP_PIXELTYPE: DBG_TRC(("CWiaDataSrc::SetCommonSettings(ICAP_PIXELTYPE)")); switch (pCap->GetCurrent()) { case TWPT_BW: DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_DATATYPE to WIA_DATA_THRESHOLD")); hr = WIA.WritePropertyLong(WIA_IPA_DATATYPE,WIA_DATA_THRESHOLD); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_DATATYPE to WIA_DATA_THRESHOLD failed")); } break; case TWPT_GRAY: DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_DATATYPE to WIA_DATA_GRAYSCALE")); hr = WIA.WritePropertyLong(WIA_IPA_DATATYPE,WIA_DATA_GRAYSCALE); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_DATATYPE to WIA_DATA_GRAYSCALE failed")); } break; case TWPT_RGB: DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_DATATYPE to WIA_DATA_COLOR")); hr = WIA.WritePropertyLong(WIA_IPA_DATATYPE,WIA_DATA_COLOR); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_DATATYPE to WIA_DATA_COLOR failed")); } break; case TWPT_PALETTE: case TWPT_CMY: case TWPT_CMYK: case TWPT_YUV: case TWPT_YUVK: case TWPT_CIEXYZ: default: DBG_WRN(("CWiaDataSrc::SetCommonSettings(), An unsupported ICAP_PIXELTYPE (%d) was sent to this data source",(LONG)pCap->GetCurrent())); break; } break; case ICAP_BITDEPTH: DBG_TRC(("CWiaDataSrc::SetCommonSettings(ICAP_BITDEPTH)")); lValue = (LONG)pCap->GetCurrent(); DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_BITDEPTH to %d",lValue)); hr = WIA.WritePropertyLong(WIA_IPA_DEPTH,lValue); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_BITDEPTH to %d failed",lValue)); } break; case ICAP_IMAGEFILEFORMAT: { DBG_TRC(("CWiaDataSrc::SetCommonSettings(ICAP_IMAGEFILEFORMAT)")); lValue = (LONG)pCap->GetCurrent(); LONG lTymed = TYMED_FILE; if (lValue == TWFF_TIFFMULTI) { DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_TYMED to TYMED_MULTIPAGE_FILE")); lTymed = TYMED_MULTIPAGE_FILE; } else { DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_TYMED to TYMED_FILE")); }
hr = WIA.WritePropertyLong(WIA_IPA_TYMED,lTymed);
GUID guidFormat = GUID_NULL;
if (SUCCEEDED(hr)) { switch (lValue) { case TWFF_TIFFMULTI: case TWFF_TIFF: guidFormat = WiaImgFmt_TIFF; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_TIFF")); break; case TWFF_PICT: guidFormat = WiaImgFmt_PICT; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_PICT")); break; case TWFF_BMP: guidFormat = WiaImgFmt_BMP; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_BMP")); break; case TWFF_JFIF: guidFormat = WiaImgFmt_JPEG; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_JPEG")); break; case TWFF_FPX: guidFormat = WiaImgFmt_FLASHPIX; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_FLASHPIX")); break; case TWFF_PNG: guidFormat = WiaImgFmt_PNG; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_PNG")); break; case TWFF_EXIF: guidFormat = WiaImgFmt_EXIF; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to WiaImgFmt_EXIF")); break; case TWFF_SPIFF: case TWFF_XBM: default: break; }
hr = WIA.WritePropertyGUID(WIA_IPA_FORMAT,guidFormat); if (FAILED(hr)) { DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_FORMAT to %d failed",lValue)); } } else { DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_TYMED to %d failed",lTymed)); } } break; case ICAP_COMPRESSION: { DBG_TRC(("CWiaDataSrc::SetCommonSettings(ICAP_COMPRESSION)")); lValue = (LONG)pCap->GetCurrent(); LONG lCompression = WIA_COMPRESSION_NONE; switch (lValue) { case TWCP_NONE: lCompression = WIA_COMPRESSION_NONE; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to WIA_COMPRESSION_NONE")); break; case TWCP_GROUP4: lCompression = WIA_COMPRESSION_G4; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to WIA_COMPRESSION_G4")); break; case TWCP_JPEG: lCompression = WIA_COMPRESSION_JPEG; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to WIA_COMPRESSION_JPEG")); break; case TWCP_RLE4: lCompression = WIA_COMPRESSION_BI_RLE4; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to WIA_COMPRESSION_BI_RLE4")); break; case TWCP_RLE8: lCompression = WIA_COMPRESSION_BI_RLE8; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to WIA_COMPRESSION_BI_RLE8")); break; case TWCP_GROUP31D: case TWCP_GROUP31DEOL: case TWCP_GROUP32D: lCompression = WIA_COMPRESSION_G3; DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to WIA_COMPRESSION_G3")); break; case TWCP_LZW: case TWCP_JBIG: case TWCP_PACKBITS: default: break; }
hr = WIA.WritePropertyLong(WIA_IPA_COMPRESSION,lCompression); if(FAILED(hr)){ DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Setting WIA_IPA_COMPRESSION to %d failed",lCompression)); } } break; default: DBG_TRC(("CWiaDataSrc::SetCommonSettings(), data source is not setting CAPID = %x to WIA device (it is not needed)",pCap->GetCapId())); break; }
if (SUCCEEDED(hr)) { DBG_TRC(("CWiaDataSrc::SetCommonSettings(), Settings were successfully sent to WIA device")); } else { DBG_ERR(("CWiaDataSrc::SetCommonSettings(), Settings were unsuccessfully sent to WIA device")); return TWRC_FAILURE; }
return TWRC_SUCCESS;}
TW_UINT16 CWiaDataSrc::GetMemoryTransferBits(BYTE* pImageData){ DBG_FN_DS(CWiaScannerDS::GetMemoryTransferBits()); if(!pImageData){ return TWRC_FAILURE; }
BYTE *pBits = pImageData;
if (m_MemoryTransferInfo.mtiguidFormat == WiaImgFmt_MEMORYBMP) { BITMAPINFOHEADER* pbmh = (BITMAPINFOHEADER*)pImageData; if (pbmh) { pBits += sizeof(BITMAPINFOHEADER) + (pbmh->biClrUsed * sizeof(RGBQUAD)); } }
m_MemoryTransferInfo.mtipBits = pBits;
return TWRC_SUCCESS;}
|
