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); }