XnStatus DepthPanasonic::Init() { // Aloca o mapa de profundidade m_pDepthMap = new XnDepthPixel[SUPPORTED_X_RES * SUPPORTED_Y_RES]; if (m_pDepthMap == NULL) { return XN_STATUS_ALLOC_FAILED; } // Inicializa a câmera if (InitImageDriver() != 0) { return XN_STATUS_DEVICE_NOT_CONNECTED; } // Define a taxa de captura if (Speedmode () != SUPPORTED_FPS){ ChangeSpeed (SUPPORTED_FPS); } // Define a frequência da luz (evitar interferênia com outras) if (Freqmode () != 1){ ChangeFreq (1); } // Acorda a câmera if (Sleepmode () == 0){ ChangeSleep (1); } // Aloca memória para os vetores retornados pela câmera (160*120*2 bytes = 38400 bytes) kdat = (unsigned short*) malloc(38400); ndat = (unsigned short*) malloc(38400); // Inicialização das matrizes que convertem os valores de profundidade para mm (e vice versa) XN_VALIDATE_INPUT_PTR(&m_ShiftToDepthTables); XN_VALIDATE_INPUT_PTR(&m_s2dConfig); XN_VALIDATE_ALIGNED_CALLOC(m_ShiftToDepthTables.pShiftToDepthTable, XnDepthPixel, m_s2dConfig.nDeviceMaxShiftValue+1, XN_DEFAULT_MEM_ALIGN); XN_VALIDATE_ALIGNED_CALLOC(m_ShiftToDepthTables.pDepthToShiftTable, XnUInt16, m_s2dConfig.nDeviceMaxDepthValue+1, XN_DEFAULT_MEM_ALIGN); m_ShiftToDepthTables.bIsInitialized = TRUE; // store allocation sizes m_ShiftToDepthTables.nShiftsCount = m_s2dConfig.nDeviceMaxShiftValue + 1; m_ShiftToDepthTables.nDepthsCount = m_s2dConfig.nDeviceMaxDepthValue + 1; // Gera a matriz XnShiftToDepthUpdate(&m_ShiftToDepthTables, &m_s2dConfig); return (XN_STATUS_OK); }
//--------------------------------------------------------------------------- // Code //--------------------------------------------------------------------------- XN_DDK_API XnStatus XnShiftToDepthInit(XnShiftToDepthTables* pShiftToDepth, const XnShiftToDepthConfig* pConfig) { XN_VALIDATE_INPUT_PTR(pShiftToDepth); XN_VALIDATE_INPUT_PTR(pConfig); XN_VALIDATE_ALIGNED_CALLOC(pShiftToDepth->pShiftToDepthTable, XnDepthPixel, pConfig->nDeviceMaxShiftValue+1, XN_DEFAULT_MEM_ALIGN); XN_VALIDATE_ALIGNED_CALLOC(pShiftToDepth->pDepthToShiftTable, XnUInt16, pConfig->nDeviceMaxDepthValue+1, XN_DEFAULT_MEM_ALIGN); pShiftToDepth->bIsInitialized = TRUE; // store allocation sizes pShiftToDepth->nShiftsCount = pConfig->nDeviceMaxShiftValue + 1; pShiftToDepth->nDepthsCount = pConfig->nDeviceMaxDepthValue + 1; return XnShiftToDepthUpdate(pShiftToDepth, pConfig); }
XN_C_API XnStatus xnOSAcceptSocket(XN_SOCKET_HANDLE ListenSocket, XN_SOCKET_HANDLE* AcceptSocketPtr, XnUInt32 nMillisecondsTimeout) { // Local function variables XnInt32 nRetVal = 0; struct timeval selectTimeOut; struct timeval* pTimeout = xnOSMillisecsToTimeVal(nMillisecondsTimeout, &selectTimeOut); fd_set fdReadHandles; XN_SOCKET_HANDLE AcceptSocket = NULL; // Validate the input/output pointers (to make sure none of them is NULL) XN_VALIDATE_INPUT_PTR(ListenSocket); XN_VALIDATE_OUTPUT_PTR(AcceptSocketPtr); // Make sure the actual socket handle isn't NULL XN_RET_IF_NULL(ListenSocket->Socket, XN_STATUS_OS_INVALID_SOCKET); // Wait for connection request XN_PRAGMA_START_DISABLED_WARNING_SECTION(XN_CONDITION_IS_CONST_WARNING_ID); FD_ZERO(&fdReadHandles); FD_SET(ListenSocket->Socket, &fdReadHandles); XN_PRAGMA_STOP_DISABLED_WARNING_SECTION; nRetVal = select(1 /* ignored */, &fdReadHandles, NULL, NULL, pTimeout); if (nRetVal == 0) { return (XN_STATUS_OS_NETWORK_TIMEOUT); } else if (nRetVal == SOCKET_ERROR) { XN_LOG_ERROR_RETURN(XN_STATUS_OS_NETWORK_SOCKET_ACCEPT_FAILED, XN_MASK_OS, "select() returned WinSock error: %d", WSAGetLastError()); } // Allocate a new socket XN_VALIDATE_ALIGNED_CALLOC(*AcceptSocketPtr, xnOSSocket, 1, XN_DEFAULT_MEM_ALIGN); AcceptSocket = *AcceptSocketPtr; // Accept the socket and make sure it succeeded AcceptSocket->nSocketAddressLen = sizeof(AcceptSocket->SocketAddress); AcceptSocket->Socket = accept(ListenSocket->Socket, (sockaddr*)&AcceptSocket->SocketAddress, &AcceptSocket->nSocketAddressLen); if (AcceptSocket->Socket == INVALID_SOCKET) { xnOSCloseSocket(AcceptSocket); xnOSFreeAligned(*AcceptSocketPtr); return(XN_STATUS_OS_NETWORK_SOCKET_ACCEPT_FAILED); } // All is good... return (XN_STATUS_OK); }
//--------------------------------------------------------------------------- // Code //--------------------------------------------------------------------------- XnStatus xnFPSInit(XnFPSData* pFPS, XnUInt32 nSamplesCount) { XN_VALIDATE_OUTPUT_PTR(pFPS); // Allocate struct XN_VALIDATE_CALLOC(*pFPS, XnFPSDataImpl, 1); XnFPSDataImpl* pData = *pFPS; // Allocate array XN_VALIDATE_ALIGNED_CALLOC(pData->anTimes, XnUInt64, nSamplesCount, XN_DEFAULT_MEM_ALIGN); pData->nArraySize = nSamplesCount; return XN_STATUS_OK; }
//--------------------------------------------------------------------------- // Code //--------------------------------------------------------------------------- XnStatus xnFPSInit(XnFPSData* pFPS, XnUInt32 nSamplesCount) { XN_VALIDATE_OUTPUT_PTR(pFPS); // make sure xnOS is init XnStatus nRetVal = xnOSInit(); if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_OS_ALREADY_INIT) return nRetVal; // Allocate struct XN_VALIDATE_CALLOC(*pFPS, XnFPSDataImpl, 1); XnFPSDataImpl* pData = *pFPS; // Allocate array XN_VALIDATE_ALIGNED_CALLOC(pData->anTimes, XnUInt64, nSamplesCount, XN_DEFAULT_MEM_ALIGN); pData->nArraySize = nSamplesCount; 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 XnFileDevice::BCReadInitialState(XnPropertySet* pSet) { // Local function variables XnStatus nRetVal = XN_STATUS_OK; XnDeviceFileHeader DeviceFileHeader; XN_STREAM_FLAGS_TYPE nStreamFlags = 0; m_pBCData->nFramePos = 1; xnOSFreeAligned(m_pBCData->pPackedStreamBuffer); m_pBCData->pPackedStreamBuffer = NULL; m_pBCData->nPackedStreamBufferSize = 0; // read StreamProperties if (m_nFileVersion == 3) { // Current Version nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.nMajorVersion, sizeof(XnUInt16)); XN_IS_STATUS_OK(nRetVal); nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.nMinorVersion, sizeof(XnUInt16)); XN_IS_STATUS_OK(nRetVal); nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.StreamProperties, sizeof(XnStreamPropertiesV3)); XN_IS_STATUS_OK(nRetVal); DeviceFileHeader.nMajorVersion = XN_PREPARE_VAR16_IN_BUFFER(DeviceFileHeader.nMajorVersion); DeviceFileHeader.nMinorVersion = XN_PREPARE_VAR16_IN_BUFFER(DeviceFileHeader.nMinorVersion); nRetVal = XnIOAdjustStreamPropertiesV3(&DeviceFileHeader.StreamProperties, &DeviceFileHeader.StreamProperties); XN_IS_STATUS_OK(nRetVal); } else if (m_nFileVersion == 2) { // Version 2 DeviceFileHeader.nMajorVersion = 0; DeviceFileHeader.nMinorVersion = 0; XnStreamPropertiesV2 StreamPropertiesV2; nRetVal = m_pInputStream->ReadData((XnUChar*)&StreamPropertiesV2, sizeof(XnStreamPropertiesV2)); XN_IS_STATUS_OK(nRetVal); nRetVal = XnIOAdjustStreamPropertiesV2(&StreamPropertiesV2, &DeviceFileHeader.StreamProperties); XN_IS_STATUS_OK(nRetVal); } else if (m_nFileVersion == 1) { // Version 1 DeviceFileHeader.nMajorVersion = 0; DeviceFileHeader.nMinorVersion = 0; XnStreamPropertiesV1 StreamPropertiesV1; nRetVal = m_pInputStream->ReadData((XnUChar*)&StreamPropertiesV1, sizeof(XnStreamPropertiesV1)); XN_IS_STATUS_OK(nRetVal); nRetVal = XnIOAdjustStreamPropertiesV1(&StreamPropertiesV1, &DeviceFileHeader.StreamProperties); XN_IS_STATUS_OK(nRetVal); } else { // Bad Magic return XN_STATUS_IO_INVALID_STREAM_HEADER; } // read packed stream properties switch (m_nFileVersion) { case 3: { nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.PackedStreamProperties, sizeof(XnPackedStreamProperties)); XN_IS_STATUS_OK(nRetVal); nRetVal = XnIOAdjustPackedStreamPropertiesV3(&DeviceFileHeader.PackedStreamProperties, &DeviceFileHeader.PackedStreamProperties); XN_IS_STATUS_OK(nRetVal); } break; case 2: { XnPackedStreamPropertiesV2 PackedStreamPropertiesV2; nRetVal = m_pInputStream->ReadData((XnUChar*)&PackedStreamPropertiesV2, sizeof(XnPackedStreamPropertiesV2)); XN_IS_STATUS_OK(nRetVal); nRetVal = XnIOAdjustPackedStreamPropertiesV2(&PackedStreamPropertiesV2, &DeviceFileHeader.PackedStreamProperties); XN_IS_STATUS_OK(nRetVal); } break; case 1: { XnPackedStreamPropertiesV1 PackedStreamPropertiesV1; nRetVal = m_pInputStream->ReadData((XnUChar*)&PackedStreamPropertiesV1, sizeof(XnPackedStreamPropertiesV1)); XN_IS_STATUS_OK(nRetVal); nRetVal = XnIOAdjustPackedStreamPropertiesV1(&PackedStreamPropertiesV1, &DeviceFileHeader.PackedStreamProperties); XN_IS_STATUS_OK(nRetVal); } break; default: return XN_STATUS_IO_INVALID_STREAM_HEADER; } // Save the stream properties into the private data (but keep the original stream flags) nStreamFlags = m_pBCData->StreamProperties.nStreamFlags; xnOSMemCopy(&m_pBCData->StreamProperties, &DeviceFileHeader.StreamProperties, sizeof(XnStreamProperties)); m_pBCData->StreamProperties.nStreamFlags = nStreamFlags; if (m_pBCData->StreamProperties.Shift2DepthData.bShift2DepthData) { m_pBCData->StreamProperties.Shift2DepthData.nMaxDepthValue = 10000; m_pBCData->StreamProperties.nDepthMaxValue = 10000; } // Save the packed stream properties into the private data xnOSMemCopy(&m_pBCData->PackedStreamProperties, &DeviceFileHeader.PackedStreamProperties, sizeof(XnPackedStreamProperties)); XnUInt32 nBufferSize = BCCalculatePackedBufferSize(); if (nBufferSize != m_pBCData->nPackedStreamBufferSize) { xnOSFreeAligned(m_pBCData->pPackedStreamBuffer); XN_VALIDATE_ALIGNED_CALLOC(m_pBCData->pPackedStreamBuffer, XnUChar, nBufferSize, XN_DEFAULT_MEM_ALIGN); m_pBCData->nPackedStreamBufferSize = nBufferSize; } nRetVal = ConvertStreamPropertiesToPropertySet(&m_pBCData->StreamProperties, &m_pBCData->PackedStreamProperties, pSet); XN_IS_STATUS_OK(nRetVal); // 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); }