You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1079 lines
25 KiB
1079 lines
25 KiB
/*****************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORPORATION, 1999 - 2000
|
|
*
|
|
* TITLE: vstiusd.cpp
|
|
*
|
|
* VERSION: 1.1
|
|
*
|
|
* AUTHOR: WilliamH (created)
|
|
* RickTu (ported to WIA)
|
|
*
|
|
* DATE: 9/7/99
|
|
*
|
|
* DESCRIPTION: This module implements the CVideoStiUsd object &
|
|
* supported classes.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
#include <precomp.h>
|
|
#pragma hdrstop
|
|
|
|
DEFINE_GUID(CLSID_VIDEO_STIUSD,0x0527d1d0, 0x88c2, 0x11d2, 0x82, 0xc7, 0x00, 0xc0, 0x4f, 0x8e, 0xc1, 0x83);
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory constructor / desctructor
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
ULONG g_cDllRef = 0;
|
|
|
|
CVideoUsdClassFactory::CVideoUsdClassFactory()
|
|
{
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::QueryInterface
|
|
|
|
Add our info to the base class QI code.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoUsdClassFactory::QueryInterface( REFIID riid, void **ppvObject)
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::QueryInterface");
|
|
|
|
*ppvObject = NULL;
|
|
|
|
if (IsEqualIID(riid, IID_IUnknown) ||
|
|
IsEqualIID(riid, IID_IClassFactory))
|
|
{
|
|
*ppvObject = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::AddRef
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP_(ULONG) CVideoUsdClassFactory::AddRef(void)
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::AddRef");
|
|
|
|
InterlockedIncrement((LONG *)&g_cDllRef);
|
|
InterlockedIncrement((LONG *)&m_cRef);
|
|
return m_cRef;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::Release
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CVideoUsdClassFactory::Release(void)
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::Release");
|
|
|
|
InterlockedDecrement((LONG *)&g_cDllRef);
|
|
InterlockedDecrement((LONG *)&m_cRef);
|
|
|
|
if (m_cRef == 0)
|
|
{
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_cRef;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::CreateInstance
|
|
|
|
Instantiate one of the objects we are responsible for.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoUsdClassFactory::CreateInstance(IUnknown *pOuterUnk,
|
|
REFIID riid,
|
|
void **ppv)
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::CreateInstance");
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if (!ppv)
|
|
{
|
|
DBG_ERR(("ppv is NULL. returning E_INVALIDARG"));
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
*ppv = NULL;
|
|
|
|
//
|
|
// If it's not an interface we support, bail early
|
|
//
|
|
|
|
if (!IsEqualIID(riid, IID_IStiUSD) &&
|
|
!IsEqualIID(riid, IID_IWiaMiniDrv) &&
|
|
!IsEqualIID(riid, IID_IUnknown))
|
|
{
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
//
|
|
// When created for aggregation, only IUnknown can be requested.
|
|
//
|
|
|
|
if (pOuterUnk &&
|
|
!IsEqualIID(riid, IID_IUnknown))
|
|
{
|
|
return CLASS_E_NOAGGREGATION;
|
|
}
|
|
|
|
//
|
|
// Create our Usd/Wia mini driver
|
|
//
|
|
|
|
CVideoStiUsd *pUsd = NULL;
|
|
HRESULT hr;
|
|
|
|
pUsd = new CVideoStiUsd(pOuterUnk);
|
|
|
|
if (!pUsd)
|
|
{
|
|
DBG_ERR(("Couldn't create new CVideoStiUsd class, "
|
|
"returning E_OUTOFMEMORY"));
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = pUsd->PrivateInitialize();
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
CHECK_S_OK2( hr, ("pUsd->PrivateInitialize" ));
|
|
delete pUsd;
|
|
return hr;
|
|
}
|
|
|
|
// Move to the requested interface if we aren't aggregated.
|
|
// Don't do this if aggregated, or we will lose the private
|
|
// IUnknown and then the caller will be hosed.
|
|
|
|
hr = pUsd->NonDelegatingQueryInterface(riid, ppv);
|
|
CHECK_S_OK2( hr, ("pUsd->NonDelegatingQueryInterface" ));
|
|
|
|
pUsd->NonDelegatingRelease();
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::LockServer
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoUsdClassFactory::LockServer(BOOL fLock)
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::LockServer");
|
|
|
|
if (fLock)
|
|
{
|
|
InterlockedIncrement((LONG*)&g_cDllRef);
|
|
}
|
|
else
|
|
{
|
|
InterlockedDecrement((LONG*)&g_cDllRef);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::GetClassObject
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoUsdClassFactory::GetClassObject(REFCLSID rclsid,
|
|
REFIID riid,
|
|
void **ppv)
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::GetClassObject");
|
|
|
|
if (!ppv)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (rclsid == CLSID_VIDEO_STIUSD &&
|
|
(riid == IID_IUnknown || riid == IID_IClassFactory))
|
|
{
|
|
CVideoUsdClassFactory *pFactory = NULL;
|
|
|
|
pFactory = new CVideoUsdClassFactory();
|
|
|
|
if (pFactory)
|
|
{
|
|
*ppv = pFactory;
|
|
pFactory->AddRef();
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoUsdClassFactory::CanUnloadNow
|
|
|
|
Lets the outside world know if we can be unloaded.
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoUsdClassFactory::CanUnloadNow()
|
|
{
|
|
DBG_FN("CVideoUsdClassFactory::CanUnloadNow");
|
|
|
|
return (0 == g_cDllRef) ? S_OK : S_FALSE;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd constructor/destructor
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
CVideoStiUsd::CVideoStiUsd(IUnknown * pUnkOuter)
|
|
: m_bDeviceIsOpened(FALSE),
|
|
m_lPicsTaken(0),
|
|
m_hTakePictureEvent(NULL),
|
|
m_hPictureReadyEvent(NULL),
|
|
m_pTakePictureOwner(NULL),
|
|
m_pLastItemCreated(NULL),
|
|
m_dwConnectedApps(0),
|
|
m_cRef(1)
|
|
{
|
|
//
|
|
// See if we are aggregated. If we are (almost always the case) save
|
|
// pointer to the controlling Unknown , so subsequent calls will be
|
|
// delegated. If not, set the same pointer to "this".
|
|
//
|
|
|
|
if (pUnkOuter)
|
|
{
|
|
m_pUnkOuter = pUnkOuter;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Cast below is needed in order to point to right virtual table
|
|
//
|
|
|
|
m_pUnkOuter = reinterpret_cast<IUnknown*>
|
|
(static_cast<INonDelegatingUnknown*>
|
|
(this));
|
|
}
|
|
|
|
}
|
|
|
|
HRESULT CVideoStiUsd::PrivateInitialize()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
HANDLE hThread = NULL;
|
|
DWORD dwId = 0;
|
|
|
|
//
|
|
// Set up some global info
|
|
//
|
|
|
|
m_wfi = (WIA_FORMAT_INFO*) CoTaskMemAlloc(sizeof(WIA_FORMAT_INFO) *
|
|
NUM_WIA_FORMAT_INFO);
|
|
|
|
if (m_wfi)
|
|
{
|
|
//
|
|
// Set up the format/tymed pairs
|
|
//
|
|
|
|
m_wfi[0].guidFormatID = WiaImgFmt_JPEG;
|
|
m_wfi[0].lTymed = TYMED_CALLBACK;
|
|
|
|
m_wfi[1].guidFormatID = WiaImgFmt_JPEG;
|
|
m_wfi[1].lTymed = TYMED_FILE;
|
|
|
|
m_wfi[2].guidFormatID = WiaImgFmt_MEMORYBMP;
|
|
m_wfi[2].lTymed = TYMED_CALLBACK;
|
|
|
|
m_wfi[3].guidFormatID = WiaImgFmt_BMP;
|
|
m_wfi[3].lTymed = TYMED_CALLBACK;
|
|
|
|
m_wfi[4].guidFormatID = WiaImgFmt_BMP;
|
|
m_wfi[4].lTymed = TYMED_FILE;
|
|
}
|
|
|
|
//
|
|
// Initialize critical sections
|
|
//
|
|
|
|
__try
|
|
{
|
|
if (!InitializeCriticalSectionAndSpinCount(&m_csItemTree, MINLONG))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
|
|
DBG_ERR(("ERROR: Failed to initialize one of critsections "
|
|
"(0x%08X)",
|
|
hr));
|
|
}
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
//
|
|
// Initialize GDI+
|
|
//
|
|
|
|
Gdiplus::Status StatusResult = Gdiplus::Ok;
|
|
Gdiplus::GdiplusStartupInput StartupInput;
|
|
m_ulGdiPlusToken = NULL;
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
StatusResult = Gdiplus::GdiplusStartup(&m_ulGdiPlusToken,
|
|
&StartupInput,
|
|
NULL);
|
|
|
|
if (StatusResult != Gdiplus::Ok)
|
|
{
|
|
DBG_ERR(("ERROR: Failed to start up GDI+, Status code returned "
|
|
"by GDI+ = '%d'",
|
|
StatusResult));
|
|
|
|
hr = HRESULT_FROM_WIN32(StatusResult);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
CVideoStiUsd::~CVideoStiUsd()
|
|
{
|
|
|
|
if (m_pRootItem)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_TRC(("CVideoStiUsd::~CVideoStiUsd, driver is being destroyed, "
|
|
"and for some reason the tree still exists, deleting tree..."));
|
|
|
|
hr = m_pRootItem->UnlinkItemTree(WiaItemTypeDisconnected);
|
|
|
|
// Clear the root item
|
|
m_pRootItem = NULL;
|
|
}
|
|
|
|
//
|
|
// Disable Take Picture command.
|
|
//
|
|
DisableTakePicture(NULL, TRUE);
|
|
|
|
//
|
|
// Shutdown GDI+
|
|
//
|
|
Gdiplus::GdiplusShutdown(m_ulGdiPlusToken);
|
|
|
|
CloseDevice();
|
|
|
|
if (m_wfi)
|
|
{
|
|
CoTaskMemFree( (LPVOID)m_wfi );
|
|
m_wfi = NULL;
|
|
}
|
|
|
|
DeleteCriticalSection(&m_csItemTree);
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::NonDelegatingQueryInterface
|
|
|
|
This is the inner object QI -- in other words, handle QI's for the
|
|
interfaces our object supports.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::NonDelegatingQueryInterface(REFIID riid,
|
|
LPVOID *ppvObj )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_FN("CVideoStiUsd::NonDelegatingQueryInterface");
|
|
|
|
//
|
|
// Check for invalid args
|
|
//
|
|
|
|
if (!ppvObj)
|
|
{
|
|
DBG_ERR(("ppvObj is NULL, returning E_INVALIDARG"));
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
*ppvObj = NULL;
|
|
|
|
if (IsEqualIID(riid, IID_IUnknown))
|
|
{
|
|
*ppvObj = static_cast<INonDelegatingUnknown*>(this);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IStiUSD))
|
|
{
|
|
*ppvObj = static_cast<IStiUSD*>(this);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IWiaMiniDrv))
|
|
{
|
|
*ppvObj = static_cast<IWiaMiniDrv*>(this);
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
DBG_ERR(("CVideoStiUsd::NonDelegatingQueryInterface requested "
|
|
"interface we don't support, returning hr = 0x%08lx", hr));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
(reinterpret_cast<IUnknown*>(*ppvObj))->AddRef();
|
|
}
|
|
|
|
CHECK_S_OK(hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::NonDelegatingAddRef
|
|
|
|
This is the inner object AddRef -- actually inc the ref count
|
|
for our interfaces.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CVideoStiUsd::NonDelegatingAddRef(void)
|
|
{
|
|
DBG_FN("CVideoStiUsd::NonDelegatingAddRef");
|
|
|
|
return InterlockedIncrement((LPLONG)&m_cRef);
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::NonDelegatingRelease
|
|
|
|
This is the inner object Release -- actually dec the ref count
|
|
for our interfaces.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CVideoStiUsd::NonDelegatingRelease(void)
|
|
{
|
|
DBG_FN("CVideoStiUsd::NonDelegatingRelease");
|
|
|
|
ULONG ulRef = 0;
|
|
|
|
ulRef = InterlockedDecrement((LPLONG)&m_cRef);
|
|
|
|
if (!ulRef)
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
return ulRef;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::QueryInterface
|
|
|
|
Outer QI -- used for aggregation
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::QueryInterface(REFIID riid, LPVOID *ppvObj)
|
|
{
|
|
DBG_FN("CVideoStiUsd::QueryInterface");
|
|
|
|
return m_pUnkOuter->QueryInterface( riid, ppvObj );
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::AddRef
|
|
|
|
Outer AddRef -- used for aggregation
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CVideoStiUsd::AddRef(void)
|
|
{
|
|
DBG_FN("CVideoStiUsd::AddRef");
|
|
return m_pUnkOuter->AddRef();
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::Release
|
|
|
|
Outer Release -- used for aggregation
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CVideoStiUsd::Release(void)
|
|
{
|
|
DBG_FN("CVideoStiUsd::Release");
|
|
return m_pUnkOuter->Release();
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::Initialize [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::Initialize(PSTIDEVICECONTROL pDcb,
|
|
DWORD dwStiVersion,
|
|
HKEY hParameterKey)
|
|
{
|
|
DBG_FN("CVideoStiUsd::Initialize");
|
|
|
|
HRESULT hr = S_OK;
|
|
WCHAR DeviceName[MAX_PATH] = {0};
|
|
|
|
if ((pDcb == NULL) || (hParameterKey == NULL))
|
|
{
|
|
hr = E_POINTER;
|
|
CHECK_S_OK2(hr, ("CVideoStiUsd::Initialize, received a "
|
|
"NULL pointer, either 'pDcb = 0x%08lx' is NULL "
|
|
"or 'hParameterKey = 0x%08lx' is NULL",
|
|
pDcb, hParameterKey));
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
//
|
|
// get the device symbolic name. We use the name to get an IMoniker to
|
|
// the device filter proxy.
|
|
//
|
|
hr = pDcb->GetMyDevicePortName(DeviceName,
|
|
sizeof(DeviceName)/sizeof(WCHAR));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = OpenDevice(DeviceName);
|
|
}
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
HKEY hKey = NULL;
|
|
DWORD dwType = 0;
|
|
LRESULT lResult = ERROR_SUCCESS;
|
|
TCHAR szValue[MAX_PATH + 1] = {0};
|
|
DWORD dwSize = sizeof(szValue) - sizeof(szValue[0]);
|
|
|
|
lResult = RegOpenKeyEx(hParameterKey,
|
|
TEXT("DeviceData"),
|
|
0,
|
|
KEY_READ,
|
|
&hKey);
|
|
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Read DShow device ID from DeviceData registry
|
|
//
|
|
lResult = RegQueryValueEx(hKey,
|
|
TEXT("DShowDeviceId"),
|
|
NULL,
|
|
&dwType,
|
|
(BYTE*) szValue,
|
|
&dwSize);
|
|
|
|
szValue[sizeof(szValue) / sizeof(szValue[0]) - 1] = '\0';
|
|
}
|
|
|
|
if (hKey)
|
|
{
|
|
RegCloseKey(hKey);
|
|
hKey = NULL;
|
|
}
|
|
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
m_strDShowDeviceId = szValue;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
CHECK_S_OK2(hr, ("CVideoStiUsd::Initialize, failed to retrieve the "
|
|
"DShow Device ID."));
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::CloseDevice [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoStiUsd::CloseDevice()
|
|
{
|
|
DBG_FN("CVideoStiUsd::CloseDevice");
|
|
|
|
m_bDeviceIsOpened = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::OpenDevice [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoStiUsd::OpenDevice(LPCWSTR DeviceName)
|
|
{
|
|
DBG_FN("CVideoStiUsd::OpenDevice");
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if (!DeviceName || (0 == *DeviceName))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
m_bDeviceIsOpened = TRUE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::GetCapabilities [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::GetCapabilities(PSTI_USD_CAPS pDevCaps)
|
|
{
|
|
DBG_FN("CVideoStiUsd::GetCapabilities");
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if (!pDevCaps)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
memset(pDevCaps, 0, sizeof(STI_USD_CAPS));
|
|
|
|
pDevCaps->dwVersion = STI_VERSION;
|
|
pDevCaps->dwGenericCaps = STI_USD_GENCAP_NATIVE_PUSHSUPPORT;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::GetStatus [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::GetStatus(PSTI_DEVICE_STATUS pDevStatus)
|
|
{
|
|
DBG_FN("CVideoStiUsd::GetStatus");
|
|
|
|
if (!pDevStatus)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (pDevStatus->StatusMask & STI_DEVSTATUS_ONLINE_STATE )
|
|
{
|
|
if (m_bDeviceIsOpened)
|
|
{
|
|
pDevStatus->dwOnlineState |= STI_ONLINESTATE_OPERATIONAL;
|
|
}
|
|
else
|
|
{
|
|
pDevStatus->dwOnlineState &= ~STI_ONLINESTATE_OPERATIONAL;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::DeviceReset [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::DeviceReset()
|
|
{
|
|
DBG_FN("CVideoStiUsd::DeviceReset");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::Diagnostic [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::Diagnostic(LPSTI_DIAG pStiDiag)
|
|
{
|
|
DBG_FN("CVideoStiUsd::Diagnostic");
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if (!pStiDiag)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// Return diag info
|
|
//
|
|
|
|
pStiDiag->dwStatusMask = 0;
|
|
memset(&pStiDiag->sErrorInfo, 0, sizeof(pStiDiag->sErrorInfo));
|
|
|
|
if (m_bDeviceIsOpened)
|
|
{
|
|
pStiDiag->sErrorInfo.dwGenericError = NOERROR;
|
|
}
|
|
else
|
|
{
|
|
pStiDiag->sErrorInfo.dwGenericError = STI_NOTCONNECTED;
|
|
}
|
|
|
|
pStiDiag->sErrorInfo.dwVendorError = 0;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::Escape [IStillUsd]
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::Escape(STI_RAW_CONTROL_CODE Function,
|
|
LPVOID DataIn,
|
|
DWORD DataInSize,
|
|
LPVOID DataOut,
|
|
DWORD DataOutSize,
|
|
DWORD *pActualSize)
|
|
{
|
|
|
|
DBG_FN("CVideoStiUsd::Escape");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::GetLastError [IStillUsd]
|
|
|
|
Not implemented yet.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::GetLastError(LPDWORD pLastError)
|
|
{
|
|
DBG_FN("CVideoStiUsd::GetLastError( NOT_IMPL )");
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::LockDevice [IStillUsd]
|
|
|
|
No actual locking of the device has to happen, so just return success.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::LockDevice()
|
|
{
|
|
DBG_FN("CVideoStiUsd::LockDevice");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::UnLockDevice [IStillUsd]
|
|
|
|
No actual locking/unlocking of the device has to happen, so just return
|
|
success.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::UnLockDevice()
|
|
{
|
|
DBG_FN("CVideoStiUsd::UnlockDevice");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::RawReadData [IStillUsd]
|
|
|
|
Not implemented yet.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::RawReadData(LPVOID Buffer,
|
|
LPDWORD BufferSize,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
DBG_FN("CVideoStiUsd::RawReadData( NOT_IMPL )");
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::RawWriteData [IStillUsd]
|
|
|
|
Not implemented yet.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::RawWriteData(LPVOID Buffer,
|
|
DWORD BufferSize,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
DBG_FN("CVideoStiUsd::RawWriteData( NOT_IMPL )");
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::RawReadCommand [IStillUsd]
|
|
|
|
Not implemented yet.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::RawReadCommand(LPVOID Buffer,
|
|
LPDWORD BufferSize,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
DBG_FN("CVideoStiUsd::RawReadCommand( NOT_IMPL )");
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::RawWriteCommand [IStillUsd]
|
|
|
|
Not implemented yet.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::RawWriteCommand(LPVOID Buffer,
|
|
DWORD BufferSize,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
DBG_FN("CVideoStiUsd::RawWriteCommand( NOT_IMPL )");
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::SetNotificationHandle [IStillUsd]
|
|
|
|
Sets the event notification handle.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::SetNotificationHandle(HANDLE hEvent)
|
|
{
|
|
DBG_FN("CVideoStiUsd::SetNotificationHandle");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::GetNotificationData [IStillUsd]
|
|
|
|
Returns the current event notification handle.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::GetNotificationData(LPSTINOTIFY lpNotify)
|
|
{
|
|
DBG_FN("CVideoStiUsd::GetNotificationData");
|
|
|
|
HRESULT hr = STIERR_NOEVENTS;
|
|
|
|
DBG_ERR(("We were called, but no events are present -- why?"));
|
|
|
|
CHECK_S_OK(hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::GetLastErrorInfo [IStillUsd]
|
|
|
|
Not implemented yet.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::GetLastErrorInfo(STI_ERROR_INFO *pLastErrorInfo)
|
|
{
|
|
DBG_FN("CVideoStiUsd::GetLastErrorInfo( NOT_IMPL )");
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|