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.
956 lines
25 KiB
956 lines
25 KiB
/*****************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORPORATION, 1999-2000
|
|
*
|
|
* TITLE: ItemTree.cpp
|
|
*
|
|
* VERSION: 1.0
|
|
*
|
|
* AUTHOR: RickTu
|
|
*
|
|
* DATE: 9/10/99 RickTu
|
|
* 2000/11/09 OrenR
|
|
*
|
|
* DESCRIPTION: This code was originally in 'camera.cpp' but was broken out.
|
|
* This code builds and maintains the camera's IWiaDrvItem tree.
|
|
*
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include <precomp.h>
|
|
#pragma hdrstop
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::BuildItemTree
|
|
|
|
Constructs an item tree which represents the layout of this
|
|
WIA camera...
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::BuildItemTree(IWiaDrvItem ** ppIDrvItemRoot,
|
|
LONG * plDevErrVal)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DBG_FN("CVideoStiUsd::BuildItemTree");
|
|
|
|
EnterCriticalSection( &m_csItemTree );
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if (!ppIDrvItemRoot)
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
//
|
|
// Make sure that there is only one item tree
|
|
//
|
|
|
|
else if (m_pRootItem)
|
|
{
|
|
*ppIDrvItemRoot = m_pRootItem;
|
|
|
|
//
|
|
// refresh our tree. We prune out all files which no longer exist
|
|
// but for some reason remain in our tree (this can happen if someone
|
|
// manually deletes a file from the temp WIA directory where we store
|
|
// these images before they are transfered)
|
|
//
|
|
|
|
RefreshTree(m_pRootItem, plDevErrVal);
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
//
|
|
// Lastly, build the tree if we need to
|
|
//
|
|
|
|
else
|
|
{
|
|
//
|
|
// First check to see if we have a corresponding DShow device id
|
|
// in the registry -- if not, then bail.
|
|
//
|
|
|
|
if (!m_strDShowDeviceId.Length())
|
|
{
|
|
hr = E_FAIL;
|
|
CHECK_S_OK2(hr, ("CVideoStiUsd::BuildItemTree, the DShow Device ID"
|
|
"is empty, this should never happen"));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Create the new root
|
|
//
|
|
|
|
CSimpleBStr bstrRoot(L"Root");
|
|
|
|
//
|
|
// Call Wia service library to create new root item
|
|
//
|
|
|
|
hr = wiasCreateDrvItem(WiaItemTypeFolder |
|
|
WiaItemTypeRoot |
|
|
WiaItemTypeDevice,
|
|
bstrRoot.BString(),
|
|
CSimpleBStr(m_strRootFullItemName),
|
|
(IWiaMiniDrv *)this,
|
|
sizeof(STILLCAM_IMAGE_CONTEXT),
|
|
NULL,
|
|
ppIDrvItemRoot);
|
|
|
|
CHECK_S_OK2( hr, ("wiaCreateDrvItem" ));
|
|
|
|
if (SUCCEEDED(hr) && *ppIDrvItemRoot)
|
|
{
|
|
m_pRootItem = *ppIDrvItemRoot;
|
|
|
|
//
|
|
// Add the items for this device
|
|
//
|
|
|
|
hr = EnumSavedImages( m_pRootItem );
|
|
CHECK_S_OK2( hr, ("EnumSavedImages" ));
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&m_csItemTree);
|
|
|
|
CHECK_S_OK(hr);
|
|
return hr;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::AddTreeItem
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoStiUsd::AddTreeItem(CSimpleString *pstrFullImagePath,
|
|
IWiaDrvItem **ppDrvItem)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
INT iPos = 0;
|
|
LPCTSTR pszFileName = NULL;
|
|
|
|
if (pstrFullImagePath == NULL)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
CHECK_S_OK2(hr, ("CVideoStiUsd::AddTreeItem, received NULL "
|
|
"param"));
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Extract the file name from the full path. We do this by searching
|
|
// for the first '\' from the end of the string.
|
|
//
|
|
iPos = pstrFullImagePath->ReverseFind('\\');
|
|
|
|
if (iPos < (INT) pstrFullImagePath->Length())
|
|
{
|
|
//
|
|
// increment the position by 1 because we want to skip over the
|
|
// backslash.
|
|
//
|
|
++iPos;
|
|
|
|
//
|
|
// point to the filename within the full path.
|
|
//
|
|
pszFileName = &(*pstrFullImagePath)[iPos];
|
|
}
|
|
|
|
if (pszFileName)
|
|
{
|
|
//
|
|
// Create a new DrvItem for this image and add it to the
|
|
// DrvItem tree.
|
|
//
|
|
|
|
IWiaDrvItem *pNewFolder = NULL;
|
|
|
|
hr = CreateItemFromFileName(WiaItemTypeFile | WiaItemTypeImage,
|
|
pstrFullImagePath->String(),
|
|
pszFileName,
|
|
&pNewFolder);
|
|
|
|
CHECK_S_OK2( hr, ("CVideoStiUsd::AddTreeItem, "
|
|
"CreateItemFromFileName failed"));
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = pNewFolder->AddItemToFolder(m_pRootItem);
|
|
|
|
CHECK_S_OK2( hr, ("CVideoStiUsd::AddTreeItem, "
|
|
"pNewFolder->AddItemToFolder failed"));
|
|
}
|
|
|
|
if (ppDrvItem)
|
|
{
|
|
*ppDrvItem = pNewFolder;
|
|
(*ppDrvItem)->AddRef();
|
|
}
|
|
|
|
pNewFolder->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::EnumSavedImages
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::EnumSavedImages(IWiaDrvItem * pRootItem)
|
|
{
|
|
DBG_FN("CVideoStiUsd::EnumSavedImages");
|
|
|
|
HRESULT hr = S_OK;
|
|
WIN32_FIND_DATA FindData;
|
|
|
|
if (!m_strStillPath.Length())
|
|
{
|
|
DBG_ERR(("m_strStillPath is NULL, can't continue!"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
CSimpleString strTempName(m_strStillPath);
|
|
strTempName.Concat( TEXT("\\*.jpg") );
|
|
|
|
//
|
|
// look for files at this level
|
|
//
|
|
|
|
HANDLE hFile = FindFirstFile(strTempName.String(), &FindData);
|
|
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
|
|
BOOL bStatus = FALSE;
|
|
|
|
do
|
|
{
|
|
//
|
|
// generate file name
|
|
//
|
|
|
|
strTempName.Assign( m_strStillPath );
|
|
strTempName.Concat( TEXT("\\") );
|
|
strTempName.Concat( FindData.cFileName );
|
|
|
|
hr = AddTreeItem(&strTempName, NULL);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// look for more images
|
|
//
|
|
|
|
bStatus = FindNextFile(hFile,&FindData);
|
|
|
|
} while (bStatus);
|
|
|
|
FindClose(hFile);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::DoesFileExist
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
BOOL
|
|
CVideoStiUsd::DoesFileExist(BSTR bstrFileName)
|
|
{
|
|
DBG_FN("CVideoStiUsd::DoesFileExist");
|
|
|
|
BOOL bExists = FALSE;
|
|
DWORD dwAttrib = 0;
|
|
|
|
if (bstrFileName == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CSimpleString strTempName(m_strStillPath);
|
|
strTempName.Concat(TEXT("\\"));
|
|
strTempName.Concat(bstrFileName);
|
|
strTempName.Concat(TEXT(".jpg"));
|
|
|
|
dwAttrib = ::GetFileAttributes(strTempName);
|
|
|
|
if (dwAttrib != 0xFFFFFFFF)
|
|
{
|
|
bExists = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bExists = FALSE;
|
|
}
|
|
|
|
return bExists;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::PruneTree
|
|
|
|
Removes nodes from the tree whose filenames no longer exist in the temp
|
|
directory
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoStiUsd::PruneTree(IWiaDrvItem * pRootItem,
|
|
BOOL * pbTreeChanged)
|
|
{
|
|
DBG_FN("CVideoStiUsd::PruneTree");
|
|
|
|
HRESULT hr = S_OK;
|
|
BOOL bTreeChanged = FALSE;
|
|
IWiaDrvItem *pCurrentItem = NULL;
|
|
IWiaDrvItem *pNextItem = NULL;
|
|
BSTR bstrItemName = NULL;
|
|
|
|
if ((pRootItem == NULL) || (pbTreeChanged == NULL))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
else if (!m_strStillPath.Length())
|
|
{
|
|
DBG_ERR(("m_strStillPath is NULL, can't continue!"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
// This function DOES NOT do an AddRef
|
|
hr = pRootItem->GetFirstChildItem(&pCurrentItem);
|
|
|
|
while ((hr == S_OK) && (pCurrentItem != NULL))
|
|
{
|
|
pNextItem = NULL;
|
|
|
|
pCurrentItem->AddRef();
|
|
|
|
hr = pCurrentItem->GetItemName(&bstrItemName);
|
|
|
|
if (SUCCEEDED(hr) && (bstrItemName != NULL))
|
|
{
|
|
//
|
|
// if the filename for this item does not exist,
|
|
// then remove it from our tree.
|
|
//
|
|
if (!DoesFileExist(bstrItemName))
|
|
{
|
|
//
|
|
// get the next item in the list so we don't lose our place
|
|
// in the list after removing the current item.
|
|
//
|
|
hr = pCurrentItem->GetNextSiblingItem(&pNextItem);
|
|
CHECK_S_OK2(hr, ("pCurrentItem->GetNextSiblingItem"));
|
|
|
|
//
|
|
// remove the item from the folder, we no longer need it.
|
|
//
|
|
hr = pCurrentItem->RemoveItemFromFolder(WiaItemTypeDeleted);
|
|
CHECK_S_OK2(hr, ("pItemToRemove->RemoveItemFromFolder"));
|
|
|
|
//
|
|
// Report the error, but continue. If we failed to
|
|
// remove the item from the tree, for whatever reason,
|
|
// there really is nothing we can do but proceed and
|
|
// prune the remainder of the tree.
|
|
//
|
|
if (hr != S_OK)
|
|
{
|
|
DBG_ERR(("Failed to remove item from folder, "
|
|
"hr = 0x%08lx",
|
|
hr));
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (m_lPicsTaken > 0)
|
|
{
|
|
//
|
|
// Decrement the # of pics taken only if the
|
|
// current # of pics is greater than 0.
|
|
//
|
|
InterlockedCompareExchange(
|
|
&m_lPicsTaken,
|
|
m_lPicsTaken - 1,
|
|
(m_lPicsTaken > 0) ? m_lPicsTaken : -1);
|
|
}
|
|
|
|
//
|
|
// Indicate the tree was changed so we can send a notification
|
|
// when we are done.
|
|
//
|
|
bTreeChanged = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// file does exist, all is well in the world, move on to next
|
|
// item in the tree.
|
|
hr = pCurrentItem->GetNextSiblingItem(&pNextItem);
|
|
}
|
|
}
|
|
|
|
//
|
|
// release the current item since we AddRef'd it at the start of this
|
|
// loop.
|
|
//
|
|
pCurrentItem->Release();
|
|
pCurrentItem = NULL;
|
|
|
|
//
|
|
// set our next item to be our current item. It is possible that
|
|
// pNextItem is NULL.
|
|
//
|
|
pCurrentItem = pNextItem;
|
|
|
|
//
|
|
// Free the BSTR.
|
|
//
|
|
if (bstrItemName)
|
|
{
|
|
::SysFreeString(bstrItemName);
|
|
bstrItemName = NULL;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
if (pbTreeChanged)
|
|
{
|
|
*pbTreeChanged = bTreeChanged;
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::IsFileAlreadyInTree
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
BOOL
|
|
CVideoStiUsd::IsFileAlreadyInTree(IWiaDrvItem * pRootItem,
|
|
LPCTSTR pszFileName)
|
|
{
|
|
DBG_FN("CVideoStiUsd::IsFileAlreadyInTree");
|
|
|
|
HRESULT hr = S_OK;
|
|
BOOL bFound = FALSE;
|
|
IWiaDrvItem *pCurrentItem = NULL;
|
|
|
|
if ((pRootItem == NULL) ||
|
|
(pszFileName == NULL))
|
|
{
|
|
bFound = FALSE;
|
|
DBG_ERR(("CVideoStiUsd::IsFileAlreadyInTree received a NULL pointer, "
|
|
"returning FALSE, item not found in tree."));
|
|
|
|
return bFound;
|
|
}
|
|
|
|
CSimpleString strFileName( m_strStillPath );
|
|
CSimpleString strBaseName( pszFileName );
|
|
strFileName.Concat( TEXT("\\") );
|
|
strFileName.Concat( strBaseName );
|
|
|
|
CImage Image(m_strStillPath,
|
|
CSimpleBStr(m_strRootFullItemName),
|
|
strFileName.String(),
|
|
strBaseName.String(),
|
|
WiaItemTypeFile | WiaItemTypeImage);
|
|
|
|
hr = pRootItem->FindItemByName(0,
|
|
Image.bstrFullItemName(),
|
|
&pCurrentItem);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
bFound = TRUE;
|
|
//
|
|
// Don't forget to release the driver item, since it was AddRef'd by
|
|
// FindItemByName(..)
|
|
//
|
|
pCurrentItem->Release();
|
|
}
|
|
else
|
|
{
|
|
bFound = FALSE;
|
|
}
|
|
|
|
return bFound;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::AddNewFilesToTree
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
HRESULT
|
|
CVideoStiUsd::AddNewFilesToTree(IWiaDrvItem * pRootItem,
|
|
BOOL * pbTreeChanged)
|
|
{
|
|
DBG_FN("CVideoStiUsd::AddNewFilesToTree");
|
|
|
|
HRESULT hr = E_FAIL;
|
|
BOOL bTreeChanged = FALSE;
|
|
HANDLE hFile = NULL;
|
|
BOOL bFileFound = FALSE;
|
|
WIN32_FIND_DATA FindData;
|
|
|
|
if ((pRootItem == NULL) ||
|
|
(pbTreeChanged == NULL))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (!m_strStillPath.Length())
|
|
{
|
|
DBG_ERR(("m_strStillPath is NULL, can't continue!"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
CSimpleString strTempName(m_strStillPath);
|
|
strTempName.Concat( TEXT("\\*.jpg") );
|
|
|
|
//
|
|
// Find all JPG files in the m_strStillPath directory.
|
|
// This directory is %windir%\temp\wia\{Device GUID}\XXXX
|
|
// where X is numeric.
|
|
//
|
|
hFile = FindFirstFile(strTempName.String(), &FindData);
|
|
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
bFileFound = TRUE;
|
|
}
|
|
|
|
//
|
|
// Iterate through all files in the directory and for each
|
|
// one check to see if it is already in the tree. If it
|
|
// isn't, then add it to the tree. If it is, do nothing
|
|
// and move to the next file in the directory
|
|
//
|
|
while (bFileFound)
|
|
{
|
|
//
|
|
// Check if the file in the directory is already in our
|
|
// tree.
|
|
//
|
|
if (!IsFileAlreadyInTree(pRootItem, FindData.cFileName))
|
|
{
|
|
//
|
|
// add an image to this folder
|
|
//
|
|
// generate file name
|
|
//
|
|
|
|
strTempName.Assign( m_strStillPath );
|
|
strTempName.Concat( TEXT("\\") );
|
|
strTempName.Concat( FindData.cFileName );
|
|
|
|
hr = AddTreeItem(&strTempName, NULL);
|
|
|
|
//
|
|
// Set this flag to indicate that changes were made to the
|
|
// tree, hence we will send an event indicating this when we
|
|
// are done.
|
|
//
|
|
bTreeChanged = TRUE;
|
|
}
|
|
|
|
//
|
|
// look for more images
|
|
//
|
|
|
|
bFileFound = FindNextFile(hFile,&FindData);
|
|
}
|
|
|
|
if (hFile)
|
|
{
|
|
FindClose(hFile);
|
|
hFile = NULL;
|
|
}
|
|
|
|
if (pbTreeChanged)
|
|
{
|
|
*pbTreeChanged = bTreeChanged;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::RefreshTree
|
|
|
|
<Notes>
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::RefreshTree(IWiaDrvItem * pRootItem,
|
|
LONG * plDevErrVal)
|
|
{
|
|
DBG_FN("CVideoStiUsd::RefreshTree");
|
|
|
|
BOOL bItemsAdded = FALSE;
|
|
BOOL bItemsRemoved = FALSE;
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Remove any dead nodes from the tree. A dead node is a node in the tree
|
|
// whose file has been deleted from the directory in m_strStillPath,
|
|
// but we still have a tree item for it.
|
|
//
|
|
hr = PruneTree(pRootItem, &bItemsRemoved);
|
|
CHECK_S_OK2(hr, ("PruneTree"));
|
|
|
|
//
|
|
// Add any news files that have been added to the folder but for some
|
|
// reason we don't have a tree node for them.
|
|
//
|
|
hr = AddNewFilesToTree(pRootItem, &bItemsAdded);
|
|
CHECK_S_OK2(hr, ("AddNewFilesToTree"));
|
|
|
|
//
|
|
// If we added new nodes, removed some nodes, or both, then notify the
|
|
// guys upstairs (in the UI world) that the tree has been updated.
|
|
//
|
|
if ((bItemsAdded) || (bItemsRemoved))
|
|
{
|
|
hr = wiasQueueEvent(CSimpleBStr(m_strDeviceId),
|
|
&WIA_EVENT_TREE_UPDATED,
|
|
NULL);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::CreateItemFromFileName
|
|
|
|
Helper function that creates a WIA item from a filename (which is a .jpg).
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::CreateItemFromFileName(LONG FolderType,
|
|
LPCTSTR pszPath,
|
|
LPCTSTR pszName,
|
|
IWiaDrvItem ** ppNewFolder)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
IWiaDrvItem * pNewFolder = NULL;
|
|
PSTILLCAM_IMAGE_CONTEXT pContext = NULL;
|
|
|
|
DBG_FN("CVideoStiUsd::CreateItemFromFileName");
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if (!ppNewFolder)
|
|
{
|
|
DBG_ERR(("ppNewFolder is NULL, returning E_INVALIDARG"));
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// Set up return value
|
|
//
|
|
|
|
*ppNewFolder = NULL;
|
|
|
|
//
|
|
// Create new image object
|
|
//
|
|
|
|
CImage * pImage = new CImage(m_strStillPath,
|
|
CSimpleBStr(m_strRootFullItemName),
|
|
pszPath,
|
|
pszName,
|
|
FolderType);
|
|
|
|
if (!pImage)
|
|
{
|
|
DBG_ERR(("Couldn't create new CImage, returning E_OUTOFMEMORY"));
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
//
|
|
// call Wia to create new DrvItem
|
|
//
|
|
|
|
|
|
hr = wiasCreateDrvItem(FolderType,
|
|
pImage->bstrItemName(),
|
|
pImage->bstrFullItemName(),
|
|
(IWiaMiniDrv *)this,
|
|
sizeof(STILLCAM_IMAGE_CONTEXT),
|
|
(BYTE **)&pContext,
|
|
&pNewFolder);
|
|
|
|
CHECK_S_OK2( hr, ("wiasCreateDrvItem"));
|
|
|
|
if (SUCCEEDED(hr) && pNewFolder)
|
|
{
|
|
|
|
//
|
|
// init device specific context
|
|
//
|
|
|
|
pContext->pImage = pImage;
|
|
|
|
//
|
|
// Return the item
|
|
//
|
|
|
|
*ppNewFolder = pNewFolder;
|
|
|
|
|
|
//
|
|
// Inc the number of pictures taken
|
|
//
|
|
|
|
InterlockedIncrement(&m_lPicsTaken);
|
|
|
|
}
|
|
else
|
|
{
|
|
DBG_ERR(("CVideoStiUsd::CreateItemFromFileName - wiasCreateItem "
|
|
"failed or returned NULL pNewFolder, hr = 0x%08lx, "
|
|
"pNewFolder = 0x%08lx, pContext = 0x%08lx",
|
|
hr,
|
|
pNewFolder,pContext ));
|
|
|
|
delete pImage;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::InitDeviceProperties
|
|
|
|
Initializes properties for the device on the device root item.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::InitDeviceProperties(BYTE * pWiasContext,
|
|
LONG * plDevErrVal)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BSTR bstrFirmwreVer = NULL;
|
|
int i = 0;
|
|
SYSTEMTIME camTime;
|
|
PROPVARIANT propVar;
|
|
|
|
DBG_FN("CVideoStiUsd::InitDeviceProperties");
|
|
|
|
//
|
|
// This device doesn't touch hardware to initialize the device properties.
|
|
//
|
|
|
|
if (plDevErrVal)
|
|
{
|
|
*plDevErrVal = 0;
|
|
}
|
|
|
|
//
|
|
// Parameter validation.
|
|
//
|
|
|
|
if (pWiasContext == NULL)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
|
|
CHECK_S_OK2(hr, ("CVideoStiUsd::InitDeviceProperties received "
|
|
"NULL param."));
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Write standard property names
|
|
//
|
|
|
|
hr = wiasSetItemPropNames(pWiasContext,
|
|
sizeof(gDevicePropIDs)/sizeof(PROPID),
|
|
gDevicePropIDs,
|
|
gDevicePropNames);
|
|
|
|
CHECK_S_OK2(hr, ("wiaSetItemPropNames"));
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
|
|
//
|
|
// Write the properties supported by all WIA devices
|
|
//
|
|
|
|
bstrFirmwreVer = SysAllocString(L"<NA>");
|
|
if (bstrFirmwreVer)
|
|
{
|
|
wiasWritePropStr(pWiasContext,
|
|
WIA_DPA_FIRMWARE_VERSION,
|
|
bstrFirmwreVer);
|
|
|
|
SysFreeString(bstrFirmwreVer);
|
|
}
|
|
|
|
hr = wiasWritePropLong(pWiasContext, WIA_DPA_CONNECT_STATUS, 1);
|
|
hr = wiasWritePropLong(pWiasContext, WIA_DPC_PICTURES_TAKEN, 0);
|
|
|
|
//
|
|
// Write the camera properties, just default values, it may
|
|
// vary with items
|
|
//
|
|
|
|
hr = wiasWritePropLong(pWiasContext, WIA_DPC_THUMB_WIDTH, 80);
|
|
hr = wiasWritePropLong(pWiasContext, WIA_DPC_THUMB_HEIGHT, 60);
|
|
|
|
//
|
|
// Write the Directshow Device ID
|
|
//
|
|
hr = wiasWritePropStr(pWiasContext,
|
|
WIA_DPV_DSHOW_DEVICE_PATH,
|
|
CSimpleBStr(m_strDShowDeviceId));
|
|
|
|
//
|
|
// Write the Images Directory
|
|
//
|
|
hr = wiasWritePropStr(pWiasContext,
|
|
WIA_DPV_IMAGES_DIRECTORY,
|
|
CSimpleBStr(m_strStillPath));
|
|
|
|
//
|
|
// Write the Last Picture Taken
|
|
//
|
|
hr = wiasWritePropStr(pWiasContext,
|
|
WIA_DPV_LAST_PICTURE_TAKEN,
|
|
CSimpleBStr(TEXT("")));
|
|
|
|
|
|
//
|
|
// Use WIA services to set the property access and
|
|
// valid value information from gDevPropInfoDefaults.
|
|
//
|
|
|
|
hr = wiasSetItemPropAttribs(pWiasContext,
|
|
NUM_CAM_DEV_PROPS,
|
|
gDevicePropSpecDefaults,
|
|
gDevPropInfoDefaults);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
CVideoStiUsd::InitImageInformation
|
|
|
|
Used to initialize device items (images) from this device.
|
|
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CVideoStiUsd::InitImageInformation( BYTE * pWiasContext,
|
|
PSTILLCAM_IMAGE_CONTEXT pContext,
|
|
LONG * plDevErrVal
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_FN("CVideoStiUsd::InitImageInformation");
|
|
|
|
//
|
|
// Check for bad args
|
|
//
|
|
|
|
if ((pWiasContext == NULL) ||
|
|
(pContext == NULL))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
CHECK_S_OK2(hr, ("CVideoStiUsd::InitImageInformation, received "
|
|
"NULL params"));
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Get the image in question
|
|
//
|
|
|
|
CImage * pImage = pContext->pImage;
|
|
|
|
if (pImage == NULL)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
//
|
|
// Ask the image to initialize the information
|
|
//
|
|
|
|
hr = pImage->InitImageInformation(pWiasContext, plDevErrVal);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|