Sample Code
windows driver samples/ Windows Image Acquisition (WIA) Driver Samples/ C++/ ProdScan/ ScanJobs.cpp/
/**************************************************************************
*
* Copyright � Microsoft Corporation
*
* Title: ScanJobs.cpp
*
* Description: This file contains the implementation of the IWiaMiniDrv::
* drvAcquireItemData method and its helper methods used to
* execute scan job requests and transfer image and metadata
* files from or to the Production Scanner Driver Sample.
*
***************************************************************************/
#include "stdafx.h"
/**************************************************************************\
*
* Implements IWiaMiniDrv::drvAcquireItemData. This method is called by the
* WIA service when the driver must transfer image data to the application.
* This driver implements the Stream based WIA 2.0 transfer model introduced
* in Windows Vista. This call correponds to one scan job executed at the device
* (scaner starts, scan documents and transfers data, scanner stops).
*
* Parameters:
*
* pWiasContext - pointer to the item context
* lFlags - reserved (set to 0)
* pmdtc - pointer to a MINIDRV_TRANSFER_CONTEXT structure
* containing the device transfer context
* plDevErrVal - unused (drvGetDeviceErrorStr unsupported)
*
* Return Value:
*
* S_OK if successful, S_FALSE if the transfer is canceled
* or an error HRESULT if an error occurrs
*
\**************************************************************************/
HRESULT CWiaDriver::drvAcquireItemData(
_In_ BYTE* pWiasContext,
LONG lFlags,
_In_ PMINIDRV_TRANSFER_CONTEXT pmdtc,
_Out_ LONG* plDevErrVal)
{
HRESULT hr = S_OK;
GUID guidItemCategory = GUID_NULL;
BSTR bstrItemName = NULL;
BSTR bstrFullItemName = NULL;
WIA_DRIVER_ITEM_CONTEXT *pWiaDriverItemContext = NULL;
IWiaMiniDrvTransferCallback *pTransferCallback = NULL;
WiaTransferParams *pCallbackTransferParams = NULL;
BYTE *pTransferBuffer = NULL;
ULONG ulBufferSize = 0;
BOOL bImageTransfer = TRUE;
WIAEX_TRACE_BEGIN;
//
// Validate parameters:
//
if ((!pWiasContext) || (!pmdtc) || (!plDevErrVal) || (!pmdtc->pIWiaMiniDrvCallBack))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
//
// Identify the item to execute the acquisition for checking WIA_IPA_ITEM_CATEGORY:
//
if (SUCCEEDED(hr))
{
hr = wiasReadPropGuid(pWiasContext, WIA_IPA_ITEM_CATEGORY, &guidItemCategory, NULL, TRUE);
if (SUCCEEDED(hr))
{
bImageTransfer = (IsEqualGUID(WIA_CATEGORY_FLATBED, guidItemCategory) ||
IsEqualGUID(WIA_CATEGORY_FEEDER, guidItemCategory) || IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory));
}
else
{
WIAEX_ERROR((g_hInst, "Failed to read WIA_IPA_ITEM_CATEGORY property, hr = 0x%08X", hr));
}
}
//
// Get the item names, we will need them when requesting a new WIA transfer stream:
//
if (SUCCEEDED(hr))
{
hr = wiasReadPropStr(pWiasContext, WIA_IPA_ITEM_NAME, &bstrItemName, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading WIA_IPA_ITEM_NAME, hr = 0x%08X", hr));
}
}
if (SUCCEEDED(hr))
{
hr = wiasReadPropStr(pWiasContext, WIA_IPA_FULL_ITEM_NAME, &bstrFullItemName, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading WIA_IPA_FULL_ITEM_NAME, hr = 0x%08X", hr));
}
}
//
// Transfers from the Root item are not supported:
//
if (SUCCEEDED(hr) && (IsEqualGUID(WIA_CATEGORY_ROOT, guidItemCategory)))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Acquisition not supported from the Root item, hr = 0x%08X", hr));
}
//
// Get the private context data for this item. This sample driver stores in this data
// an image that the WIA application uploads in this session to the Imprinter or the
// Endorser and that should be used in subsequent downloads from the respective item:
//
if (SUCCEEDED(hr))
{
hr = wiasGetDriverItemPrivateContext(pWiasContext, (BYTE**)&pWiaDriverItemContext);
if (SUCCEEDED(hr) && (!pWiaDriverItemContext))
{
hr = E_POINTER;
}
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to retrieve the driver item context data, hr = 0x%08X", hr));
}
}
//
// Check the requested direction for this data transfer. Download means from the driver to the
// application (from the scanner device to the PC). Upload means from the application to the
// driver (from the PC to the scanner device). For a stream upload the flag value is
// WIA_MINIDRV_TRANSFER_UPLOAD while for a WIA 1.0 tymed-style transfer the flag value is 0:
//
if (SUCCEEDED(hr) && (bImageTransfer || IsEqualGUID(WIA_CATEGORY_BARCODE_READER, guidItemCategory) ||
IsEqualGUID(WIA_CATEGORY_PATCH_CODE_READER, guidItemCategory) ||
IsEqualGUID(WIA_CATEGORY_MICR_READER, guidItemCategory)) && (!(lFlags & WIA_MINIDRV_TRANSFER_DOWNLOAD)))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst,
"Invalid transfer flag parameter requested, this driver supports only download transfer direction for image data, barcode, patch code and MICR metadata, hr = 0x%08X",
hr));
}
if (SUCCEEDED(hr))
{
*plDevErrVal = 0;
}
//
// Get the WIA transfer callback interface to use for these transfers:
//
if (SUCCEEDED(hr))
{
hr = pmdtc->pIWiaMiniDrvCallBack->QueryInterface(IID_IWiaMiniDrvTransferCallback, (void**)&pTransferCallback);
if (SUCCEEDED(hr) && (!pTransferCallback))
{
hr = E_POINTER;
}
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to retrieve IID_IWiaMiniDrvTransferCallback interface, scan failed, hr = 0x%08X", hr));
}
}
//
// Allocate memory for the WIA transfer parameters structure and the transfer buffer:
//
if (SUCCEEDED(hr))
{
pCallbackTransferParams = (WiaTransferParams*)CoTaskMemAlloc(sizeof(WiaTransferParams));
if (!pCallbackTransferParams)
{
hr = E_OUTOFMEMORY;
WIAEX_ERROR((g_hInst, "Memory allocation for transfer parameters failed, scan failed, hr = 0x%08X", hr));
}
else
{
memset(pCallbackTransferParams, 0, sizeof(WiaTransferParams));
}
}
if (SUCCEEDED(hr))
{
hr = AllocateTransferBuffer(&pTransferBuffer, &ulBufferSize);
if (!pTransferBuffer)
{
hr = E_OUTOFMEMORY;
WIAEX_ERROR((g_hInst, "Memory allocation for transfer buffer failed, scan failed, hr = 0x%08X", hr));
}
}
if (SUCCEEDED(hr))
{
//
// The CWiaDriver::Download and CWiaDriver::Upload methods called below
// fully trace their execution, no need to trace additionally here.
// Also note that the pInputStrem stream is released by these functions:
//
if (lFlags & WIA_MINIDRV_TRANSFER_DOWNLOAD)
{
//
// 'Download' transfer direction (driver to application)
//
hr = Download(pWiasContext, guidItemCategory, bstrItemName, bstrFullItemName, pmdtc, pTransferBuffer,
ulBufferSize, pTransferCallback, pCallbackTransferParams, pWiaDriverItemContext);
}
else if (lFlags & WIA_MINIDRV_TRANSFER_UPLOAD)
{
//
// 'Upload' transfer direction (application to driver)
//
hr = Upload(pWiasContext, guidItemCategory, bstrItemName, bstrFullItemName, pTransferBuffer,
ulBufferSize, pTransferCallback, pCallbackTransferParams, pWiaDriverItemContext);
}
}
//
// Note that WIA_TRANSFER_MSG_END_OF_STREAM and WIA_TRANSFER_MSG_END_OF_TRANSFER
// are sent to the WIA application by the WIA service itself (first when the driver
// asks for a new stream), the driver should not send these itself.
//
//
// Clean-up for this scan job:
//
if (bstrItemName)
{
SysFreeString(bstrItemName);
}
if (bstrFullItemName)
{
SysFreeString(bstrFullItemName);
}
if (pTransferBuffer)
{
FreeTransferBuffer(pTransferBuffer);
}
if (pCallbackTransferParams)
{
CoTaskMemFree(pCallbackTransferParams);
}
if (pTransferCallback)
{
pTransferCallback->Release();
}
if (FAILED(hr))
{
m_hrLastEdviceError = hr;
}
WIAEX_TRACE((g_hInst, "IWiaMiniDrv::drvAcquireItemData 0x%08X", hr));
return hr;
}
/**************************************************************************\
*
* Helper for CWiaDriver::drvAcquireItemData. Executes the download data
* transfer sequence for the current scan job,
*
* Parameters:
*
* pWiasContext - item context
* guidItemCategory - item category
* bstrItemName - item name
* bstrFullItemName - full item name
* pmdc - driver transfer context data
* pTransferBuffer - pre-allocated transfer buffer
* ulBufferSize - size of the pre-allocated transfer buffer, in bytes
* pTransferCallback - IWiaMiniDrvTransferCallback* for WIA status
* pCallbackTransferParams - WiaTransferParams* for WIA status callbacks
* ulEstimatedFileSize - estimated file size, in bytes (0 if unknown)
*
* Return Value:
*
* S_OK if successful, S_FALSE if the transfer is canceled
* or an error HRESULT if an error occurrs
*
\**************************************************************************/
HRESULT
CWiaDriver::Download(
_In_ BYTE *pWiasContext,
GUID guidItemCategory,
_In_ BSTR bstrItemName,
_In_ BSTR bstrFullItemName,
_In_ PMINIDRV_TRANSFER_CONTEXT pmdtc,
_In_reads_bytes_(ulBufferSize) BYTE *pTransferBuffer,
ULONG ulBufferSize,
_In_ IWiaMiniDrvTransferCallback *pTransferCallback,
_In_ WiaTransferParams *pCallbackTransferParams,
_In_ WIA_DRIVER_ITEM_CONTEXT *pWiaDriverItemContext)
{
HRESULT hr = S_OK;
IStream *pInputStream = NULL;
IStream *pOutputStream = NULL;
LONG lPagesToScan = 1;
LONG lJobSeparators = WIA_SEPARATOR_DISABLED;
LONG lMultiFeed = WIA_MULTI_FEED_DETECT_DISABLED;
LONG lDataType = WIA_DATA_GRAYSCALE;
LONG lCompression = WIA_COMPRESSION_NONE;
LONG lPixelsPerLine = 0;
LONG lNumberOfLines = 0;
LONG lBytesPerLine = 0;
LONG lFilesToProcess = 1;
LONG lFilesProcessed = 0;
ULONG ulEstimatedFileSize = 0;
ULONG ulFileSize = 0;
ULONG_PTR pGDIPlusToken = NULL;
LONG lGDIPlus_PixelsPerLine = 0;
LONG lGDIPlus_NumberOfLines = 0;
LONG lGDIPlus_BytesPerLine = 0;
DWORD dwJobStart = 0;
IStream *pWiaStream = NULL;
BOOL bCancelTransfer = FALSE;
BOOL bSkipTransfer = FALSE;
BOOL bImageTransfer = (IsEqualGUID(WIA_CATEGORY_FLATBED, guidItemCategory) ||
IsEqualGUID(WIA_CATEGORY_FEEDER, guidItemCategory) || IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory));
WIAEX_TRACE_BEGIN;
if ((!pWiasContext) || (!bstrItemName) || (!bstrFullItemName) || (!pmdtc) || (!pTransferBuffer) || (!pTransferCallback) || (!pCallbackTransferParams))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
//
// Reset the recorded scan available input source, if any, ignoring failures:
//
if (SUCCEEDED(hr) && bImageTransfer)
{
UpdateScanAvailableItemName(NULL);
}
//
// For image transfers from feeder, use WIA_IPS_PAGES to know the number of images expected to transfer in this job:
//
if (SUCCEEDED(hr))
{
if (IsEqualGUID(guidItemCategory, WIA_CATEGORY_FEEDER))
{
//
// When WIA_IPS_PAGES is set to 0 (ALL_PAGES) meaning "scan as
// many documents as there may be loaded into the feeder" this
// sample driver will transfer up to MAX_SCAN_PAGES:
//
hr = wiasReadPropLong(pWiasContext, WIA_IPS_PAGES, &lPagesToScan, NULL, TRUE);
if (SUCCEEDED(hr))
{
if (ALL_PAGES == lPagesToScan)
{
lPagesToScan = MAX_SCAN_PAGES;
}
}
else
{
lPagesToScan = 1;
WIAEX_ERROR((g_hInst, "Failed reading the WIA_IPS_PAGES property, hr = 0x%08X", hr));
}
}
else if (IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory))
{
//
// In full automatic mode scan as many pages as the device decides to allow:
//
lPagesToScan = MAX_SCAN_PAGES;
}
else
{
//
// One single document page to scan from the flatbed or one single metadata file:
//
lPagesToScan = 1;
}
}
if (SUCCEEDED(hr) && bImageTransfer)
{
WIAS_TRACE((g_hInst, "Pages to scan: %u (0 means all)", lPagesToScan));
}
//
// For feeder acquisitions, this sample driver simulates a job separator every
// JOB_SEPARATOR_AT_PAGE page and a multi-feed every MULTI_FEED_AT_PAGE pages:
//
if (SUCCEEDED(hr) && IsEqualGUID(guidItemCategory, WIA_CATEGORY_FEEDER))
{
hr = wiasReadPropLong(pWiasContext, WIA_IPS_JOB_SEPARATORS, &lJobSeparators, NULL, TRUE);
if (SUCCEEDED(hr))
{
hr = wiasReadPropLong(pWiasContext, WIA_IPS_MULTI_FEED, &lMultiFeed, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading the WIA_IPS_MULTI_FEED property, hr = 0x%08X", hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed reading the WIA_IPS_JOB_SEPARATORS property, hr = 0x%08X", hr));
}
}
//
// For feeder acquisitions, if WIA_IPS_FEEDER_CONTROL is set to WIA_FEEDER_CONTROL_MANUAL
// and the feeder is not running, start the feeder and reset the feeder control to automatic
// mode, updating WIA_IPS_FEEDER_CONTROL to WIA_FEEDER_CONTROL_AUTO:
//
if (SUCCEEDED(hr) && IsEqualGUID(guidItemCategory, WIA_CATEGORY_FEEDER))
{
LONG lFeederControl = WIA_FEEDER_CONTROL_AUTO;
hr = wiasReadPropLong(pWiasContext, WIA_IPS_FEEDER_CONTROL, &lFeederControl, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading the WIA_IPS_FEEDER_CONTROL property, hr = 0x%08X", hr));
}
if (SUCCEEDED(hr) && (WIA_FEEDER_CONTROL_MANUAL == lFeederControl) && (!m_bFeederStarted))
{
hr = StartFeeder();
if (SUCCEEDED(hr))
{
lFeederControl = WIA_FEEDER_CONTROL_AUTO;
hr = wiasWritePropLong(pWiasContext, WIA_IPS_FEEDER_CONTROL, lFeederControl);
if (SUCCEEDED(hr))
{
WIAS_TRACE((g_hInst, "Reverted to WIA_FEEDER_CONTROL_AUTO"));
}
else
{
WIAEX_ERROR((g_hInst, "Failed to reset the WIA_IPS_FEEDER_CONTROL property, hr = 0x%08X", hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "Cannot start the feeder, hr = 0x%08X", hr));
}
}
}
//
// Read the current data type configured for this image source:
//
if (SUCCEEDED(hr) && bImageTransfer && (!IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory)))
{
hr = wiasReadPropLong(pWiasContext, WIA_IPA_DATATYPE, &lDataType, NULL, TRUE);
if (SUCCEEDED(hr))
{
if (WIA_DATA_AUTO == lDataType)
{
//
// When WIA_DATA_AUTO is set the sample driver choses randomly between WIA_DATA_GRAYSCALE
// and WIA_DATA_COLOR. A real driver should base this decision on the actual scan document,
// each document page preferrably. This sample driver uses the same test image to transfer
// all single-file page scans in a job so this initialization is only performed once, for
// the entire job:
//
lDataType = (rand() % 2) ? WIA_DATA_GRAYSCALE : WIA_DATA_COLOR;
WIAS_TRACE((g_hInst, "Detected data type in automatic mode: %ws",
(WIA_DATA_GRAYSCALE == lDataType) ? L"8-bpp grayscale" : L"24-bpp RGB color"));
//
// Updated dependent image information properties:
//
hr = UpdateImageInfoProperties(pWiasContext, lDataType);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to update dependent image information properties, hr = 0x%08X", hr));
}
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed to read WIA_IPA_DATATYPE property, hr = 0x%08X", hr));
}
}
//
// How many files and transfer streams the driver needs for this drvAcquireItemData call:
//
// a) For transfers from Feeder WIA_IPS_PAGES indicates the number of files.
// b) For transfers from Flatbed there is always just one file.
// c) For multi-page transfers (which this sample driver doesn't support) there would be just one file.
//
if (SUCCEEDED(hr))
{
if ((IsEqualGUID(guidItemCategory, WIA_CATEGORY_FEEDER)) || (IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory)))
{
lFilesToProcess = lPagesToScan;
}
else
{
lFilesToProcess = 1;
}
WIAS_TRACE((g_hInst, "Files to transfer: %u", lFilesToProcess));
}
if (SUCCEEDED(hr))
{
//
// Check first if we have a (previously uploaded in this session) imprinter/endorser image to use:
//
if (pWiaDriverItemContext->m_pUploadedImage)
{
pInputStream = pWiaDriverItemContext->m_pUploadedImage;
}
else
{
//
// Create a new global memory stream to store the transfer data file:
//
hr = CreateStreamOnHGlobal(NULL, TRUE, &pInputStream);
if (SUCCEEDED(hr) && (!pInputStream))
{
hr = E_FAIL;
}
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "CreateStreamOnHGlobal failed, hr = 0x%08X", hr));
}
//
// Read from resources or generate the test data file (image or metadata) to be downloaded
// to the application, storing this data into the new memory stream:
//
if (SUCCEEDED(hr))
{
ULONG ulResource = 0;
if (bImageTransfer)
{
ulResource = (WIA_DATA_COLOR == lDataType) ? IDB_TESTIMAGE_COLOR : IDB_TESTIMAGE_GRAY;
}
else if ((IsEqualGUID(WIA_CATEGORY_IMPRINTER, guidItemCategory) || IsEqualGUID(WIA_CATEGORY_ENDORSER, guidItemCategory))
&& IsEqualGUID(WiaImgFmt_BMP, pmdtc->guidFormatID))
{
//
// The sample driver will generate itself the WiaImgFmt_CSV and WiaImgFmt_TXT files:
//
ulResource = IDB_TEST_IMPRINTER_IMAGE;
}
else if (IsEqualGUID(WIA_CATEGORY_BARCODE_READER, guidItemCategory) && IsEqualGUID(WiaImgFmt_XMLBAR, pmdtc->guidFormatID))
{
//
// The sample driver hard-codes the sample WiaImgFmt_RAWBAR file:
//
ulResource = IDB_BARCODE_SAMPLE;
}
else if (IsEqualGUID(WIA_CATEGORY_PATCH_CODE_READER, guidItemCategory) && IsEqualGUID(WiaImgFmt_XMLPAT, pmdtc->guidFormatID))
{
//
// The sample driver hard-codes the sample WiaImgFmt_RAWPAT file:
//
ulResource = IDB_PATCH_CODE_SAMPLE;
}
else if (IsEqualGUID(WIA_CATEGORY_MICR_READER, guidItemCategory) && IsEqualGUID(WiaImgFmt_XMLMIC, pmdtc->guidFormatID))
{
//
// The sample driver hard-codes the sample WiaImgFmt_RAWMIC file:
//
ulResource = IDB_MICR_SAMPLE;
}
if (ulResource)
{
hr = LoadTestDataResourceToStream(ulResource, pInputStream, &ulFileSize);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to load the test data file from resource %u, hr = 0x%08X", ulResource, hr));
}
}
else
{
hr = LoadTestDataToStream(pWiasContext, guidItemCategory, pmdtc->guidFormatID, pInputStream, &ulFileSize);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to load the test data file from resource %u, hr = 0x%08X", ulResource, hr));
}
}
}
}
}
//
// For image transfers, if the application asks for DIB (which the driver must always support) or Raw
// this sample driver converts the image from the attached EXIF test image to obtain the uncompressed
// image before the first image transfer takes place. For this the driver first runs the test image
// through the GDI+ DIB encoder to generate the DIB image to transfer to the WIA application.
//
if (S_OK == hr)
{
if (bImageTransfer && IsEqualGUID(pmdtc->guidFormatID, WiaImgFmt_BMP) || IsEqualGUID(pmdtc->guidFormatID, WiaImgFmt_RAW))
{
//
// Initialize GDI+ if the driver must translate scanned images to the DIB format:
//
if (S_OK == hr)
{
WIAS_TRACE((g_hInst, "Initialize GDI++.."));
hr = InitializeGDIPlus(&pGDIPlusToken);
if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "Failed to initialize GDI+, hr = 0x%08X", hr));
}
}
//
// Load the image to a GDI+ Image object (GDI+ cannot convert the image directly from the stream):
//
Image *pInputImage = NULL;
if (S_OK == hr)
{
pInputImage = Image::FromStream(pInputStream);
if (!pInputImage)
{
hr = E_FAIL;
WIAEX_ERROR((g_hInst, "Image::FromStream failed, hr = 0x%08X", hr));
}
}
//
// Release the input stream now, no longer needed, the same image is held by the Image object:
//
pInputStream->Release();
pInputStream = NULL;
//
// Hand the Image object to GDI+ to generate the DIB image:
//
if (S_OK == hr)
{
hr = ConvertImageToDIB(pInputImage, &pOutputStream,
&lGDIPlus_PixelsPerLine, &lGDIPlus_NumberOfLines, &lGDIPlus_BytesPerLine);
if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "Failed to convert scanned image file to DIB, hr = 0x%08X", hr));
}
}
//
// Free the GDI+ Image copy:
//
if (pInputImage)
{
delete pInputImage;
}
//
// Done with file format conversions, if any. Shutdown GDI+, no longer needed:
//
if (pGDIPlusToken)
{
WIAS_TRACE((g_hInst, "Shutdown GDI++.."));
ShutdownGDIPlus(pGDIPlusToken);
pGDIPlusToken = NULL;
}
//
// For a Raw image transfer, further convert the DIB to an uncompressed Raw image file:
//
if ((S_OK == hr) && IsEqualGUID(pmdtc->guidFormatID, WiaImgFmt_RAW))
{
IStream *pTempOutputStream = NULL;
hr = ConvertDibToRaw(pOutputStream, &pTempOutputStream);
if (S_OK == hr)
{
//
// Release pOutputStream then reset its pointer to the new stream:
//
pOutputStream->Release();
pOutputStream = pTempOutputStream;
pTempOutputStream = NULL;
}
}
//
// If not in auto-config mode check the actual image dimensions reported by GDI+.
// In both programmed and auto-config mode update the estimated file size from
// the image dimensions and depth reported by GDI+ during the conversion process:
//
if (S_OK == hr)
{
if (!IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory))
{
HRESULT hrTemp = S_OK;
//
// Update WIA_IPA_PIXELS_PER_LINE, WIA_IPA_NUMBER_OF_LINES and WIA_IPA_BYTES_PER_LINE:
//
hrTemp = wiasWritePropLong(pWiasContext, WIA_IPA_PIXELS_PER_LINE, lGDIPlus_PixelsPerLine);
if (FAILED(hrTemp))
{
WIAEX_ERROR((g_hInst, "Failed to update WIA_IPA_PIXELS_PER_LINE to %u, hr = 0x%08X",
lGDIPlus_PixelsPerLine, hrTemp));
}
if (SUCCEEDED(hrTemp))
{
hrTemp = wiasWritePropLong(pWiasContext, WIA_IPA_NUMBER_OF_LINES, lGDIPlus_NumberOfLines);
if (FAILED(hrTemp))
{
WIAEX_ERROR((g_hInst, "Failed to update WIA_IPA_NUMBER_OF_LINES to %u, hr = 0x%08X",
lGDIPlus_NumberOfLines, hrTemp));
}
}
if (SUCCEEDED(hrTemp))
{
hrTemp = wiasWritePropLong(pWiasContext, WIA_IPA_BYTES_PER_LINE, lGDIPlus_BytesPerLine);
if (FAILED(hrTemp))
{
WIAEX_ERROR((g_hInst, "Failed to update WIA_IPA_BYTES_PER_LINE to %u, hr = 0x%08X",
lGDIPlus_BytesPerLine, hrTemp));
}
}
}
}
}
}
//
// Estimate the size of uncompressed data we need to transfer for each file, assuming
// all images in the current acquisition sequence will be scanned using the same scan
// parameters. The estimate is relatively accurate for uncompressed data. Cannot use
// this kind of estimate for compressed data because of the unknown compression ratio:
//
if ((S_OK == hr) && bImageTransfer && (!IsEqualGUID(WIA_CATEGORY_AUTO, guidItemCategory)))
{
//
// Read the image information properties:
//
hr = wiasReadPropLong(pWiasContext, WIA_IPA_NUMBER_OF_LINES, &lNumberOfLines, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading WIA_IPA_NUMBER_OF_LINES, hr = 0x%08X", hr));
}
if (S_OK == hr)
{
hr = wiasReadPropLong(pWiasContext, WIA_IPA_BYTES_PER_LINE, &lBytesPerLine, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading WIA_IPA_BYTES_PER_LINE, hr = 0x%08X", hr));
}
}
if (S_OK == hr)
{
hr = wiasReadPropLong(pWiasContext, WIA_IPA_PIXELS_PER_LINE, &lPixelsPerLine, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading WIA_IPA_PIXELS_PER_LINE, hr = 0x%08X", hr));
}
}
if (S_OK == hr)
{
hr = wiasReadPropLong(pWiasContext, WIA_IPA_COMPRESSION, &lCompression, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed reading WIA_IPA_COMPRESSION, hr = 0x%08X", hr));
}
}
if ((S_OK == hr) && (lBytesPerLine > 0) && (WIA_COMPRESSION_NONE == lCompression))
{
ulEstimatedFileSize = lBytesPerLine * lNumberOfLines;
if (IsEqualGUID(pmdtc->guidFormatID, WiaImgFmt_BMP))
{
ulEstimatedFileSize += sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
}
else if (IsEqualGUID(pmdtc->guidFormatID, WiaImgFmt_RAW))
{
ulEstimatedFileSize += sizeof(WIA_RAW_HEADER);
}
WIAS_TRACE((g_hInst, "Transfer file size for uncompressed image data: %02.2f KB (%u BPL, %u lines)",
ulEstimatedFileSize / 1024.0f, lBytesPerLine, lNumberOfLines));
}
else
{
ulEstimatedFileSize = ulFileSize;
WIAS_TRACE((g_hInst, "Transfer file size for compressed image data: %02.2f KB (%u uncompreessed BPL, %u lines)",
ulEstimatedFileSize / 1024.0f, lBytesPerLine, lNumberOfLines));
}
}
if ((S_OK == hr) && (!bImageTransfer))
{
ulEstimatedFileSize = ulFileSize;
WIAS_TRACE((g_hInst, "Transfer file size for metadata: %02.2f bytes", ulEstimatedFileSize));
}
//
// Begin the actual data transfer procedure to the WIA application:
//
//
#pragma prefast(suppress:__WARNING_USE_OTHER_FUNCTION, "A sample scan job duration does not exceed 49 days. If there is risk to exceed, use GetTickCount64 instead:"
dwJobStart = GetTickCount();
lFilesProcessed = 0;
while (S_OK == hr)
{
bSkipTransfer = FALSE;
//
// Request a new WIA stream from the WIA client application:
//
if (S_OK == hr)
{
_Analysis_assume_nullterminated_(bstrItemName);
hr = pTransferCallback->GetNextStream(0, bstrItemName, bstrFullItemName, &pWiaStream);
if (S_FALSE == hr)
{
bCancelTransfer = TRUE;
WIAS_TRACE((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream returned S_FALSE (0x%08X), transfer must be canceled", hr));
}
else if (WIA_STATUS_SKIP_ITEM == hr)
{
bSkipTransfer = TRUE;
WIAS_TRACE((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream returned WIA_STATUS_SKIP_ITEM (0x%08X), transfer must be skipped", hr));
hr = S_OK;
}
else if (SUCCEEDED(hr) && (S_OK != hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream returned an unknown success value, hr = 0x%08X", hr));
hr = E_UNEXPECTED;
}
else if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream failed, hr = 0x%08X", hr));
}
}
//
// Signal start of data transfer to the WIA application and check
// if the application asks already for the transfers to be cancelled:
//
if ((S_OK == hr) && (!bSkipTransfer))
{
pCallbackTransferParams->lMessage = WIA_TRANSFER_MSG_STATUS;
pCallbackTransferParams->hrErrorStatus = 0;
pCallbackTransferParams->lPercentComplete = 0;
pCallbackTransferParams->ulTransferredBytes = 0;
WIAS_TRACE((g_hInst, "Transfer callback: WIA_TRANSFER_MSG_STATUS, 0 bytes"));
hr = pTransferCallback->SendMessage(0, pCallbackTransferParams);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage failed, hr = 0x%08X", hr));
}
else if (S_FALSE == hr)
{
bCancelTransfer = TRUE;
}
else if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage returned unknown success value, hr = 0x%08X", hr));
bCancelTransfer = TRUE;
hr = S_FALSE;
}
}
if (S_OK == hr)
{
if (bSkipTransfer)
{
WIAS_TRACE((g_hInst, "Discarding data to skip the current file transfer (%u)..", lFilesProcessed + 1));
}
else
{
//
// Read the test file and transfer it to the WIA application:
//
if ((S_OK == hr) && (!bCancelTransfer))
{
hr = TransferFile(pOutputStream ? pOutputStream : pInputStream, pWiaStream, pTransferBuffer, ulBufferSize,
pTransferCallback, pCallbackTransferParams, ulEstimatedFileSize, &bCancelTransfer);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "File transfer to WIA stream failed, hr = 0x%08X", hr));
}
}
}
}
//
// The transfer of one file was successfully completed, reset WIA_STATUS_END_OF_MEDIA:
//
if (WIA_STATUS_END_OF_MEDIA == hr)
{
WIAS_TRACE((g_hInst, "File transfer complete (WIA_STATUS_END_OF_MEDIA)"));
hr = S_OK;
}
//
// Signal 100% transfer complete to the WIA client application (pCallbackTransferParams->ulTransferredBytes
// contains the total number of bytes transferred to this stream):
//
if ((S_OK == hr) && (!bSkipTransfer))
{
pCallbackTransferParams->lMessage = WIA_TRANSFER_MSG_STATUS;
pCallbackTransferParams->hrErrorStatus = 0;
pCallbackTransferParams->lPercentComplete = 100;
WIAS_TRACE((g_hInst, "Transfer callback: WIA_TRANSFER_MSG_STATUS, transfer complete, %02.2f KB total (%u)",
pCallbackTransferParams->ulTransferredBytes / 1024.0f, pCallbackTransferParams->lPercentComplete));
hr = pTransferCallback->SendMessage(0, pCallbackTransferParams);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage(WIA_TRANSFER_MSG_STATUS, transfer complete) failed, hr = 0x%08X", hr));
}
else if (S_FALSE == hr)
{
bCancelTransfer = TRUE;
}
else if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage(WIA_TRANSFER_MSG_STATUS, transfer complete) returned unknown success value, hr = 0x%08X", hr));
bCancelTransfer = TRUE;
hr = S_FALSE;
}
}
//
// If the transfer was canceled from the client application send a CancelJob
// to the scanner device to ensure scanning is stopped and all scanned image
// data (not read yet) is discarded from the scanner internal buffer:
//
if (bCancelTransfer)
{
WIAS_TRACE((g_hInst, "Transfer cancelled from WIA application.."));
//
// Make sure hr is left set to S_FALSE (cancelled):
//
hr = S_FALSE;
}
//
// The current job must be canceled at the device if there is an error during the data
// transfer phase, error which may result in leaving the current job in a processing
// state and risk to block the scanner from accepting new jobs until this job times out:
//
else if (FAILED(hr))
{
WIAS_TRACE((g_hInst, "Transfer failed (hr = 0x%08X), abort job..", hr));
}
//
// Clean-up after finishing each individual WIA file transfer:
//
pCallbackTransferParams->lPercentComplete = 0;
pCallbackTransferParams->ulTransferredBytes = 0;
//
// Release the current WIA transfer stream:
//
if (pWiaStream)
{
pWiaStream->Release();
pWiaStream = NULL;
}
//
// Note the loop ends when hr != S_OK.
//
// Increment the number of streams (files) transferred
// and check if we must end the transfers here:
//
if (S_OK == hr)
{
//
// If a finite number of files must be processed (transferred and/or skipped):
//
lFilesProcessed++;
WIAS_TRACE((g_hInst, "Successfully transferred %u file(s)", lFilesProcessed));
if (lFilesToProcess && (lFilesProcessed >= lFilesToProcess))
{
//
// Note that in general for the Feeder item the driver must signal
// end of paper, not S_OK (as documented by MSDN), to ensure that the
// application does not request another drvAcquireItemData. In this
// case however we transfer multiple files in a single call so we
// won't do this:
//
// if (IsEqualGUID(WIA_CATEGORY_FEEDER, guidItemCategory))
// {
// hr = WIA_ERROR_PAPER_EMPTY;
// }
//
//
// Do not transfer another file for this call:
//
hr = WIA_STATUS_END_OF_MEDIA;
}
//
// For feeder acquisitions, if job separators and/or multi-feed detection is enabled,
// check if the sample driver needs to perform an action here (such as stopping the scan):
//
else if ((!(lFilesProcessed % JOB_SEPARATOR_AT_PAGE)) && (WIA_SEPARATOR_DISABLED != lJobSeparators))
{
WIAS_TRACE((g_hInst, "Job separator detected"));
if ((WIA_SEPARATOR_DETECT_SCAN_STOP == lJobSeparators) || (WIA_SEPARATOR_DETECT_NOSCAN_STOP == lJobSeparators))
{
WIAS_TRACE((g_hInst, "End of scan job due to job separator"));
hr = WIA_STATUS_END_OF_MEDIA;
}
}
else if ((!(lFilesProcessed % MULTI_FEED_AT_PAGE)) && (WIA_MULTI_FEED_DETECT_DISABLED != lMultiFeed))
{
WIAS_TRACE((g_hInst, "Multi-feed detected"));
if (WIA_MULTI_FEED_DETECT_STOP_SUCCESS == lMultiFeed)
{
WIAS_TRACE((g_hInst, "End of scan job due to multi-feed"));
hr = WIA_STATUS_END_OF_MEDIA;
}
else if (WIA_MULTI_FEED_DETECT_STOP_ERROR == lMultiFeed)
{
WIAS_TRACE((g_hInst, "Failed scan job due to multi-feed"));
hr = WIA_ERROR_MULTI_FEED;
}
}
//
// For image transfers, if lFileToTransfer is 0 (ALL_PAGES) the transfers end (with S_OK) when either:
//
// 1) an error occurrs;
// 2) a file transfer is canceled (either from the app or the scanner);
// 3) when RetrieveImage would return WIA_ERROR_PAPER_EMPTY.
//
}
}
//
// Compute the number of pages per minute (PPM) transferred for this job:
//
if ((lFilesProcessed > 0) && bImageTransfer)
{
#pragma prefast(suppress:__WARNING_USE_OTHER_FUNCTION, "A sample scan job duration does not exceed 49 days. If there is risk to exceed, use GetTickCount64 instead:"
DWORD dwJobEnd = GetTickCount();
if (dwJobEnd > dwJobStart)
{
float fSecondsElapsed = (dwJobEnd - dwJobStart) / 1000.0f;
if (lFilesProcessed > 1)
{
DWORD dwPagesPerMinute = (DWORD)((60 * lFilesProcessed) / fSecondsElapsed);
WIAS_TRACE((g_hInst, "Measured scan performance for this job is %u PPM (%u single-page image files transferred in %0.2f seconds)",
dwPagesPerMinute, lFilesProcessed, fSecondsElapsed));
}
else
{
WIAS_TRACE((g_hInst, "1 image file transferred in %0.2f seconds", fSecondsElapsed));
}
}
}
//
// Keep the image in the item context, if there is one:
//
if (pWiaDriverItemContext->m_pUploadedImage)
{
pInputStream = NULL;
}
//
// Clean-up for memory streams (set to automatically free memory on release)
// used for the test image:
//
if (pInputStream)
{
pInputStream->Release();
}
if (pOutputStream)
{
pOutputStream->Release();
}
//
// The transfers (of all files) were successfully completed, reset WIA_STATUS_END_OF_MEDIA:
//
if (WIA_STATUS_END_OF_MEDIA == hr)
{
WIAS_TRACE((g_hInst, "All files successfully transferred"));
hr = S_OK;
}
//
// If this job call is about to return WIA_ERROR_PAPER_EMPTY we have to consider
// first the following conditions:
//
// - if an undefined number of transfers had to be performed and at least
// one file was transferred the return code must be changed to S_OK;
//
// - if a finite number of transfers had to be performed and all these
// transfers have been done the return code must be changed to S_OK;
//
// - if a finite number of transfers had to be performed and at least one
// of these transfers - but not all of them - has been done the return
// code must be changed to WIA_STATUS_END_OF_MEDIA;
//
// - WIA_ERROR_PAPER_EMPTY must be returned only when no transfers could
// be completed in the current drvAcquireItemData call.
//
if (WIA_ERROR_PAPER_EMPTY == hr)
{
if (((!lFilesToProcess) && (lFilesProcessed >= 1)) ||
((lFilesToProcess > 0) && (lFilesProcessed >= lFilesToProcess)))
{
WIAS_TRACE((g_hInst, "Running out of paper, returning S_OK for drvAcquireItemData.."));
hr = S_OK;
}
else if ((lFilesToProcess > 0) && (lFilesProcessed < lFilesToProcess) && (lFilesProcessed >= 1))
{
WIAS_TRACE((g_hInst, "Running out of paper, returning WIA_STATUS_END_OF_MEDIA for drvAcquireItemData.."));
hr = WIA_STATUS_END_OF_MEDIA;
}
else
{
WIAS_TRACE((g_hInst, "Running out of paper, returning WIA_ERROR_PAPER_EMPTY for drvAcquireItemData.."));
}
}
else if (WIA_ERROR_MULTI_FEED == hr)
{
WIAS_TRACE((g_hInst, "Multi-feed error, returning WIA_ERROR_MULTI_FEED for drvAcquireItemData.."));
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for CWiaDriver::drvAcquireItemData. Executes the upload data
* transfer sequence for the current scan job,
*
* Parameters:
*
* pWiasContext - item context
* guidItemCategory - item category
* bstrItemName - item name
* bstrFullItemName - full item name
* pmdc - driver transfer context data
* pTransferBuffer - pre-allocated transfer buffer
* ulBufferSize - size of the pre-allocated transfer buffer, in bytes
* pTransferCallback - IWiaMiniDrvTransferCallback* for WIA status
* pCallbackTransferParams - WiaTransferParams* for WIA status callbacks
* ulEstimatedFileSize - estimated file size, in bytes (0 if unknown)
*
* Return Value:
*
* S_OK if successful, S_FALSE if the transfer is canceled
* or an error HRESULT if an error occurrs
*
\**************************************************************************/
HRESULT
CWiaDriver::Upload(
_In_ BYTE *pWiasContext,
GUID guidItemCategory,
_In_ BSTR bstrItemName,
_In_ BSTR bstrFullItemName,
_In_reads_bytes_(ulBufferSize) BYTE *pTransferBuffer,
ULONG ulBufferSize,
_In_ IWiaMiniDrvTransferCallback *pTransferCallback,
_In_ WiaTransferParams *pCallbackTransferParams,
_In_ WIA_DRIVER_ITEM_CONTEXT *pWiaDriverItemContext)
{
HRESULT hr = S_OK;
IStream *pInputStream = NULL;
IStream *pWiaStream = NULL;
BOOL bCancelTransfer = FALSE;
BOOL bSkipTransfer = FALSE;
GUID guidUploadFormat = GUID_NULL;
WIAEX_TRACE_BEGIN;
if ((!pWiasContext) || (!bstrItemName) || (!bstrFullItemName) || (!pTransferBuffer) || (!pTransferCallback) || (!pCallbackTransferParams))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
if ((!IsEqualGUID(WIA_CATEGORY_IMPRINTER, guidItemCategory)) && (!IsEqualGUID(WIA_CATEGORY_ENDORSER, guidItemCategory)))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "This driver does not support upload transfer direction for the requested item, hr = 0x%08X", hr));
}
//
// Create a new global memory stream to store the transfer data file:
//
if (SUCCEEDED(hr))
{
hr = CreateStreamOnHGlobal(NULL, TRUE, &pInputStream);
if (SUCCEEDED(hr) && (!pInputStream))
{
hr = E_FAIL;
}
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "CreateStreamOnHGlobal failed, hr = 0x%08X", hr));
}
}
//
// This sample driver executes a very simple data transfer upload for the imprinter/endorser data.
//
// For WiaImgFmt_BMP transfers the driver validates that the image dimensions match
// WIA_IPS_PRINTER_ENDORSER_GRAPHICS_MIN/MAX_WIDTH/HEIGHT dimensions.
//
// For WiaImgFmt_TXT and WiaImgFmt_CSV transfers the driver loads the transferred text and
// attempts to update the current WIA_IPS_PRINTER_ENDORSER_STRING value with it, performing
// validation as if the application would directly set WIA_IPS_PRINTER_ENDORSER_STRING.
//
// It was already validated that WIA_MINIDRV_TRANSFER_UPLOAD works only for
// WIA_CATEGORY_IMPRINTER and WIA_CATEGORY_ENDORSER.
//
//
// Request the WIA transfer stream from the WIA client application:
//
if (SUCCEEDED(hr))
{
_Analysis_assume_nullterminated_(bstrItemName);
hr = pTransferCallback->GetNextStream(0, bstrItemName, bstrFullItemName, &pWiaStream);
if (S_FALSE == hr)
{
bCancelTransfer = TRUE;
WIAS_TRACE((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream returned S_FALSE (0x%08X), transfer must be canceled", hr));
}
else if (WIA_STATUS_SKIP_ITEM == hr)
{
bSkipTransfer = TRUE;
WIAS_TRACE((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream returned WIA_STATUS_SKIP_ITEM (0x%08X), transfer must be skipped", hr));
hr = S_OK;
}
else if (SUCCEEDED(hr) && (S_OK != hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream returned an unknown success value, hr = 0x%08X", hr));
hr = E_UNEXPECTED;
}
else if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::GetNextStream failed, hr = 0x%08X", hr));
}
}
//
// Signal start of data transfer from the WIA application and check if the application asks for the transfer to be cancelled:
//
if ((S_OK == hr) && (!bSkipTransfer))
{
pCallbackTransferParams->lMessage = WIA_TRANSFER_MSG_STATUS;
pCallbackTransferParams->hrErrorStatus = 0;
pCallbackTransferParams->lPercentComplete = 0;
pCallbackTransferParams->ulTransferredBytes = 0;
WIAS_TRACE((g_hInst, "Transfer callback: WIA_TRANSFER_MSG_STATUS, 0 bytes"));
hr = pTransferCallback->SendMessage(0, pCallbackTransferParams);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage failed, hr = 0x%08X", hr));
}
else if (S_FALSE == hr)
{
bCancelTransfer = TRUE;
}
else if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage returned unknown success value, hr = 0x%08X", hr));
bCancelTransfer = TRUE;
hr = S_FALSE;
}
}
if ((S_OK == hr) && (!bSkipTransfer))
{
//
// Transfer the file from the WIA application:
//
if ((S_OK == hr) && (!bCancelTransfer))
{
hr = TransferFile(pWiaStream, pInputStream, pTransferBuffer, ulBufferSize,
pTransferCallback, pCallbackTransferParams, 0, &bCancelTransfer);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "File transfer from the WIA stream failed, hr = 0x%08X", hr));
}
}
}
//
// The transfer of one file was successfully completed, reset WIA_STATUS_END_OF_MEDIA:
//
if (WIA_STATUS_END_OF_MEDIA == hr)
{
WIAS_TRACE((g_hInst, "File transfer complete (WIA_STATUS_END_OF_MEDIA)"));
hr = S_OK;
}
//
// Signal 100% transfer complete to the WIA client application (pCallbackTransferParams->ulTransferredBytes
// contains the total number of bytes transferred to this stream):
//
if ((S_OK == hr) && (!bSkipTransfer))
{
pCallbackTransferParams->lMessage = WIA_TRANSFER_MSG_STATUS;
pCallbackTransferParams->hrErrorStatus = 0;
pCallbackTransferParams->lPercentComplete = 100;
WIAS_TRACE((g_hInst, "Transfer callback: WIA_TRANSFER_MSG_STATUS, transfer complete, %02.2f KB total (%u)",
pCallbackTransferParams->ulTransferredBytes / 1024.0f, pCallbackTransferParams->lPercentComplete));
hr = pTransferCallback->SendMessage(0, pCallbackTransferParams);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage(WIA_TRANSFER_MSG_STATUS, transfer complete) failed, hr = 0x%08X", hr));
}
}
//
// Clean-up after finishing each individual WIA file transfer:
//
pCallbackTransferParams->lPercentComplete = 0;
pCallbackTransferParams->ulTransferredBytes = 0;
//
// Release the current WIA transfer stream:
//
if (pWiaStream)
{
pWiaStream->Release();
pWiaStream = NULL;
}
//
// For upload transfers we need to check the current WIA_IPA_FORMAT to see what
// format is the file that was uploaded by the application, the MINIDRV_TRANSFER_CONTEXT
// structure not being initialized with the right file format in this case.
// Remember that the WIA application needs to set WIA_IPA_FORMAT before calling
// IWiaTransfer::Upload:
//
if (S_OK == hr)
{
hr = wiasReadPropGuid(pWiasContext, WIA_IPA_FORMAT, &guidUploadFormat, NULL, TRUE);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to read WIA_IPA_FORMAT, hr = 0x%08X", hr));
}
}
if (S_OK == hr)
{
//
// At this point pInputStream contains the data uploaded by the application
//
if (IsEqualGUID(WiaImgFmt_BMP, guidUploadFormat))
{
if (SUCCEEDED(IsDibValid(pInputStream, 1, IMPRINTER_MAX_WIDTH, IMPRINTER_MAX_HEIGHT)))
{
if (pWiaDriverItemContext->m_pUploadedImage)
{
IStream *pTemp = pWiaDriverItemContext->m_pUploadedImage;
pWiaDriverItemContext->m_pUploadedImage = NULL;
pTemp->Release();
}
pWiaDriverItemContext->m_pUploadedImage = pInputStream;
pInputStream = NULL;
}
else
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst,
"The uploaded WiaImgFmt_BMP (DIB) image is invalid. This item accepts only a 1-bpp %ux%u pixels image, bottom to top line order, hr = 0x%08X",
IMPRINTER_MAX_WIDTH, IMPRINTER_MAX_HEIGHT, hr));
}
}
else if (IsEqualGUID(WiaImgFmt_TXT, guidUploadFormat) || IsEqualGUID(WiaImgFmt_CSV, guidUploadFormat))
{
if (FAILED(IsImprinterEndorserTextValid(pWiasContext, pInputStream, IsEqualGUID(WIA_CATEGORY_IMPRINTER, guidItemCategory) ? IMPRINTER : ENDORSER)))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "The uploaded text data is invalid, hr = 0x%08X", hr));
}
}
else
{
USHORT *pUUID = NULL;
hr = E_INVALIDARG;
if (RPC_S_OK == UuidToStringW(&guidUploadFormat, &pUUID))
{
WIAEX_ERROR((g_hInst, "Unsupported upload transfer file format (%ws), hr = 0x%08X", pUUID, hr));
RpcStringFreeW(&pUUID);
}
else
{
WIAEX_ERROR((g_hInst, "Unsupported upload transfer file format, hr = 0x%08X", hr));
}
}
}
if (pInputStream)
{
pInputStream->Release();
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for CWiaDriver::drvAcquireItemData. Transfers one file (image or
* metadata) to the WIA transfer stream provided by the aplication. Note that
* for image file transfers it is not a good solution to let GDI+ to write the
* image directly to the WIA transfer stream as the WIA stream has special
* requirements such as predetermined buffer size, reposition of the write
* cursor at the beginning of the stream between writes and WIA notifications.
*
* Parameters:
*
* pInputStream - IStream object to read the file from
* pDestinationStream - IStream object to write the file to
* pTransferBuffer - pre-allocated transfer buffer
* ulBufferSize - size of the pre-allocated transfer buffer, in bytes
* pTransferCallback - optional IWiaMiniDrvTransferCallback* for WIA status
* pCallbackTransferParams - optional WiaTransferParams* for WIA status callbacks
* ulEstimatedFileSize - estimated file size, in bytes (0 if unknown)
* pbCancelTransfer - on return indicates if the WIA client canceled
* the operation
*
* Remarks:
*
* The caller may specify a non zero pCallbackTransferParams->lPercentComplete
* value (between 0% and 49%) to have this function resume incrementing the
* percent complete starting from this value. An invalid value is set to 0%
* and does not cause the function to fail (still, the caller must not do this).
*
* Return Value:
*
* WIA_STATUS_END_OF_MEDIA if successful, S_FALSE if the transfer
* is canceled or an error HRESULT if an error occurrs
*
\**************************************************************************/
HRESULT
CWiaDriver::TransferFile(
_In_ IStream *pInputStream,
_In_ IStream *pDestinationStream,
_In_reads_bytes_(ulBufferSize)
BYTE *pTransferBuffer,
ULONG ulBufferSize,
_In_opt_ IWiaMiniDrvTransferCallback *pTransferCallback,
_In_opt_ WiaTransferParams *pCallbackTransferParams,
ULONG ulEstimatedFileSize,
_Out_ BOOL *pbCancelTransfer)
{
HRESULT hr = S_OK;
HRESULT hrTemp = S_OK;
ULONG ulBytesToRead = 0;
ULONG ulBytesRead = 0;
ULONG ulBytesToWrite = 0;
ULONG ulBytesWritten = 0;
ULONG ulFileBytesWritten = 0;
ULONG ulPercentComplete = 0;
ULONG ulStartProgressFrom = 0;
const LARGE_INTEGER liZeroOffset = {};
WIAEX_TRACE_BEGIN;
if ((!pInputStream) || (!pDestinationStream) || (!pTransferBuffer) || (!pbCancelTransfer))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
else
{
*pbCancelTransfer = FALSE;
}
if ((S_OK == hr) && pTransferCallback && pCallbackTransferParams && pCallbackTransferParams->lPercentComplete)
{
if ((pCallbackTransferParams->lPercentComplete < 0) || (pCallbackTransferParams->lPercentComplete > 49))
{
WIAEX_ERROR((g_hInst, "Invalid WiaTransferParams::lPercentComplete parameter (%d), reset to 0",
pCallbackTransferParams->lPercentComplete));
ulStartProgressFrom = 0;
}
else
{
ulStartProgressFrom = (ULONG)pCallbackTransferParams->lPercentComplete;
WIAS_TRACE((g_hInst, "Resuming progress indicator from %u", ulStartProgressFrom));
}
}
if (S_OK == hr)
{
//
// Make sure the input stream pointer is at the beginning of the stream before reading from it:
//
hr = pInputStream->Seek(liZeroOffset, STREAM_SEEK_SET, NULL);
if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "IStream::Seek(0, STREAM_SEEK_SET, NULL) failed, hr = 0x%08X", hr));
}
}
//
// Resume from current pCallbackTransferParams->lPercentComplete,
// do not reset to 0 pCallbackTransferParams->lPercentComplete:
//
if ((S_OK == hr) && pCallbackTransferParams)
{
pCallbackTransferParams->ulTransferredBytes = 0;
}
while (S_OK == hr)
{
ulBytesRead = 0;
ulBytesToRead = ulBufferSize;
ulBytesWritten = 0;
ulBytesToWrite = 0;
*pbCancelTransfer = FALSE;
//
// Read one buffer of data from the input stream. Note the source IStream
// may return S_OK and no data when the transfer is complete:
//
hr = pInputStream->Read(pTransferBuffer, ulBytesToRead, &ulBytesRead);
if ((S_FALSE == hr) || ((S_OK == hr) && (!ulBytesRead)))
{
//
// End of file, transfer of this file should be complete:
//
hr = WIA_STATUS_END_OF_MEDIA;
WIAS_TRACE((g_hInst, "IStream::Read: end of media, data transfer complete"));
}
else if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IStream::Read failed, hr = 0x%08X", hr));
}
else if (ulBytesRead > ulBytesToRead)
{
hr = E_UNEXPECTED;
WIAEX_ERROR((g_hInst, "IStream::Read caused a possible buffer overflow (%u bytes over %u limit), hr = 0x%08X",
ulBytesRead - ulBytesToRead, ulBytesToRead, hr));
}
//
// Write the the read buffer content to the destination stream:
//
if ((S_OK == hr) || ((WIA_STATUS_END_OF_MEDIA == hr) && (ulBytesRead > 0)))
{
//
// Make sure the write stream pointer is at the end of the stream before writing to it:
//
hrTemp = pDestinationStream->Seek(liZeroOffset, STREAM_SEEK_END, NULL);
if (FAILED(hrTemp))
{
WIAEX_ERROR((g_hInst, "IStream::Seek(0, STREAM_SEEK_END, NULL) failed, hr = 0x%08X", hrTemp));
}
//
// Write the buffer to the destination stream:
//
if (S_OK == hrTemp)
{
ulBytesToWrite = ulBytesRead;
hrTemp = pDestinationStream->Write(pTransferBuffer, ulBytesToWrite, &ulBytesWritten);
if (FAILED(hrTemp))
{
WIAEX_ERROR((g_hInst, "IStream::Write(%u bytes) failed, hr = 0x%08X", ulBytesToWrite, hrTemp));
}
}
//
// Make progress callback to the WIA client application and check for a cancel transfer request:
//
if (S_OK == hrTemp)
{
if (pTransferCallback && pCallbackTransferParams)
{
ulFileBytesWritten += ulBytesWritten;
//
// Indicate to ComputeTransferProgress a direct/full transfer (0% .. 99%):
//
ComputeTransferProgress(&ulPercentComplete, ulEstimatedFileSize, ulFileBytesWritten, TRUE, ulStartProgressFrom);
pCallbackTransferParams->lMessage = WIA_TRANSFER_MSG_STATUS;
pCallbackTransferParams->ulTransferredBytes = ulFileBytesWritten;
pCallbackTransferParams->lPercentComplete = ulPercentComplete;
WIAS_TRACE((g_hInst, "Transfer callback: WIA_TRANSFER_MSG_STATUS, %u bytes, %02.2f KB total (%u)",
ulBytesWritten, pCallbackTransferParams->ulTransferredBytes / 1024.0f, ulPercentComplete));
hrTemp = pTransferCallback->SendMessage(0, pCallbackTransferParams);
if (FAILED(hrTemp))
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage(%u bytes written) failed, hr = 0x%08X",
ulBytesWritten, hrTemp));
}
else if (S_FALSE == hrTemp)
{
*pbCancelTransfer = TRUE;
}
else if (S_OK != hrTemp)
{
WIAEX_ERROR((g_hInst, "IWiaMiniDrvTransferCallback::SendMessage(%u bytes written) returned unknown success value, hr = 0x%08X",
ulBytesWritten, hrTemp));
*pbCancelTransfer = TRUE;
hrTemp = S_FALSE;
}
}
else
{
WIAS_TRACE((g_hInst, "Transferred %u bytes, %02.2f KB total (%u)", ulBytesWritten,
ulFileBytesWritten / 1024.0f, ulPercentComplete));
}
}
//
// Preserve WIA_STATUS_END_OF_MEDIA to allow this loop to normally end, unless a failure was encountered:
//
if ((S_OK != hrTemp) || (WIA_STATUS_END_OF_MEDIA != hr))
{
hr = hrTemp;
}
}
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for IWiaMiniDrv::drvAcquireItemData. Executes a simple validation
* for the WiaImgFmt_BMP (DIB) image uploaded by the application and stored
* in the specified stream.
*
* Parameters:
*
* pStream - stream source for the image to be validated
* lBitDepth - expected pixel bit depth (e.g. 24)
* lWidth - expected image width, in pixels
* lHeight - expected image height, in pixels; also describes
* the DIB line order (if negative the image data is
* top to bottom, positive means bottom to top)
*
* Return Value:
*
* S_OK if successful and the image is valid, E_INVALIDARG if the image is
* invalid or another error HRESULT if another error occurrs and the image
* cannot be validated
*
\**************************************************************************/
HRESULT
CWiaDriver::IsDibValid(
_In_ IStream* pStream,
LONG lBitDepth,
LONG lWidth,
LONG lHeight)
{
HRESULT hr = S_OK;
LARGE_INTEGER lStart = {};
BITMAPINFO bi = {};
WIAEX_TRACE_BEGIN;
if (!pStream)
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
if (SUCCEEDED(hr))
{
lStart.LowPart = sizeof(BITMAPFILEHEADER);
hr = pStream->Seek(lStart, STREAM_SEEK_SET, NULL);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to reset the input stream, hr = 0x%08X", hr));
}
}
if (S_OK == hr)
{
hr = pStream->Read(&bi, sizeof(bi), NULL);
if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "Failed to read the DIB header from the image, hr = 0x%08X", hr));
if (SUCCEEDED(hr))
{
hr = E_INVALIDARG;
}
}
}
if (SUCCEEDED(hr) && (bi.bmiHeader.biBitCount != lBitDepth))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid DIB pixel bit depth, got %u bits, expected %u bit(s), hr = 0x%08X",
bi.bmiHeader.biBitCount, lBitDepth, hr));
}
if (SUCCEEDED(hr) && (bi.bmiHeader.biWidth != lWidth))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid DIB width, got %u pixels, expected %u pixels, hr = 0x%08X",
bi.bmiHeader.biWidth, lWidth, hr));
}
if (SUCCEEDED(hr) && (bi.bmiHeader.biHeight != lHeight))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid DIB height and/or line order, got %l pixels, expected %l pixels, hr = 0x%08X",
bi.bmiHeader.biHeight, lHeight, hr));
}
if (S_OK == hr)
{
lStart.LowPart = 0;
hr = pStream->Seek(lStart, STREAM_SEEK_SET, NULL);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to reset the input stream, hr = 0x%08X", hr));
}
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for IWiaMiniDrv::drvAcquireItemData. Executes a simple validation
* for the WiaImgFmt_TXT and WiaImgFmt_CSV imprinter/endorser text uploaded
* by the application and stored in the specified stream and if the text is
* valid it updates WIA_IPS_PRINTER_ENDORSER_STRING.
*
* Parameters:
*
* pWiasContext - item context
* pStream - stream source for the image to be validated
* nDocumentHandlingSelect - IMPRINTER or ENDORSER (defined in wiadef.h)
*
* Return Value:
*
* S_OK if successful and the image is valid, E_INVALIDARG or another
* error HRESULT if validation fails or if it cannot be performed
*
\**************************************************************************/
HRESULT
CWiaDriver::IsImprinterEndorserTextValid(
_In_ BYTE* pWiasContext,
_In_ IStream* pStream,
LONG nDocumentHandlingSelect)
{
HRESULT hr = S_OK;
LARGE_INTEGER liZero = {};
ULARGE_INTEGER ui = {};
ULONG ulNumChars = 0;
ULONG ulDataSize = 0;
PWCHAR pwData = NULL;
BSTR bstrData = NULL;
WIAEX_TRACE_BEGIN;
if (!pStream)
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
if (SUCCEEDED(hr))
{
hr = IStream_Size(pStream, &ui);
if (SUCCEEDED(hr))
{
WIAS_TRACE((g_hInst, "Stream size, low: %u bytes, high: %u bytes",
ui.LowPart, ui.HighPart));
if (ui.HighPart > 0)
{
WIAS_TRACE((g_hInst, "Stream size exceeeds maximum accepted by this item, last %u bytes will be ignored", ui.HighPart));
}
//
// Data must contain the two bytes BOM and at least one double-byte character:
//
if (ui.LowPart >= (2 * sizeof(WCHAR)))
{
ulDataSize = ui.LowPart;
}
else
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Insufficient data (less than one actual character), hr = 0x%08X", hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "IStream_Size failed, hr = 0x%08X", hr));
}
}
if (SUCCEEDED(hr))
{
hr = pStream->Seek(liZero, STREAM_SEEK_SET, NULL);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to reset memory stream, hr = 0x%08X", hr));
}
}
//
// Read first the BOM bytes and validate:
//
if (S_OK == hr)
{
BYTE bBOM[2] = {};
hr = pStream->Read(bBOM, 2, NULL);
if (S_OK == hr)
{
if ((0xFF != bBOM[0]) || (0xFE != bBOM[1]))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid BOM. Expected 0xFF 0xFE, received 0x%X 0x%X, hr = 0x%08X", bBOM[0], bBOM[1], hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed to read the BOM from the stream, hr = 0x%08X", hr));
if (SUCCEEDED(hr))
{
hr = E_INVALIDARG;
}
}
}
//
// Alocate memory for the NULL terminated WCHAR string. The NULL string terminator is not
// expected in the stream, however the stream must contain the BOM "character" instead,
// thus we need to allocate space for the same number of whole double byte characters
// that are in the stream:
//
if (SUCCEEDED(hr))
{
ulNumChars = ulDataSize / sizeof(WCHAR);
pwData = new WCHAR[ulNumChars];
if (pwData)
{
//
// NULL terminate the string:
//
pwData[ulNumChars - 1] = 0;
}
else
{
hr = E_OUTOFMEMORY;
WIAEX_ERROR((g_hInst, "Out of memory when trying to allocate %u bytes, hr = 0x%08X", ulDataSize, hr));
}
}
//
// Read the actual imprinter/endorser characters:
//
if (S_OK == hr)
{
//
// ulNumChars includes the length of the NULL terminator:
//
ulNumChars -= 1;
hr = pStream->Read((PBYTE)pwData, ulNumChars * sizeof(WCHAR), NULL);
if (S_OK != hr)
{
WIAEX_ERROR((g_hInst, "Failed to read from the stream, hr = 0x%08X", hr));
if (SUCCEEDED(hr))
{
hr = E_INVALIDARG;
}
}
}
//
// Validate each character against the set of valid characters for the source:
//
if (SUCCEEDED(hr))
{
PWCHAR szValidChars = (IMPRINTER == nDocumentHandlingSelect) ? SAMPLE_IMPRINTER_VALID_CHARS : SAMPLE_ENDORSER_VALID_CHARS;
ULONG ulValidChars = ((IMPRINTER == nDocumentHandlingSelect) ? ARRAYSIZE(SAMPLE_IMPRINTER_VALID_CHARS) : ARRAYSIZE(SAMPLE_ENDORSER_VALID_CHARS)) - 1;
BOOL bFound = FALSE;
for (ULONG i = 0; i < ulNumChars; i++)
{
bFound = FALSE;
for (ULONG j = 0; j < ulValidChars; j++)
{
if (pwData[i] == szValidChars[j])
{
bFound = TRUE;
i++;
break;
}
}
if (!bFound)
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid character for WIA_IPS_PRINTER_ENDORSER_STRING: 0x%X (%wc), hr = 0x%08X", pwData[i], pwData[i], hr));
break;
}
}
}
if (SUCCEEDED(hr))
{
bstrData = SysAllocString(pwData);
if (!bstrData)
{
hr = E_OUTOFMEMORY;
WIAEX_ERROR((g_hInst, "Out of memory when trying to allocate a BSTR of %u characters in length, hr = 0x%08X", ulNumChars, hr));
}
}
if (SUCCEEDED(hr))
{
hr = wiasWritePropStr(pWiasContext, WIA_IPS_PRINTER_ENDORSER_STRING, bstrData);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "Failed to set WIA_IPS_PRINTER_ENDORSER_STRING, hr = 0x%08X", hr));
}
}
if (bstrData)
{
SysFreeString(bstrData);
}
if (pwData)
{
delete[] pwData;
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for IWiaMiniDrv::drvAcquireItemData. Loads a test data file (image
* or metadata) from resources. A test image is expected to be in EXIF format
* and match the dimensions described by the MIN/MAX_TEST_SCAN_WIDTH/HEIGHT.
* The function does not attempt to validate the contents of data loaded from
* resources, it only copies the whole data file to the specified stream.
*
* Parameters:
*
* ulResourceId - resource identifier
* pStream - stream destination for the test image
* pulDataSize - returns the size in bytes of the data loaded from
* resources and written to the destination stream
*
* Return Value:
*
* S_OK if successful or an error HRESULT if an error occurrs
*
\**************************************************************************/
HRESULT
CWiaDriver::LoadTestDataResourceToStream(
ULONG ulResourceId,
_In_ IStream *pStream,
_Out_ ULONG *pulDataSize)
{
HRESULT hr = S_OK;
WIAEX_TRACE_BEGIN;
if ((!pStream) && (!pulDataSize))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
if (SUCCEEDED(hr))
{
*pulDataSize = 0;
HRSRC hResourceInfo = FindResource(g_hInst, MAKEINTRESOURCE(ulResourceId), MAKEINTRESOURCE(RT_RCDATA));
if (hResourceInfo)
{
ULONG ulWrittenData = 0;
ULONG ulDataSize = (ULONG)SizeofResource(g_hInst, hResourceInfo);
if (ulDataSize > 0)
{
HGLOBAL hTestData = LoadResource(g_hInst, hResourceInfo);
if (hTestData)
{
PBYTE pTestData = (PBYTE)LockResource(hTestData);
if (pTestData)
{
LARGE_INTEGER lZero = {};
hr = pStream->Seek(lZero, STREAM_SEEK_SET, NULL);
if (S_OK == hr)
{
hr = pStream->Write(pTestData, ulDataSize, &ulWrittenData);
if (S_OK == hr)
{
if (ulWrittenData != ulDataSize)
{
hr = E_FAIL;
WIAEX_ERROR((g_hInst, "Failed to load data (%u) from resources, expected %u bytes, got %u bytes, hr = 0x%08X",
ulResourceId, ulDataSize, ulWrittenData, hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed to load data (%u) from resources, hr = 0x%08X", ulResourceId, hr));
}
HRESULT hrTemp = pStream->Seek(lZero, STREAM_SEEK_SET, NULL);
if (S_OK != hrTemp)
{
if (S_OK == hr)
{
hr = hrTemp;
}
WIAEX_ERROR((g_hInst, "Failed to reset memory stream, hr = 0x%08X", hrTemp));
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed to reset memory stream, hr = 0x%08X", hr));
}
}
DeleteObject(hTestData);
}
if (S_OK == hr)
{
*pulDataSize = ulDataSize;
}
}
else
{
hr = HRESULT_FROM_WIN32(::GetLastError());
WIAEX_ERROR((g_hInst, "Bad resource (%u), hr = 0x%08X", ulResourceId, hr));
}
}
else
{
hr = HRESULT_FROM_WIN32(::GetLastError());
WIAEX_ERROR((g_hInst, "Cannot find resource (%u), hr = 0x%08X", ulResourceId, hr));
}
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for IWiaMiniDrv::drvAcquireItemData. Writes generated or hard-coded
* sample metadata to the specified download stream. This data is to be
* transferred from this sample driver to the WIA application client as an
* imprinter/endorser text/CSV file, or raw barcode/patch code/MICR metadata.
*
* Parameters:
*
* pWiasContext - item context
* guidItemCategory - item category (WIA_CATEGORY_ value)
* guidFormat - trasfer file format (WiaImgFmt_ value)
* pStream - stream destination for the test image
* pulDataSize - returns the size in bytes of the data loaded from
* resources and written to the destination stream
*
* Return Value:
*
* S_OK if successful or an error HRESULT if an error occurrs
*
\**************************************************************************/
HRESULT
CWiaDriver::LoadTestDataToStream(
_In_ BYTE *pWiasContext,
GUID guidItemCategory,
GUID guidFormat,
_In_ IStream *pStream,
_Out_ ULONG *pulDataSize)
{
HRESULT hr = S_OK;
ULONG ulDataSize = 0;
WIAEX_TRACE_BEGIN;
if ((!pWiasContext) || (!pStream) && (!pulDataSize))
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
if (SUCCEEDED(hr))
{
if ((IsEqualGUID(WIA_CATEGORY_IMPRINTER, guidItemCategory) || IsEqualGUID(WIA_CATEGORY_ENDORSER, guidItemCategory)) &&
(!IsEqualGUID(WiaImgFmt_BMP, guidFormat)))
{
if (IsEqualGUID(WiaImgFmt_TXT, guidFormat) || IsEqualGUID(WiaImgFmt_CSV, guidFormat))
{
BSTR bstrData = NULL;
//
// Read the current WIA_IPS_PRINTER_ENDORSER_STRING character string value
// and prepare to write it to the destination stream, for simplicity without
// expanding any special formatting sequences. Note the NULL string terminator
// is not to be written to the stream (which for this sample it will end up
// as a TXT or CSV file):
//
hr = wiasReadPropStr(pWiasContext, WIA_IPS_PRINTER_ENDORSER_STRING, &bstrData, NULL, TRUE);
if (SUCCEEDED(hr))
{
hr = pStream->Write(g_bBOM, sizeof(g_bBOM), NULL);
if (SUCCEEDED(hr))
{
ulDataSize = (ULONG)(wcslen((PWCHAR)bstrData) * sizeof(WCHAR));
hr = pStream->Write((PBYTE)bstrData, ulDataSize, NULL);
if (FAILED(hr))
{
WIAEX_ERROR((g_hInst, "IStream::Write(data) failed, hr = 0x%08X", hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "IStream::Write(prefix) failed, hr = 0x%08X", hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed to read the current WIA_IPS_PRINTER_ENDORSER_STRING value, hr = 0x%08X", hr));
}
if (bstrData)
{
SysFreeString(bstrData);
}
}
else
{
hr = E_INVALIDARG;
}
}
else if (IsEqualGUID(WIA_CATEGORY_BARCODE_READER, guidItemCategory) && IsEqualGUID(WiaImgFmt_RAWBAR, guidFormat))
{
WIA_BARCODES bc = {};
WIA_BARCODE_INFO bi = {};
//
// 3 hard-coded sample barcodes to report. These sample barcodes match the XML sample metadata (Barcodes.xml):
//
WCHAR szBarcodeOne[] = L"036000291452";
WCHAR szBarcodeTwo[] = L"3117013206375";
WCHAR szBarcodeThree[] = L"This is a Full ASCII Code 39 example";
//
// When computing the data size take into account the following important details:
//
// WIA_BARCODES includes a WIA_BARCODE_INFO structure element as a placeholder.
// WIA_BARCODE_INFO includes a WCHAR pleceholder for the text.
// Make sure the size of these fields are not counted twice.
//
// Do not include the length of the NULL string terminators for the character sequences,
// they and not NULL terminated.
//
// Do not compute the fixed size (excluding the text) of a WIA_BARCODE_INFO structure
// doing sizeof(WIA_BARCODE_INFO) - sizeof(WCHAR), this will incorrectly add compiler
// padding for the data structure (2 additional bytes by default). Instead compute
// the length of the fixed WIA_BARCODE_INFO size as 8 * sizeof(DWORD).
//
ULONG ulFixedSize = 4 * sizeof(DWORD); //not: sizeof(WIA_BARCODES - sizeof(WIA_BARCODES_INFO)
ULONG ulFixedInfoSize = 8 * sizeof(DWORD); //not: sizeof(WIA_BARCODES_INFO) - sizeof(WCHAR)
ulDataSize = ulFixedSize + (3 * ulFixedInfoSize) + sizeof(szBarcodeOne) + sizeof(szBarcodeTwo) + sizeof(szBarcodeThree) - (3 * sizeof(WCHAR));
const char szSignature[] = "WBAR";
memcpy(&bc.Tag, szSignature, sizeof(DWORD));
bc.Version = 0x00010000;
bc.Size = ulDataSize;
bc.Count = 3;
hr = pStream->Write(&bc, ulFixedSize, NULL);
if (SUCCEEDED(hr))
{
bi.Size = ulFixedInfoSize + sizeof(szBarcodeOne) - sizeof(WCHAR);
bi.Type = 0;
bi.Page = 0;
bi.Confidence = 5;
bi.XOffset = 0;
bi.YOffset = 0;
bi.Rotation = 90;
bi.Length = (DWORD)wcslen(szBarcodeOne);
hr = pStream->Write(&bi, ulFixedInfoSize, NULL);
if (SUCCEEDED(hr))
{
hr = pStream->Write(szBarcodeOne, sizeof(szBarcodeOne) - sizeof(WCHAR), NULL);
}
}
if (SUCCEEDED(hr))
{
bi.Size = ulFixedInfoSize + sizeof(szBarcodeTwo) - sizeof(WCHAR);
bi.Type = 2;
bi.Page = 0;
bi.Confidence = 9;
bi.XOffset = 2;
bi.YOffset = 1000;
bi.Rotation = 0;
bi.Length = (DWORD)wcslen(szBarcodeTwo);
hr = pStream->Write(&bi, ulFixedInfoSize, NULL);
if (SUCCEEDED(hr))
{
hr = pStream->Write(szBarcodeTwo, sizeof(szBarcodeTwo) - sizeof(WCHAR), NULL);
}
}
if (SUCCEEDED(hr))
{
bi.Size = ulFixedInfoSize + sizeof(szBarcodeThree) - sizeof(WCHAR);
bi.Type = 7;
bi.Page = 0;
bi.Confidence = 10;
bi.XOffset = 0;
bi.YOffset = 2000;
bi.Rotation = 0;
bi.Length = (DWORD)wcslen(szBarcodeThree);
hr = pStream->Write(&bi, ulFixedInfoSize, NULL);
if (SUCCEEDED(hr))
{
hr = pStream->Write(szBarcodeThree, sizeof(szBarcodeThree) - sizeof(WCHAR), NULL);
}
}
}
else if (IsEqualGUID(WIA_CATEGORY_PATCH_CODE_READER, guidItemCategory) && IsEqualGUID(WiaImgFmt_RAWPAT, guidFormat))
{
WIA_PATCH_CODES pc = {};
WIA_PATCH_CODE_INFO pi = {};
//
// 2 hard-coded sample patch codes to report. These sample codes match the XML sample metadata (PatchCod.xml):
//
ULONG ulFixedSize = 4 * sizeof(DWORD);
ULONG ulFixedInfoSize = sizeof(DWORD);
ulDataSize = ulFixedSize + (2 * ulFixedInfoSize);
const char szSignature[] = "WPAT";
memcpy(&pc.Tag, szSignature, sizeof(DWORD));
pc.Version = 0x00010000;
pc.Size = ulDataSize;
pc.Count = 2;
hr = pStream->Write(&pc, ulFixedSize, NULL);
if (SUCCEEDED(hr))
{
pi.Type = 2;
hr = pStream->Write(&pi, ulFixedInfoSize, NULL);
}
if (SUCCEEDED(hr))
{
pi.Type = 1;
hr = pStream->Write(&pi, ulFixedInfoSize, NULL);
}
}
else if (IsEqualGUID(WIA_CATEGORY_MICR_READER, guidItemCategory) && IsEqualGUID(WiaImgFmt_RAWMIC, guidFormat))
{
WIA_MICR micr = {};
WIA_MICR_INFO mi = {};
//
// 2 hard-coded sample MICR codes to report. These sample codes match the XML sample metadata (Micr.xml):
//
WCHAR szMicrOne[] = L"1234567890";
WCHAR szMicrTwo[] = L"987?543?10";
//
// When computing the data size take into account the following important details:
//
// WIA_MICR includes a WIA_MICR_INFO structure element as a placeholder.
// WIA_MICR_INFO includes a WCHAR pleceholder for the text.
// Make sure the size of these fields are not counted twice.
//
// Do not include the length of the NULL string terminators for the character sequences,
// they and not NULL terminated.
//
// Do not compute the fixed size (excluding the text) of a WIA_MICR_INFO structure
// doing sizeof(WIA_MICR_INFO) - sizeof(WCHAR), this may add compiler padding for
// the data structure. Instead compute the length of the fixed WIA_MICR_INFO size
// as 3 * sizeof(DWORD).
//
ULONG ulFixedSize = 5 * sizeof(DWORD); //not: sizeof(WIA_MICR - sizeof(WIA_MICR_INFO)
ULONG ulFixedInfoSize = 3 * sizeof(DWORD); //not: sizeof(WIA_MICR_INFO) - sizeof(WCHAR)
ulDataSize = ulFixedSize + (2 * ulFixedInfoSize) + sizeof(szMicrOne) + sizeof(szMicrTwo) - (2 * sizeof(WCHAR));
const char szSignature[] = "WMIC";
memcpy(&micr.Tag, szSignature, sizeof(DWORD));
micr.Version = 0x00010000;
micr.Size = ulDataSize;
micr.Count = 2;
micr.Placeholder = L'?';
hr = pStream->Write(&micr, ulFixedSize, NULL);
if (SUCCEEDED(hr))
{
mi.Size = ulFixedInfoSize + sizeof(szMicrOne) - sizeof(WCHAR);
mi.Page = 0;
mi.Length = (DWORD)wcslen(szMicrOne);
hr = pStream->Write(&mi, ulFixedInfoSize, NULL);
if (SUCCEEDED(hr))
{
hr = pStream->Write(szMicrOne, sizeof(szMicrOne) - sizeof(WCHAR), NULL);
}
}
if (SUCCEEDED(hr))
{
mi.Size = ulFixedInfoSize + sizeof(szMicrTwo) - sizeof(WCHAR);
mi.Page = 1;
mi.Length = (DWORD)wcslen(szMicrTwo);
hr = pStream->Write(&mi, ulFixedInfoSize, NULL);
if (SUCCEEDED(hr))
{
hr = pStream->Write(szMicrTwo, sizeof(szMicrTwo) - sizeof(WCHAR), NULL);
}
}
}
else
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid item - transfer format combination, hr = 0x%08X", hr));
}
}
if (SUCCEEDED(hr))
{
*pulDataSize = ulDataSize;
}
WIAEX_TRACE_FUNC_HR;
return hr;
}
/**************************************************************************\
*
* Helper for TransferFile. Computes the transfer completion relative to the
* specified size of data written and the estimated target file size.
*
* Parameters:
*
* pulPercentComplete - percent complete value to be updated
* ulEstimatedFileSize - estimated file size, in bytes (0 if unknown)
* ulFileBytesWritten - number of bytes of data written
* bDirectWiaTransfer - TRUE if this is a full WIA transfer when the
* percent complete must be incremented from 0%
* to 99%, FALSE if this is a transfer of a file
* already read from the scanner when the percent
* complete is set from ulResumeFrom to 99% -or-
* if this is a transfer from scanner to the driver
* when the percent complete is set from 0% to 49%.
* ulResumeFrom - if bDirectWiaTransfer is FALSE this parameter
* indicates a start value between 0% and 49% for
* a transfer from the driver to the WIA app -or-
* 0 to indicate a transfer from the scanner to driver
* Return Value:
*
* None
*
\**************************************************************************/
void
CWiaDriver::ComputeTransferProgress(
_Inout_ ULONG *pulPercentComplete,
ULONG ulEstimatedFileSize,
ULONG ulFileBytesWritten,
BOOL bDirectWIATransfer,
ULONG ulResumeFrom)
{
ULONG ulStartPos = 0;
double dMax = 100.0;
ULONG ulLimit = 99;
if (!bDirectWIATransfer)
{
if (!ulResumeFrom)
{
//
// If this is an indirect (translated) transfer and the indicated
// start position is 0 we will compute the transfer complete on a
// 0% to 50% scale up to a maximum value of 49%:
//
ulStartPos = 0;
dMax = 50.0;
ulLimit = 49;
}
else
{
//
// If a non-zero value is indicated to start the progress indicator
// from we will resume incrementing the transfer complete from here:
//
if (ulResumeFrom < 50)
{
ulStartPos = ulResumeFrom + 1;
}
else
{
ulStartPos = 50;
}
dMax = 100.0 - (double)ulStartPos;
ulLimit = 99 - ulStartPos;
}
}
if (pulPercentComplete)
{
//
// Note that we do not know in advance the exact size of the file to be transferred.
// In order to allow the WIA client application to see activity (other than the
// amount of data that is being transferred with each write) we will use the estimated
// uncompressed data size (if available) or simply increment the percent complete until
// 99 or end of file transfer (and then set it to 100%):
//
if (ulEstimatedFileSize > 0)
{
*pulPercentComplete = (ULONG)(dMax * (((double)ulFileBytesWritten) / ((double)ulEstimatedFileSize)));
if ((*pulPercentComplete) > ulLimit)
{
*pulPercentComplete = ulLimit;
}
}
else
{
if ((*pulPercentComplete) < ulLimit)
{
*pulPercentComplete += 1;
}
}
if (!bDirectWIATransfer)
{
*pulPercentComplete += ulStartPos;
}
}
}
Our Services
-
What our customers say about us?
Read our customer testimonials to find out why our clients keep returning for their projects.
View Testimonials
