Updated for "Windows 10 Anniversary Update" (Version 1607)

1 files changed, 2531 insertions, 0 deletions

diff --git a/wia/ProdScan/ScanJobs.cpp b/wia/ProdScan/ScanJobs.cpp
new file mode 100644
index 00000000..ad5b51ea
--- /dev/null
+++ b/wia/ProdScan/ScanJobs.cpp
@@ -0,0 +1,2531 @@
+/**************************************************************************
+*
+*  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), 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;
+        }
+    }
+}