XnStatus ClientUSBInDataEndpoint::Init(XN_USB_DEV_HANDLE hUSBDevice, XnUInt16 nEndpointID) { XN_VALIDATE_INPUT_PTR(hUSBDevice); XnStatus nRetVal = XN_STATUS_OK; m_hUSBDevice = hUSBDevice; m_nEndpointID = BASE_INPUT_ENDPOINT + nEndpointID; m_endpointType = XN_USB_EP_ISOCHRONOUS; nRetVal = xnUSBOpenEndPoint(m_hUSBDevice, m_nEndpointID, m_endpointType, XN_USB_DIRECTION_IN, &m_hEndpoint); if (nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_TYPE) { m_endpointType = XN_USB_EP_BULK; nRetVal = xnUSBOpenEndPoint(m_hUSBDevice, m_nEndpointID, m_endpointType, XN_USB_DIRECTION_IN, &m_hEndpoint); } XN_IS_STATUS_OK_LOG_ERROR("Open USB endpoint", nRetVal); XnUInt32 nTempMaxPacketSize = 0; nRetVal = xnUSBGetEndPointMaxPacketSize(m_hEndpoint, &nTempMaxPacketSize); XN_IS_STATUS_OK_LOG_ERROR("Get USB endpoint max packet size", nRetVal); if (nTempMaxPacketSize > XN_MAX_UINT16) { xnLogError(XN_MASK_USB, "Max packet size received is larger than max uint16 value?!"); XN_ASSERT(FALSE); return XN_STATUS_ERROR; } m_nMaxPacketSize = static_cast<XnUInt16>(nTempMaxPacketSize); return XN_STATUS_OK; }
XnStatus XnSensorIO::OpenDevice(const XnChar* strPath) { XnStatus nRetVal; XnUSBDeviceSpeed DevSpeed; nRetVal = xnUSBInit(); if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_USB_ALREADY_INIT) return nRetVal; xnLogVerbose(XN_MASK_DEVICE_IO, "Connecting to USB device..."); if (strPath == NULL || strcmp(strPath, "*:0") == 0) { // support old style API XnConnectionString aConnections[1]; XnUInt32 nCount = 1; nRetVal = EnumerateSensors(aConnections, &nCount); if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_OUTPUT_BUFFER_OVERFLOW) { return nRetVal; } strPath = aConnections[0]; } // try to open the device xnLogVerbose(XN_MASK_DEVICE_IO, "Trying to open sensor '%s'...", strPath); nRetVal = xnUSBOpenDeviceByPath(strPath, &m_pSensorHandle->USBDevice); XN_IS_STATUS_OK(nRetVal); nRetVal = xnUSBGetDeviceSpeed(m_pSensorHandle->USBDevice, &DevSpeed); XN_IS_STATUS_OK(nRetVal); if (DevSpeed != XN_USB_DEVICE_HIGH_SPEED) { XN_LOG_WARNING_RETURN(XN_STATUS_USB_UNKNOWN_DEVICE_SPEED, XN_MASK_DEVICE_IO, "Device is not high speed!"); } // on older firmwares, control was sent over BULK endpoints. Check if this is the case xnLogVerbose(XN_MASK_DEVICE_IO, "Trying to open endpoint 0x4 for control out (for old firmwares)..."); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x4, XN_USB_EP_BULK, XN_USB_DIRECTION_OUT, &m_pSensorHandle->ControlConnection.ControlOutConnectionEp); if (nRetVal == XN_STATUS_USB_ENDPOINT_NOT_FOUND || nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_TYPE || nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_DIRECTION) { // this is not the case. use regular control endpoint (0) m_pSensorHandle->ControlConnection.bIsBulk = FALSE; } else { XN_IS_STATUS_OK(nRetVal); xnLogVerbose(XN_MASK_DEVICE_IO, "Opening endpoint 0x85 for control in..."); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x85, XN_USB_EP_BULK, XN_USB_DIRECTION_IN, &m_pSensorHandle->ControlConnection.ControlInConnectionEp); XN_IS_STATUS_OK(nRetVal); m_pSensorHandle->ControlConnection.bIsBulk = TRUE; } nRetVal = IsSensorLowBandwidth(strPath, &m_bIsLowBandwidth); XN_IS_STATUS_OK(nRetVal); xnLogInfo(XN_MASK_DEVICE_IO, "Connected to USB device%s", m_bIsLowBandwidth ? " (LowBand)" : ""); strcpy(m_strDeviceName, strPath); return XN_STATUS_OK; }
XnStatus XnSensorIO::OpenDataEndPoints(XnSensorUsbInterface nInterface, const XnFirmwareInfo& fwInfo) { XnStatus nRetVal = XN_STATUS_OK; // --avin mod-- /* // try to set requested interface if (nInterface != XN_SENSOR_USB_INTERFACE_DEFAULT) { XnUInt8 nAlternativeInterface = 0; switch (nInterface) { case XN_SENSOR_USB_INTERFACE_ISO_ENDPOINTS: nAlternativeInterface = fwInfo.nISOAlternativeInterface; break; case XN_SENSOR_USB_INTERFACE_BULK_ENDPOINTS: nAlternativeInterface = fwInfo.nBulkAlternativeInterface; break; default: XN_ASSERT(FALSE); XN_LOG_WARNING_RETURN(XN_STATUS_USB_INTERFACE_NOT_SUPPORTED, XN_MASK_DEVICE_IO, "Unknown interface type: %d", nInterface); } xnLogVerbose(XN_MASK_DEVICE_IO, "Setting USB alternative interface to %d...", nAlternativeInterface); nRetVal = xnUSBSetInterface(m_pSensorHandle->USBDevice, 0, nAlternativeInterface); XN_IS_STATUS_OK(nRetVal); } */ xnLogVerbose(XN_MASK_DEVICE_IO, "Opening endpoints..."); // up until v3.0/4.0, Image went over 0x82, depth on 0x83, audio on 0x86, and control was using bulk EPs, at 0x4 and 0x85. // starting v3.0/4.0, Image is at 0x81, depth at 0x82, audio/misc at 0x83, and control is using actual control EPs. // This means we are using the new Jungo USB Code XnBool bNewUSB = TRUE; // Depth // --avin mod-- m_pSensorHandle->DepthConnection.bIsISO = TRUE; bNewUSB = TRUE; xnLogVerbose(XN_MASK_DEVICE_IO, "Opening endpoint 0x81 for depth..."); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x81, XN_USB_EP_ISOCHRONOUS, XN_USB_DIRECTION_IN, &m_pSensorHandle->DepthConnection.UsbEp); if (nRetVal == XN_STATUS_USB_ENDPOINT_NOT_FOUND) { nRetVal = xnUSBSetInterface(m_pSensorHandle->USBDevice, 0, 1); XN_IS_STATUS_OK(nRetVal); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x81, XN_USB_EP_ISOCHRONOUS, XN_USB_DIRECTION_IN, &m_pSensorHandle->DepthConnection.UsbEp); XN_IS_STATUS_OK(nRetVal); } xnLogVerbose(XN_MASK_DEVICE_IO, "Depth endpoint is isochronous."); m_pSensorHandle->DepthConnection.bIsOpen = TRUE; nRetVal = xnUSBGetEndPointMaxPacketSize(m_pSensorHandle->DepthConnection.UsbEp, &m_pSensorHandle->DepthConnection.nMaxPacketSize); XN_IS_STATUS_OK(nRetVal); // check this matches requested interface (unless DEFAULT was requested) if (nInterface == XN_SENSOR_USB_INTERFACE_BULK_ENDPOINTS && m_pSensorHandle->DepthConnection.bIsISO || nInterface == XN_SENSOR_USB_INTERFACE_ISO_ENDPOINTS && !m_pSensorHandle->DepthConnection.bIsISO) { return (XN_STATUS_USB_INTERFACE_NOT_SUPPORTED); } m_interface = m_pSensorHandle->DepthConnection.bIsISO ? XN_SENSOR_USB_INTERFACE_ISO_ENDPOINTS : XN_SENSOR_USB_INTERFACE_BULK_ENDPOINTS; // Image XnUInt16 nImageEP = bNewUSB ? 0x82 : 0x83; m_pSensorHandle->ImageConnection.bIsISO = FALSE; xnLogVerbose(XN_MASK_DEVICE_IO, "Opening endpoint 0x%hx for image...", nImageEP); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, nImageEP, XN_USB_EP_BULK, XN_USB_DIRECTION_IN, &m_pSensorHandle->ImageConnection.UsbEp); if (nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_TYPE) { nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, nImageEP, XN_USB_EP_ISOCHRONOUS, XN_USB_DIRECTION_IN, &m_pSensorHandle->ImageConnection.UsbEp); m_pSensorHandle->ImageConnection.bIsISO = TRUE; } XN_IS_STATUS_OK(nRetVal); if (m_pSensorHandle->ImageConnection.bIsISO == TRUE) { xnLogVerbose(XN_MASK_DEVICE_IO, "Image endpoint is isochronous."); } else { xnLogVerbose(XN_MASK_DEVICE_IO, "Image endpoint is bulk."); } m_pSensorHandle->ImageConnection.bIsOpen = TRUE; nRetVal = xnUSBGetEndPointMaxPacketSize(m_pSensorHandle->ImageConnection.UsbEp, &m_pSensorHandle->ImageConnection.nMaxPacketSize); XN_IS_STATUS_OK(nRetVal); // Misc XnUInt16 nMiscEP = bNewUSB ? 0x83 : 0x86; m_pSensorHandle->MiscConnection.bIsISO = FALSE; xnLogVerbose(XN_MASK_DEVICE_IO, "Opening endpoint 0x%hx for misc...", nMiscEP); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, nMiscEP, XN_USB_EP_BULK, XN_USB_DIRECTION_IN, &m_pSensorHandle->MiscConnection.UsbEp); if (nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_TYPE) { nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, nMiscEP, XN_USB_EP_ISOCHRONOUS, XN_USB_DIRECTION_IN, &m_pSensorHandle->MiscConnection.UsbEp); m_pSensorHandle->MiscConnection.bIsISO = TRUE; } if (nRetVal == XN_STATUS_USB_ENDPOINT_NOT_FOUND) { // Firmware does not support misc... m_pSensorHandle->MiscConnection.bIsOpen = FALSE; m_bMiscSupported = FALSE; xnLogVerbose(XN_MASK_DEVICE_IO, "Misc endpoint is not supported..."); } else if (nRetVal == XN_STATUS_OK) { m_pSensorHandle->MiscConnection.bIsOpen = TRUE; m_bMiscSupported = TRUE; if (m_pSensorHandle->MiscConnection.bIsISO == TRUE) { xnLogVerbose(XN_MASK_DEVICE_IO, "Misc endpoint is isochronous."); } else { xnLogVerbose(XN_MASK_DEVICE_IO, "Misc endpoint is bulk."); } } else { return nRetVal; } if (m_pSensorHandle->MiscConnection.bIsOpen) { nRetVal = xnUSBGetEndPointMaxPacketSize(m_pSensorHandle->MiscConnection.UsbEp, &m_pSensorHandle->MiscConnection.nMaxPacketSize); XN_IS_STATUS_OK(nRetVal); } xnLogInfo(XN_MASK_DEVICE_IO, "Endpoints open"); // All is good... return (XN_STATUS_OK); }
XnStatus XnSensorIO::OpenDevice(const XnChar* strPath, XnBool bLeanInit) { XnStatus nRetVal; XnUSBDeviceSpeed DevSpeed; xnLogVerbose(XN_MASK_DEVICE_IO, "Connecting to USB device..."); // try to open the device xnLogVerbose(XN_MASK_DEVICE_IO, "Trying to open sensor '%s'...", strPath); nRetVal = xnUSBOpenDeviceByPath(strPath, &m_pSensorHandle->USBDevice); XN_IS_STATUS_OK(nRetVal); if (!bLeanInit) { nRetVal = xnUSBGetDeviceSpeed(m_pSensorHandle->USBDevice, &DevSpeed); XN_IS_STATUS_OK(nRetVal); if (DevSpeed != XN_USB_DEVICE_HIGH_SPEED) { XN_LOG_WARNING_RETURN(XN_STATUS_USB_UNKNOWN_DEVICE_SPEED, XN_MASK_DEVICE_IO, "Device is not high speed!"); } } // on older firmwares, control was sent over BULK endpoints. Check if this is the case xnLogVerbose(XN_MASK_DEVICE_IO, "Trying to open endpoint 0x4 for control out (for old firmwares)..."); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x4, XN_USB_EP_BULK, XN_USB_DIRECTION_OUT, &m_pSensorHandle->ControlConnection.ControlOutConnectionEp); if (nRetVal == XN_STATUS_USB_ENDPOINT_NOT_FOUND || nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_TYPE || nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_DIRECTION) { // this is not the case. use regular control endpoint (0) m_pSensorHandle->ControlConnection.bIsBulk = FALSE; } else { XN_IS_STATUS_OK(nRetVal); xnLogVerbose(XN_MASK_DEVICE_IO, "Opening endpoint 0x85 for control in..."); nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x85, XN_USB_EP_BULK, XN_USB_DIRECTION_IN, &m_pSensorHandle->ControlConnection.ControlInConnectionEp); XN_IS_STATUS_OK(nRetVal); m_pSensorHandle->ControlConnection.bIsBulk = TRUE; } nRetVal = XnDeviceEnumeration::IsSensorLowBandwidth(strPath, &m_bIsLowBandwidth); XN_IS_STATUS_OK(nRetVal); xnLogInfo(XN_MASK_DEVICE_IO, "Connected to USB device%s", m_bIsLowBandwidth ? " (LowBand)" : ""); // check if we're currently on BULK interfaces or ISO ones XN_USB_EP_HANDLE hEP; nRetVal = xnUSBOpenEndPoint(m_pSensorHandle->USBDevice, 0x82, XN_USB_EP_BULK, XN_USB_DIRECTION_IN, &hEP); if (nRetVal == XN_STATUS_USB_WRONG_ENDPOINT_TYPE) { m_interface = XN_SENSOR_USB_INTERFACE_ISO_ENDPOINTS; } else { m_interface = XN_SENSOR_USB_INTERFACE_BULK_ENDPOINTS; xnUSBCloseEndPoint(hEP); } strcpy(m_strDeviceName, strPath); return XN_STATUS_OK; }