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

1 files changed, 821 insertions, 0 deletions

diff --git a/wia/ProdScan/StiUSD.cpp b/wia/ProdScan/StiUSD.cpp
new file mode 100644
index 00000000..7fd61b8a
--- /dev/null
+++ b/wia/ProdScan/StiUSD.cpp
@@ -0,0 +1,821 @@
+/**************************************************************************
+*
+*  Copyright � Microsoft Corporation
+*
+*  File Name:   StiUSD.cpp
+*
+*  Description: Contains the IStiUSD interface implementation for
+*               the Production Scanner Driver Sample
+*
+*
+***************************************************************************/
+
+#include "stdafx.h"
+
+
+/**************************************************************************\
+*
+* Helper for IStiUSD::Initialize implementation. Placeholder where the driver
+* would initialize its communication interface with the scanner device (register
+* itself to receive event notifications from the device, read the scanner device
+* configuration). Also initializes the the available transfer formats and the
+* capabilities needed for the sample driver.
+*
+* Parameters:
+*
+*    wszDevicePath - device path name
+*    hDeviceKey    - device key in Registry
+*
+* Return Value:
+*
+*    S_OK if it suceeds, a standard COM error code if initialization fails
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::InitializeDeviceConnection(
+    _In_ LPCWSTR wszDevicePath,
+    _In_ HKEY    hDeviceKey)
+{
+    HRESULT hr = S_OK;
+
+    WIAEX_TRACE_BEGIN;
+
+    //
+    // Validate parameters:
+    //
+    if ((!wszDevicePath) || (!hDeviceKey))
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
+    }
+
+    //
+    // Initialize here the connection with the scanner device identified by wszDevicePath.
+    //
+    // For example:
+    //
+    // if (SUCCEEDED(hr))
+    // {
+    //     hr = m_ScannerDevice.Initialize(wszDevicePath);
+    //     if (FAILED(hr))
+    //     {
+    //         WIAEX_ERROR((g_hInst, "Failed to initialize connection with scanner device described by %ws, hr = 0x%08X", wszDevicePath, hr));
+    //     }
+    // }
+    //
+
+    //
+    // Initialize the valid format information arrays, matching the current scanner configuration if available:
+    //
+    if (SUCCEEDED(hr))
+    {
+        hr = InitializeFormatInfoArrays();
+        if(FAILED(hr))
+        {
+            WIAEX_ERROR((g_hInst, "Failed to initialize WIA_FORMAT_INFO arrays, hr = 0x%08X", hr));
+        }
+    }
+
+    //
+    // Initialize the page size array used by this driver (only one list, for portrait orientation).
+    //
+    // This sample driver supports Letter, and also pretends (without actually doing it) custom
+    // and auto-detect document sizes:
+    //
+    if (SUCCEEDED(hr))
+    {
+        //
+        // WIA_PAGE_CUSTOM is always supported:
+        //
+        m_lPortraitSizesArray.Append(WIA_PAGE_CUSTOM);
+
+        //
+        // WIA_PAGE_AUTO is also supported if the scanner reports that it supports automatic document size detection:
+        //
+        m_lPortraitSizesArray.Append(WIA_PAGE_AUTO);
+
+        //
+        // Other standard page sizes:
+        //
+        GetValidPageSizes(MAX_SCAN_AREA_WIDTH, MAX_SCAN_AREA_HEIGHT, MIN_SCAN_AREA_WIDTH, MIN_SCAN_AREA_HEIGHT, TRUE, m_lPortraitSizesArray);
+    }
+
+    //
+    // Create the capability manager which will be initialized (uniquely per
+    // driver session) during the first IWiaMiniDrv::drvGetCapabilities call:
+    //
+    if (SUCCEEDED(hr))
+    {
+        hr = m_tCapabilityManager.Initialize(g_hInst);
+        if (FAILED(hr))
+        {
+            WIAEX_ERROR((g_hInst, "Failed to initialize the WIA driver capability manager object, hr = 0x%08X", hr));
+        }
+    }
+
+    WIAEX_TRACE_FUNC_HR;
+
+    return hr;
+}
+
+
+/**************************************************************************\
+*
+* Implements IStiUSD::Initialize. Initializes an instance of the COM object
+* that defines the IStiUSD interface. When this method is called the driver
+* receives a pointer to an IStiDeviceControl COM interface.
+*
+* Parameters:
+*
+*    pIStiDevControl - caller-supplied pointer to the IStiDeviceControl interface
+*    dwStiVersion    - caller-supplied STI version number
+*                      (value defined as STI_VERSION_x in sti.h)
+*    hParametersKey  - caller-supplied handle to the registry key under
+*                      which device-specific information is to be stored.
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes  defined in stierr.h
+*    or another standard COM error code.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::Initialize(
+    _In_ PSTIDEVICECONTROL pIStiDevControl,
+    DWORD                  dwStiVersion,
+    _In_ HKEY              hParametersKey)
+{
+    UNREFERENCED_PARAMETER(dwStiVersion);
+
+    HRESULT hr = S_OK;
+    DWORD cchDevicePath = sizeof(m_wszDevicePath) / sizeof(WCHAR);
+
+    WIAEX_TRACE_BEGIN;
+
+    //
+    // Validate parameters:
+    //
+    if ((!pIStiDevControl) || (!hParametersKey))
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
+    }
+
+    //
+    // Get the device path name from PnP:
+    //
+    if (SUCCEEDED(hr))
+    {
+        memset(m_wszDevicePath, 0, sizeof(m_wszDevicePath));
+
+        hr = pIStiDevControl->GetMyDevicePortName(m_wszDevicePath, cchDevicePath);
+
+        if(FAILED(hr))
+        {
+            WIAEX_ERROR((g_hInst, "IStiDeviceControl::GetMyDevicePortName failed, hr = 0x%08X", hr));
+        }
+    }
+
+    //
+    // Initialize the connection with the scanner:
+    //
+    if (SUCCEEDED(hr))
+    {
+        m_hDeviceKey = hParametersKey;
+
+        hr = InitializeDeviceConnection(m_wszDevicePath, m_hDeviceKey);
+        if (FAILED(hr))
+        {
+            WIAEX_ERROR((g_hInst, "InitializeDeviceConnection for DevicePath %ws failed, hr = 0x%08X", m_wszDevicePath, hr));
+        }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        m_hrLastEdviceError = STI_ERROR_NO_ERROR;
+        m_bInitialized = TRUE;
+    }
+    else
+    {
+        m_hrLastEdviceError = hr;
+        m_bInitialized = FALSE;
+    }
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::Initialize 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::GetCapabilities. Returns the still image
+* device's capabilities.
+*
+* Parameters:
+*
+*    pDevCaps - caller-supplied pointer to an empty STI_USD_CAPS structure
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::GetCapabilities(
+    _Out_ PSTI_USD_CAPS pDevCaps)
+{
+    HRESULT hr = S_OK;
+
+    WIAEX_TRACE_BEGIN;
+
+    if (!pDevCaps)
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X",hr));
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        //
+        // The sample driver supports device notifications (required), known also as interrupt events.
+        // Polling (optional) it is not needed so STI_GENCAP_POLLING_NEEDED is not reported here:
+        //
+
+        memset(pDevCaps, 0, sizeof(STI_USD_CAPS));
+
+        pDevCaps->dwVersion = STI_VERSION_3;
+        pDevCaps->dwGenericCaps = STI_GENCAP_WIA | STI_USD_GENCAP_NATIVE_PUSHSUPPORT | STI_GENCAP_NOTIFICATIONS;
+
+        WIAS_TRACE((g_hInst, "Device capabilities: 0x%08X", pDevCaps->dwGenericCaps));
+    }
+
+    if (FAILED(hr))
+    {
+        m_hrLastEdviceError = hr;
+    }
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::GetCapabilities 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::GetStatus. Returns the status for the still image device.
+* GetStatus is called by the WIA service for two major operations:
+*
+*   1. Checking device ON-LINE status.
+*   2. Polling for device events (like a push button event)
+*
+* Parameters:
+*
+*    pDevStatus - caller-supplied pointer to an STI_DEVICE_STATUS structure
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::GetStatus(
+    _Inout_ PSTI_DEVICE_STATUS pDevStatus)
+{
+    HRESULT hr = S_OK;
+
+    if (!pDevStatus)
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X",hr));
+    }
+
+    //
+    // A driver may be requested to report one or both of the following:
+    //
+    // STI_DEVSTATUS_EVENTS_STATE - The driver should fill in the dwEventHandlingState member
+    // STI_DEVSTATUS_ONLINE_STATE - The driver should fill in the dwOnlineState member
+    //
+    // In this case STI_DEVSTATUS_EVENTS_STATE is not expected nor supported as this driver
+    // does not support polling events (if the driver previously set the STI_GENCAP_POLLING_NEEDED
+    // flag in the device's STI_DEV_CAPS structure, the IStiUSD::GetStatus method is the means
+    // by which the Event Monitor determines if a still image device event has occurred;
+    // the Event Monitor will call the method, specifying STI_DEVSTATUS_EVENT_STATE
+    // in the supplied STI_DEVICE_STATUS structure; the driver must poll the device
+    // and set STI_EVENTHANDLING_PENDING if an event has occurred)
+    //
+    // If the caller specifies STI_DEVSTATUS_ONLINE_STATE in the supplied
+    // STI_DEVICE_STATUS structure, the driver should set the appropriate flag
+    // in the STI_DEVICE_STATUS structure's dwOnlineState member.
+    //
+
+    if (SUCCEEDED(hr))
+    {
+        pDevStatus->dwOnlineState = 0;
+        pDevStatus->dwHardwareStatusCode = 0;
+        pDevStatus->dwEventHandlingState = 0;
+
+        //
+        // STI_DEVSTATUS_ONLINE_STATE:
+        //
+        if (pDevStatus->StatusMask & STI_DEVSTATUS_ONLINE_STATE)
+        {
+            //
+            // This sample driver is always online and ready:
+            //
+            pDevStatus->dwOnlineState = STI_ONLINESTATE_OPERATIONAL;
+        }
+
+        //
+        // STI_DEVSTATUS_EVENTS_STATE:
+        //
+        else if (pDevStatus->StatusMask & STI_DEVSTATUS_EVENTS_STATE)
+        {
+            //
+            // Polled events are not supported so we don't have to return anyting here:
+            //
+            pDevStatus->dwEventHandlingState &= ~STI_EVENTHANDLING_PENDING;
+        }
+    }
+
+    if (FAILED(hr))
+    {
+        m_hrLastEdviceError = hr;
+    }
+
+    WIAS_TRACE((g_hInst, "IStiUSD::GetStatus 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::DeviceReset. Resets the still image device to a known,
+* initialized state. The sample driver will return S_OK without to execute
+* any reset operation. The success-do-nothing approach is needed to ensure
+* compatibility with the requirements for the IStiUSD interface implementation.
+*
+* Parameters:
+*
+*    None
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. The sample driver always returns S_OK.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::DeviceReset()
+{
+    WIAS_TRACE((g_hInst, "IStiUSD::DeviceReset 0x%08X", S_OK));
+    return S_OK;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::Diagnostic. If the driver is initialized when Diagnostic
+* is called the driver should attempt to communicate with the device and
+* determine if the device is online and operational. This sample driver
+* does not do any special device validation.
+*
+* Parameters:
+*
+*    pBuffer - caller-supplied pointer to an STI_DIAG structure to receive
+*              testing status information
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::Diagnostic(
+    _Inout_ LPDIAG pBuffer)
+{
+    HRESULT hr = S_OK;
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::Diagnostic.."));
+
+    if ((!pBuffer) || (pBuffer->dwSize < sizeof(STI_DIAG)) || (pBuffer->sErrorInfo.dwSize < sizeof(STI_ERROR_INFO)))
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter (buffer: %p, size: %u bytes (needed: %u), error: %u bytes (needed: %u)), hr = 0x%08X",
+            pBuffer, pBuffer ? pBuffer->dwSize : 0, sizeof(STI_DIAG),
+            pBuffer ? pBuffer->sErrorInfo.dwSize : 0, sizeof(STI_ERROR_INFO), hr));
+        m_hrLastEdviceError = STIERR_INVALID_PARAM;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        pBuffer->dwVendorDiagCode = 0;
+        pBuffer->dwStatusMask = 0;
+        pBuffer->sErrorInfo.dwGenericError = NOERROR;
+        pBuffer->sErrorInfo.dwVendorError = 0;
+        memset(pBuffer->sErrorInfo.szExtendedErrorText, 0, sizeof(pBuffer->sErrorInfo.szExtendedErrorText));
+
+        if (STI_DIAGCODE_HWPRESENCE == pBuffer->dwBasicDiagCode)
+        {
+            WIAEX_TRACE((g_hInst, "STI_DIAGCODE_HWPRESENCE.."));
+        }
+        else
+        {
+            WIAEX_ERROR((g_hInst, "Unknown basic diag code requested (and ignored): %u", pBuffer->dwBasicDiagCode));
+        }
+    }
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::Diagnostic 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::Escape. This method allows an application to send
+* directly to the device a proprietary command ID and optionally send
+* and receive data.
+*
+* The sample driver returns STIERR_UNSUPPORTED.
+*
+* Parameters:
+*
+*    EscapeFunction - caller-supplied, vendor-defined, DWORD-sized value
+*                     representing an I/O operation
+*    lpInData       - caller-supplied pointer to a buffer containing data
+*                     sent to the device
+*    cbInDataSize   - caller-supplied length, in bytes, of the buffer
+*                     pointed to by lpInData
+*    pOutData       - caller-supplied pointer to a memory buffer to
+*                     receive data from the device
+*    cbOutDataSize  - caller-supplied length, in bytes, of the buffer
+*                     pointed to by lpOutData
+*    pdwActualData  - receives the number of bytes actually written to pOutData
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This driver returns STIERR_UNSUPPORTED.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::Escape(
+    STI_RAW_CONTROL_CODE               EscapeFunction,
+    _In_reads_bytes_(cbInDataSize)
+    LPVOID                             lpInData,
+    DWORD                              cbInDataSize,
+    _Out_writes_bytes_(cbOutDataSize)
+    LPVOID                             pOutData,
+    DWORD                              cbOutDataSize,
+    _Out_ LPDWORD                      pdwActualData)
+{
+    UNREFERENCED_PARAMETER(EscapeFunction);
+    UNREFERENCED_PARAMETER(cbInDataSize);
+    UNREFERENCED_PARAMETER(lpInData);
+    UNREFERENCED_PARAMETER(cbOutDataSize);
+    UNREFERENCED_PARAMETER(pOutData);
+
+    WIAEX_ERROR((g_hInst, "This method is not implemented or supported for this driver"));
+
+    HRESULT hr = STIERR_UNSUPPORTED;
+
+    if (pdwActualData)
+    {
+        *pdwActualData = 0;
+    }
+
+    m_hrLastEdviceError = hr;
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::Escape 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::LockDevice. The sample driver returns S_OK. This is
+* a must considering that the driver cannot function otherwise (the WIA Service
+* expects this method to succeed for a properly installed driver and a working
+* scanner device).
+*
+* Parameters:
+*
+*    None
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This sample driver returns S_OK.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::LockDevice()
+{
+    return S_OK;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::UnLockDevice. The sample driver returns S_OK. This is
+* a must considering that the driver cannot function otherwise (the WIA Service
+* expects this method to succeed for a properly installed driver and a
+* working scanner device).
+*
+* Parameters:
+*
+*    None
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This sample driver returns S_OK.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::UnLockDevice()
+{
+    return S_OK;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::RawReadData. Reads data from the still image device.
+*
+* Parameters:
+*
+*    lpBuffer          - caller-supplied pointer to a buffer to receive data
+*                        read from the device.
+*    lpdwNumberOfBytes - caller-supplied pointer to a DWORD. The caller loads
+*                        the DWORD with the number of bytes in the buffer pointed
+*                        to by lpBuffer. The driver must replace this value with
+*                        the number of bytes actually read.
+*    lpOverlapped      - optional, caller-supplied pointer to an OVERLAPPED structure
+*                        (described in the Microsoft Windows SDK documentation).
+*
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This driver returns STIERR_UNSUPPORTED.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::RawReadData(
+    _Out_writes_bytes_(*lpdwNumberOfBytes)
+             LPVOID        lpBuffer,
+    _Inout_  LPDWORD       lpdwNumberOfBytes,
+    _In_opt_ LPOVERLAPPED  lpOverlapped)
+{
+    UNREFERENCED_PARAMETER(lpBuffer);
+    UNREFERENCED_PARAMETER(lpdwNumberOfBytes);
+    UNREFERENCED_PARAMETER(lpOverlapped);
+
+    WIAEX_ERROR((g_hInst, "This method is not implemented or supported for this driver"));
+
+    HRESULT hr = STIERR_UNSUPPORTED;
+
+    m_hrLastEdviceError = hr;
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::RawReadData 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::RawWriteData. Writes data to the still image device.
+*
+* Parameters:
+*
+*    lpBuffer        - caller-supplied pointer to a buffer containing data
+*                      to be sent to the device.
+*    dwNumberOfBytes - caller-supplied number of bytes to be written; this is
+*                      the number of bytes in the buffer pointed to by lpBuffer.
+*    lpOverlapped    - optional, caller-supplied pointer to an OVERLAPPED structure
+*                      (described in the Microsoft Windows SDK documentation).
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This driver returns STIERR_UNSUPPORTED.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::RawWriteData(
+    _In_reads_bytes_(dwNumberOfBytes)
+             LPVOID       lpBuffer,
+             DWORD        dwNumberOfBytes,
+    _In_opt_ LPOVERLAPPED lpOverlapped)
+{
+    UNREFERENCED_PARAMETER(lpBuffer);
+    UNREFERENCED_PARAMETER(dwNumberOfBytes);
+    UNREFERENCED_PARAMETER(lpOverlapped);
+
+    WIAEX_ERROR((g_hInst, "This method is not implemented or supported for this driver"));
+
+    HRESULT hr = STIERR_UNSUPPORTED;
+
+    m_hrLastEdviceError = hr;
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::RawWriteData 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::RawReadCommand. Reads command information from
+* the still image device.
+*
+* Parameters:
+*
+*    lpBuffer          - caller-supplied pointer to a buffer to receive the
+*                        command read from the device.
+*    lpdwNumberOfBytes - caller-supplied pointer to a DWORD. The caller loads
+*                        the DWORD with the number of bytes in the buffer pointed
+*                        to by lpBuffer; The driver must replace this value with
+*                        the number of bytes actually read.
+*    lpOverlapped      - optional, caller-supplied pointer to an OVERLAPPED structure
+*                        (described in the Microsoft Windows SDK documentation).
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This driver returns STIERR_UNSUPPORTED.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::RawReadCommand(
+    _Out_writes_bytes_(*lpdwNumberOfBytes)
+             LPVOID       lpBuffer,
+    _Inout_  LPDWORD      lpdwNumberOfBytes,
+    _In_opt_ LPOVERLAPPED lpOverlapped)
+{
+    UNREFERENCED_PARAMETER(lpBuffer);
+    UNREFERENCED_PARAMETER(lpdwNumberOfBytes);
+    UNREFERENCED_PARAMETER(lpOverlapped);
+
+    WIAEX_ERROR((g_hInst, "This method is not implemented or supported for this driver"));
+
+    HRESULT hr = STIERR_UNSUPPORTED;
+
+    m_hrLastEdviceError = hr;
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::RawReadCommand 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::RawWriteCommand. Writes command information to
+* the still image device.
+*
+* Parameters:
+*
+*    lpBuffer        - caller-supplied pointer to a buffer containing data
+*                      to be sent to the device.
+*    dwNumberOfBytes - caller-supplied number of bytes to be written; this is
+*                      the number of bytes in the buffer pointed to by lpBuffer.
+*    lpOverlapped    - optional, caller-supplied pointer to an OVERLAPPED structure
+*                      (described in the Microsoft Windows SDK documentation).
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code. This driver returns STIERR_UNSUPPORTED.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::RawWriteCommand(
+    _In_reads_bytes_(dwNumberOfBytes)
+             LPVOID        lpBuffer,
+             DWORD         dwNumberOfBytes,
+    _In_opt_ LPOVERLAPPED  lpOverlapped)
+{
+    UNREFERENCED_PARAMETER(lpBuffer);
+    UNREFERENCED_PARAMETER(dwNumberOfBytes);
+    UNREFERENCED_PARAMETER(lpOverlapped);
+
+    WIAEX_ERROR((g_hInst, "This method is not implemented or supported for this driver"));
+
+    HRESULT hr = STIERR_UNSUPPORTED;
+
+    m_hrLastEdviceError = hr;
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::RawWriteCommand 0x%08X", hr));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::GetLastError. Returns the last known error associated
+* with the still image device. The driver should record the last STIERR_ error
+* code (defined in stierr.h) or generic Win32 error code (retrieved using the
+* GetLastError Win32 API) encountered during its operation.
+*
+* Parameters:
+*
+*    pdwLastDeviceError - caller-supplied pointer to a buffer in which
+*                         the error code will be stored
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::GetLastError(
+    _Out_ LPDWORD pdwLastDeviceError)
+{
+    //
+    // When this method is called the driver should also check the scanner state
+    // (as when re-initializing the current WIA_DPS_DOCUMENT_HANDLING_STATUS).
+    //
+    HRESULT hr = S_OK;
+
+    if (!pdwLastDeviceError)
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
+        m_hrLastEdviceError = STIERR_INVALID_PARAM;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        *pdwLastDeviceError = WIN32_FROM_HRESULT(m_hrLastEdviceError);
+    }
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::GetLastError 0x%08X (%u, 0x%08X)", hr, m_hrLastEdviceError, m_hrLastEdviceError));
+
+    return hr;
+}
+
+/**************************************************************************\
+*
+* Implements IStiUSD::GetLastErrorInfo. Returns information about the last
+* known error associated with a still image device. The driver should record
+* the last STIERR_ error code (defined in stierr.h) or generic Win32 error code
+* (retrieved using the GetLastError Win32 API) encountered during its operation.
+* This error code would be the only information packaged in the STI_ERROR_INFO
+* to be returned by this method for the sample driver. The sample driver does
+* not provide a vendor error ID and no additional text error description.
+*
+* Parameters:
+*
+*    pLastErrorInfo - caller-supplied pointer to an STI_ERROR_INFO structure
+*                     to receive error information
+*
+* Return Value:
+*
+*    If the operation succeeds, the method must return S_OK. Otherwise, it
+*    should return one of the STIERR-prefixed error codes defined in stierr.h
+*    or another standard COM error code.
+*
+\**************************************************************************/
+
+HRESULT CWiaDriver::GetLastErrorInfo(
+    _Out_ STI_ERROR_INFO *pLastErrorInfo)
+{
+    HRESULT hr = S_OK;
+
+    if (!pLastErrorInfo)
+    {
+        hr = E_INVALIDARG;
+        WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X",hr));
+        m_hrLastEdviceError = STIERR_INVALID_PARAM;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        memset(pLastErrorInfo, 0, sizeof(STI_ERROR_INFO));
+        pLastErrorInfo->dwGenericError = WIN32_FROM_HRESULT(m_hrLastEdviceError);
+    }
+
+    WIAEX_TRACE((g_hInst, "IStiUSD::GetLastErrorInfo 0x%08X (%u, 0x%08X)", hr, m_hrLastEdviceError, m_hrLastEdviceError));
+
+    //
+    // If successful reset the recorded error to not report it more than once:
+    //
+    if (SUCCEEDED(hr))
+    {
+        m_hrLastEdviceError = STI_ERROR_NO_ERROR;
+    }
+
+    return hr;
+}