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