XN_DDK_API XnStatus XnShiftToDepthFree(XnShiftToDepthTables* pShiftToDepth)
{
XN_VALIDATE_INPUT_PTR(pShiftToDepth);
if (pShiftToDepth->bIsInitialized)
{
XN_ALIGNED_FREE_AND_NULL(pShiftToDepth->pDepthToShiftTable);
XN_ALIGNED_FREE_AND_NULL(pShiftToDepth->pShiftToDepthTable);
pShiftToDepth->bIsInitialized = FALSE;
}
return XN_STATUS_OK;
}
XN_DDK_API XnStatus XnStreamDataUpdateSize(XnStreamData* pStreamOutput, XnUInt32 nAllocSize)
{
XN_VALIDATE_INPUT_PTR(pStreamOutput);
// allocate new memory
void* pNew = xnOSMallocAligned(nAllocSize, XN_DEFAULT_MEM_ALIGN);
if (pNew == NULL)
return (XN_STATUS_ALLOC_FAILED);
// zero it
xnOSMemSet(pNew, 0, nAllocSize);
// free the buffer if it is allocated
XN_ALIGNED_FREE_AND_NULL(pStreamOutput->pData);
// and now set new buffer
pStreamOutput->pData = pNew;
// and size
pStreamOutput->pInternal->nAllocSize = nAllocSize;
pStreamOutput->pInternal->bAllocated = TRUE;
return XN_STATUS_OK;
}
void LinkContInputStream::Shutdown()
{
if (!m_bInitialized)
return;
xnOSEnterCriticalSection(&m_hCriticalSection);
XN_ALIGNED_FREE_AND_NULL(m_pUserBuffer);
XN_ALIGNED_FREE_AND_NULL(m_pWorkingBuffer);
m_bInitialized = FALSE;
m_bNewDataAvailable = FALSE;
LinkInputStream::Shutdown();
xnOSLeaveCriticalSection(&m_hCriticalSection);
}
XN_C_API XnStatus xnOSCloseSocket(XN_SOCKET_HANDLE Socket)
{
// Local function variables
XnInt32 nRetVal = 0;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(Socket);
// Make sure the actual socket handle isn't NULL
XN_RET_IF_INVALID(Socket->Socket, XN_STATUS_OS_INVALID_SOCKET);
// shut down the socket
if (-1 == shutdown(Socket->Socket, SHUT_RDWR))
{
return(XN_STATUS_OS_NETWORK_SHUTDOWN_FAILED);
}
// Close the socket and make sure it succeeded (return value is 0)
if (-1 == close(Socket->Socket))
{
return(XN_STATUS_OS_NETWORK_SHUTDOWN_FAILED);
}
XN_ALIGNED_FREE_AND_NULL(Socket);
// All is good...
return (XN_STATUS_OK);
}
XnStatus XnDeviceSensorFreeBuffers(XnDevicePrivateData* pDevicePrivateData)
{
if (pDevicePrivateData->SensorHandle.DepthConnection.pUSBBuffer != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pDevicePrivateData->SensorHandle.DepthConnection.pUSBBuffer);
}
if (pDevicePrivateData->SensorHandle.ImageConnection.pUSBBuffer != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pDevicePrivateData->SensorHandle.ImageConnection.pUSBBuffer);
}
if (pDevicePrivateData->SensorHandle.MiscConnection.pUSBBuffer != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pDevicePrivateData->SensorHandle.MiscConnection.pUSBBuffer);
}
if (pDevicePrivateData->pSpecificDepthUsb != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pDevicePrivateData->pSpecificDepthUsb);
}
if (pDevicePrivateData->pSpecificImageUsb != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pDevicePrivateData->pSpecificImageUsb);
}
if (pDevicePrivateData->pSpecificMiscUsb != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pDevicePrivateData->pSpecificMiscUsb);
}
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnUSBCloseDevice(XN_USB_DEV_HANDLE pDevHandle)
{
// Validate xnUSB
XN_VALIDATE_USB_INIT();
XN_VALIDATE_USB_PDEV_HANDLE(pDevHandle);
// Close the device handle
CloseHandle(pDevHandle->hUSBDevHandle);
// Free the device handle
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
// All is good...
return (XN_STATUS_OK);
}
XnStatus xnFPSFree(XnFPSData* pFPS)
{
XN_VALIDATE_INPUT_PTR(pFPS);
XnFPSDataImpl* pData = *pFPS;
if (pData != NULL)
{
if (pData->anTimes != NULL)
{
XN_ALIGNED_FREE_AND_NULL(pData->anTimes);
}
if (*pFPS != NULL)
{
XN_FREE_AND_NULL(*pFPS);
}
}
return XN_STATUS_OK;
}
XN_C_API XnStatus xnUSBOpenEndPoint(XN_USB_DEV_HANDLE pDevHandle, XnUInt16 nEndPointID, XnUSBEndPointType nEPType, XnUSBDirectionType nDirType, XN_USB_EP_HANDLE* pEPHandlePtr)
{
// Local variables
XnBool bResult = TRUE;
XnStatus nRetVal = XN_STATUS_OK;
XnInt32 nRetBytes = 0;
XnChar pConfigDescBuf[MAX_CONFIG_DESC_SIZE];
XnChar* pBuf = NULL;
PUSB_CONFIGURATION_DESCRIPTOR pUSBConfigDesc = NULL;
PUSB_INTERFACE_DESCRIPTOR pUSBInterfaceDesc = NULL;
PUSB_ENDPOINT_DESCRIPTOR pUSBEndPointDesc = NULL;
XN_USB_EP_HANDLE pEPHandle = NULL;
XnChar cpPipeID[3];
// Validate xnUSB
XN_VALIDATE_USB_INIT();
XN_VALIDATE_USB_PDEV_HANDLE(pDevHandle);
// Validate the input/output pointers
XN_VALIDATE_OUTPUT_PTR(pEPHandlePtr);
// Allocate a new xnUSB EP handle
XN_VALIDATE_ALIGNED_CALLOC(*pEPHandlePtr, xnUSBEPHandle, 1, XN_DEFAULT_MEM_ALIGN);
pEPHandle = *pEPHandlePtr;
// Read the config descriptor
bResult = DeviceIoControl(pDevHandle->hUSBDevHandle, IOCTL_PSDRV_GET_CONFIG_DESCRIPTOR, pConfigDescBuf, sizeof(pConfigDescBuf), pConfigDescBuf, sizeof(pConfigDescBuf), (PULONG)&nRetBytes, NULL);
if (bResult)
{
XnUInt32 nIFIdx = 0;
UCHAR nEPIdx = 0;
XnUInt32 nUBBEPType = 0;
XnUInt32 nCurrIF = 0;
pBuf = pConfigDescBuf;
pUSBConfigDesc = (PUSB_CONFIGURATION_DESCRIPTOR)pBuf;
pBuf += pUSBConfigDesc->bLength;
// Scan all the interfaces
do {
pUSBInterfaceDesc = (PUSB_INTERFACE_DESCRIPTOR)pBuf;
pBuf += pUSBInterfaceDesc->bLength;
// Scan all the endpoints
for (nEPIdx = 0; nEPIdx < pUSBInterfaceDesc->bNumEndpoints; nEPIdx++)
{
pUSBEndPointDesc = (PUSB_ENDPOINT_DESCRIPTOR)pBuf;
// Is this the EP we're looking for?
if ((pUSBEndPointDesc->bEndpointAddress == nEndPointID) && (pDevHandle->nAltInterface == nCurrIF))
{
// Get the EP type
nUBBEPType = pUSBEndPointDesc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
// Verify that the EP type matches the requested EP
if (nEPType == XN_USB_EP_BULK)
{
if (nUBBEPType != USB_ENDPOINT_TYPE_BULK)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_WRONG_ENDPOINT_TYPE);
}
}
else if (nEPType == XN_USB_EP_INTERRUPT)
{
if (nUBBEPType != USB_ENDPOINT_TYPE_INTERRUPT)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_WRONG_ENDPOINT_TYPE);
}
}
else if (nEPType == XN_USB_EP_ISOCHRONOUS)
{
if (nUBBEPType != USB_ENDPOINT_TYPE_ISOCHRONOUS)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_WRONG_ENDPOINT_TYPE);
}
}
else
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_UNKNOWN_ENDPOINT_TYPE);
}
// Verify that the EP direction matches the requested direction
if (nDirType == XN_USB_DIRECTION_IN)
{
if (USB_ENDPOINT_DIRECTION_IN(pUSBEndPointDesc->bEndpointAddress) == FALSE)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_WRONG_ENDPOINT_DIRECTION);
}
}
else if (nDirType == XN_USB_DIRECTION_OUT)
{
if (USB_ENDPOINT_DIRECTION_OUT(pUSBEndPointDesc->bEndpointAddress) == FALSE)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_WRONG_ENDPOINT_DIRECTION);
}
}
else
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_UNKNOWN_ENDPOINT_DIRECTION);
}
// Construct the pipe file name
pEPHandle->cpPipeName[0] = 0;
cpPipeID[0] = '0';
cpPipeID[1] = '0' + nEPIdx;
cpPipeID[2] = 0;
StringCchCopy(pEPHandle->cpPipeName, MAX_DEVICE_STR_LENGTH, pDevHandle->cpDeviceName);
StringCchCat(pEPHandle->cpPipeName, MAX_DEVICE_STR_LENGTH, PSDRV_PIPE_PREFIX);
StringCchCat(pEPHandle->cpPipeName, MAX_DEVICE_STR_LENGTH, cpPipeID);
// Open the regular pipe handle
pEPHandle->hEPHandle = CreateFile(pEPHandle->cpPipeName, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
if (pEPHandle->hEPHandle == INVALID_HANDLE_VALUE)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_OPEN_ENDPOINT_FAILED);
}
// Init the overlapped I/O structs
nRetVal = xnUSBInitOvlp(pEPHandle);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (XN_STATUS_USB_OPEN_ENDPOINT_FAILED);
}
// Init the ThreadData variables
xnOSMemSet(&pEPHandle->ThreadData, 0, sizeof(xnUSBReadThreadData));
pEPHandle->ThreadData.bInUse = FALSE;
// Init the default endpoint properties
pEPHandle->nTimeOut = XN_USB_DEFAULT_EP_TIMEOUT;
pEPHandle->nEPType = nEPType;
pEPHandle->nEPDir = nDirType;
pEPHandle->nEndPointID = nEndPointID;
// Set the default endpoint timeout
nRetVal = xnUSBSetPipeProperty(pEPHandle, PSUSBDRV_PIPE_PROPERTY_TIMEOUT, XN_USB_DEFAULT_EP_TIMEOUT);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pEPHandle);
return (nRetVal);
}
if (nUBBEPType == USB_ENDPOINT_TYPE_ISOCHRONOUS)
{
// bits 11 and 12 mark the number of additional transactions, bits 0-10 mark the size
XnUInt32 nAdditionalTransactions = pUSBEndPointDesc->wMaxPacketSize >> 11;
XnUInt32 nPacketSize = pUSBEndPointDesc->wMaxPacketSize & 0x7FF;
pEPHandle->nMaxPacketSize = (nAdditionalTransactions + 1) * (nPacketSize);
}
else
{
pEPHandle->nMaxPacketSize = pUSBEndPointDesc->wMaxPacketSize;
}
// Mark the endpoint as valid
pEPHandle->bValid = TRUE;
// The end... (Happy)
return (XN_STATUS_OK);
}
pBuf += pUSBEndPointDesc->bLength;
}
XnStatus xnUSBOpenDeviceImpl(const XnChar* strDevicePath, XN_USB_DEV_HANDLE* pDevHandlePtr)
{
// Local variables
XnStatus nRetVal = XN_STATUS_OK;
LPCGUID pInterfaceGuid = NULL;
XN_USB_DEV_HANDLE pDevHandle = NULL;
ULONG nNumberDevices = 0;
HDEVINFO hDevInfo = NULL;
BOOLEAN bDone = FALSE;
SP_DEVICE_INTERFACE_DATA devInterfaceData;
PUSB_DEVICE_DESCRIPTOR pUsbDeviceInst = NULL;
PUSB_DEVICE_DESCRIPTOR* ppUsbDevices = &pUsbDeviceInst;
PUSB_DEVICE_DESCRIPTOR pTempDevDesc = NULL;
ULONG nIdx = 0;
HANDLE hSelectedDevice = INVALID_HANDLE_VALUE;
PSUSBDRV_DRIVER_VERSION UsbDriverVersion;
PSUSBDRV_INTERFACE_PROPERTY pInterfaceProp;
// Validate xnUSB
XN_VALIDATE_USB_INIT();
// Validate the input/output pointers
XN_VALIDATE_OUTPUT_PTR(pDevHandlePtr);
// Allocate a new xnUSB Device handle
XN_VALIDATE_ALIGNED_CALLOC(*pDevHandlePtr, XnUSBDeviceHandle, 1, XN_DEFAULT_MEM_ALIGN);
pDevHandle = *pDevHandlePtr;
// Get Device Path
pInterfaceGuid = &GUID_CLASS_PSDRV_USB;
// See if the driver is installed
hDevInfo = SetupDiGetClassDevs (pInterfaceGuid, NULL, NULL, (DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
if (hDevInfo == INVALID_HANDLE_VALUE)
{
// No devices are present...
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (XN_STATUS_USB_DRIVER_NOT_FOUND);
}
// Guess how much devices we're going to have. If it's too little, we'll realloc it soon.
nNumberDevices = 4;
// Scan the hardware for any devices that are attached to our driver. Stop only after we have successfully opened a device.
devInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
nIdx = 0;
bDone = FALSE;
while (!bDone)
{
// Allocate enough memory for all the devices that are attached to the driver
nNumberDevices *= 2;
if (*ppUsbDevices)
{
pTempDevDesc = (USB_DEVICE_DESCRIPTOR*)realloc(*ppUsbDevices, (nNumberDevices * sizeof (USB_DEVICE_DESCRIPTOR)));
if(pTempDevDesc)
{
// We have enough memory!
*ppUsbDevices = pTempDevDesc;
pTempDevDesc = NULL;
}
else
{
// Out of memory... realloc failed...
free(*ppUsbDevices);
*ppUsbDevices = NULL;
}
}
else
{
*ppUsbDevices = (USB_DEVICE_DESCRIPTOR*)calloc (nNumberDevices, sizeof (USB_DEVICE_DESCRIPTOR));
}
// Make sure we have found some devices
if (NULL == *ppUsbDevices)
{
SetupDiDestroyDeviceInfoList(hDevInfo);
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (XN_STATUS_USB_DEVICE_GETINFO_FAILED);
}
pUsbDeviceInst = *ppUsbDevices + nIdx;
// Scan all the devices that are attached to the driver. Stop when one of them open successfully.
for (; nIdx < nNumberDevices; nIdx++)
{
// Get information about the device
if (SetupDiEnumDeviceInterfaces (hDevInfo, 0, pInterfaceGuid, nIdx, &devInterfaceData))
{
// Try to open this device
hSelectedDevice = xnUSBOpenOneDevice(hDevInfo, &devInterfaceData, pDevHandle->cpDeviceName, strDevicePath);
if (hSelectedDevice != INVALID_HANDLE_VALUE)
{
// Success! We have a valid device handle.
bDone = TRUE;
break;
}
}
else
{
// Did we reach the end?
if (ERROR_NO_MORE_ITEMS == GetLastError())
{
// Yup... and we didn't find any devices...
bDone = TRUE;
break;
}
}
}
}
// Save the number of devices
nNumberDevices = nIdx;
// Cleanup memory
SetupDiDestroyDeviceInfoList (hDevInfo);
free (*ppUsbDevices);
// Do we have a valid device?
if (hSelectedDevice == INVALID_HANDLE_VALUE)
{
// Nope...
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (XN_STATUS_USB_DEVICE_NOT_FOUND);
}
// Save the device handle
pDevHandle->hUSBDevHandle = hSelectedDevice;
// Get the device speed
nRetVal = xnUSBGetDeviceSpeedInternal(pDevHandle, &pDevHandle->nDevSpeed);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (nRetVal);
}
// Get the driver version
nRetVal = xnUSBGetDriverVersion(pDevHandle, &UsbDriverVersion);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (nRetVal);
}
xnLogVerbose(XN_MASK_USB, "USB Driver Version is: %d.%d.%d.%d", UsbDriverVersion.nMajor, UsbDriverVersion.nMinor, UsbDriverVersion.nMaintenance, UsbDriverVersion.nBuild);
// Mark the device handle as valid
pDevHandle->bValid = TRUE;
// Read the current alt-if settings
nRetVal = xnUSBGetInterface(pDevHandle, &pInterfaceProp.nIF, &pInterfaceProp.nAltIF);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (nRetVal);
}
pDevHandle->nAltInterface = pInterfaceProp.nAltIF;
xnLogVerbose(XN_MASK_USB, "USB Driver Current Alt Setting is: %d", pDevHandle->nAltInterface);
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSCreateSocket(const XnOSSocketType SocketType, const XnChar* cpIPAddress, const XnUInt16 nPort, XN_SOCKET_HANDLE* SocketPtr)
{
// Local function variables
hostent* HostEnt = NULL;
XN_SOCKET_HANDLE Socket = NULL;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpIPAddress);
XN_VALIDATE_OUTPUT_PTR(SocketPtr);
XN_VALIDATE_ALIGNED_CALLOC(*SocketPtr, xnOSSocket, 1, XN_DEFAULT_MEM_ALIGN);
Socket = *SocketPtr;
if (SocketType == XN_OS_UDP_SOCKET)
{
// Create a UDP socket
Socket->Socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
}
else if (SocketType == XN_OS_TCP_SOCKET)
{
// Create a TCP socket
Socket->Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
}
else
{
// Unknown socket type...
XN_ALIGNED_FREE_AND_NULL(Socket);
return (XN_STATUS_OS_NETWORK_INVALID_SOCKET_TYPE);
}
if (Socket->Socket == INVALID_SOCKET)
{
XN_ALIGNED_FREE_AND_NULL(Socket);
XN_LOG_ERROR_RETURN(XN_STATUS_OS_NETWORK_SOCKET_CREATION_FAILED, XN_MASK_OS, "socket() returned WinSock error: %d", WSAGetLastError());
}
// Set the socket server address
Socket->SocketAddress.sin_family = AF_INET;
if (isalpha(cpIPAddress[0]))
{
HostEnt = gethostbyname(cpIPAddress);
if (HostEnt == NULL)
{
XN_ALIGNED_FREE_AND_NULL(Socket);
return (XN_STATUS_OS_NETWORK_BAD_HOST_NAME);
}
xnOSMemCopy(&Socket->SocketAddress.sin_addr, HostEnt->h_addr, HostEnt->h_length);
}
else
{
Socket->SocketAddress.sin_addr.s_addr = inet_addr(cpIPAddress);
}
Socket->SocketAddress.sin_port = htons(nPort);
// Update socket address size
Socket->nSocketAddressLen = sizeof(Socket->SocketAddress);
// Remember the socket type
Socket->nSocketType = SocketType;
// All is good...
return (XN_STATUS_OK);
}
XnStatus xnUSBOpenDeviceImpl(const XnChar* strDevicePath, XN_USB_DEV_HANDLE* pDevHandlePtr)
{
// Local variables
XnStatus nRetVal = XN_STATUS_OK;
LPCGUID pInterfaceGuid = NULL;
XN_USB_DEV_HANDLE pDevHandle = NULL;
HDEVINFO hDevInfo = NULL;
SP_DEVICE_INTERFACE_DATA devInterfaceData;
HANDLE hSelectedDevice = INVALID_HANDLE_VALUE;
PSUSBDRV_DRIVER_VERSION UsbDriverVersion;
PSUSBDRV_INTERFACE_PROPERTY pInterfaceProp;
// Validate xnUSB
XN_VALIDATE_USB_INIT();
// Validate the input/output pointers
XN_VALIDATE_OUTPUT_PTR(pDevHandlePtr);
// Allocate a new xnUSB Device handle
XN_VALIDATE_ALIGNED_CALLOC(*pDevHandlePtr, XnUSBDeviceHandle, 1, XN_DEFAULT_MEM_ALIGN);
pDevHandle = *pDevHandlePtr;
// Get Device Path
pInterfaceGuid = &GUID_CLASS_PSDRV_USB;
// See if the driver is installed
hDevInfo = SetupDiGetClassDevs (pInterfaceGuid, NULL, NULL, (DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
if (hDevInfo == INVALID_HANDLE_VALUE)
{
// No devices are present...
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (XN_STATUS_USB_DRIVER_NOT_FOUND);
}
// Scan the hardware for any devices that are attached to our driver. Stop only after we have successfully opened a device.
devInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
bool bDone = FALSE;
ULONG nIdx = 0;
// Scan all the devices that are attached to the driver. Stop when one of them open successfully.
while (!bDone)
{
// Get information about the device
if (SetupDiEnumDeviceInterfaces (hDevInfo, 0, pInterfaceGuid, nIdx, &devInterfaceData))
{
// Try to open this device
hSelectedDevice = xnUSBOpenOneDevice(hDevInfo, &devInterfaceData, pDevHandle->cpDeviceName, strDevicePath);
if (hSelectedDevice != INVALID_HANDLE_VALUE)
{
// Success! We have a valid device handle.
bDone = TRUE;
break;
}
}
else
{
// Did we reach the end?
if (ERROR_NO_MORE_ITEMS == GetLastError())
{
// Yup... and we didn't find any devices...
bDone = TRUE;
break;
}
}
++nIdx;
}
// Cleanup memory
SetupDiDestroyDeviceInfoList (hDevInfo);
// Do we have a valid device?
if (hSelectedDevice == INVALID_HANDLE_VALUE)
{
// Nope...
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (XN_STATUS_USB_DEVICE_NOT_FOUND);
}
// Save the device handle
pDevHandle->hUSBDevHandle = hSelectedDevice;
// Get the device speed
nRetVal = xnUSBGetDeviceSpeedInternal(pDevHandle, &pDevHandle->nDevSpeed);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (nRetVal);
}
// Get the driver version
nRetVal = xnUSBGetDriverVersion(pDevHandle, &UsbDriverVersion);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (nRetVal);
}
xnLogVerbose(XN_MASK_USB, "USB Driver Version is: %d.%d.%d.%d", UsbDriverVersion.nMajor, UsbDriverVersion.nMinor, UsbDriverVersion.nMaintenance, UsbDriverVersion.nBuild);
// Mark the device handle as valid
pDevHandle->bValid = TRUE;
// Read the current alt-if settings
nRetVal = xnUSBGetInterface(pDevHandle, &pInterfaceProp.nIF, &pInterfaceProp.nAltIF);
if (nRetVal != XN_STATUS_OK)
{
XN_ALIGNED_FREE_AND_NULL(pDevHandle);
return (nRetVal);
}
pDevHandle->nAltInterface = pInterfaceProp.nAltIF;
xnLogVerbose(XN_MASK_USB, "USB Driver Current Alt Setting is: %d", pDevHandle->nAltInterface);
// All is good...
return (XN_STATUS_OK);
}
