void XnSensorGenerator::UnregisterFromNewDataAvailable(XnCallbackHandle hCallback)
{
NewDataCallback *pNewDataCallback = (NewDataCallback*)hCallback;
m_pSensor->UnregisterFromNewStreamData(pNewDataCallback->m_hCallback);
XN_DELETE(pNewDataCallback);
}
void destroyStream(oni::driver::StreamBase* pStream)
{
XN_DELETE(pStream);
}
void XnXmlScriptNodeExporter::Destroy(xn::ModuleProductionNode* pInstance)
{
xn::ModuleProductionNode* pNode = (xn::ModuleProductionNode*)pInstance;
XN_DELETE(pNode);
}
void XnCodecFactory::Destroy(XnCodec* pCodec)
{
XN_DELETE(pCodec);
}
UserTracker::UserTracker(int argc, char **argv, XnUInt64 timeSpanForExitPose) : m_bValid(FALSE),
m_timeSpanForExitPose(timeSpanForExitPose),
m_pExitPoseDetector(NULL)
{
m_bRecord=FALSE;
XnStatus nRetVal = XN_STATUS_OK;
XnBool OpenedRecording=FALSE;
if(argc>1)
{
for(int i=1; i<argc-1; i++)
{
if(xnOSStrCmp(argv[i],"-RecordingFilename")==0)
{
// initialize the context from scratch
nRetVal = m_Context.Init();
CHECK_RC(nRetVal, "Context Initialization");
// try to open the recording as the source for sensor data
nRetVal = m_Context.OpenFileRecording(argv[i+1], m_Player);
CHECK_RC(nRetVal, "Couldn't open recording with command line argument");
OpenedRecording=TRUE;
break; // we only support one recording at a time..
}
}
}
if(OpenedRecording==FALSE)
{
xn::EnumerationErrors errors;
nRetVal = m_Context.InitFromXmlFile(SAMPLE_XML_PATH, m_ScriptNode, &errors);
if (nRetVal == XN_STATUS_NO_NODE_PRESENT)
{
XnChar strError[1024];
errors.ToString(strError, 1024);
printf("%s\n", strError);
return;
}
CHECK_RC(nRetVal, "Open XML failed");
}
nRetVal = m_Context.FindExistingNode(XN_NODE_TYPE_DEPTH, m_DepthGenerator);
if (nRetVal != XN_STATUS_OK)
{
printf("No depth generator found. Using a default one...");
xn::MockDepthGenerator mockDepth;
nRetVal = mockDepth.Create(m_Context);
CHECK_RC(nRetVal, "Create mock depth");
// set some defaults
XnMapOutputMode defaultMode;
defaultMode.nXRes = 320;
defaultMode.nYRes = 240;
defaultMode.nFPS = 30;
nRetVal = mockDepth.SetMapOutputMode(defaultMode);
CHECK_RC(nRetVal, "set default mode");
// set FOV
XnFieldOfView fov;
fov.fHFOV = 1.0225999419141749;
fov.fVFOV = 0.79661567681716894;
nRetVal = mockDepth.SetGeneralProperty(XN_PROP_FIELD_OF_VIEW, sizeof(fov), &fov);
CHECK_RC(nRetVal, "set FOV");
XnUInt32 nDataSize = defaultMode.nXRes * defaultMode.nYRes * sizeof(XnDepthPixel);
XnDepthPixel* pData = (XnDepthPixel*)xnOSCallocAligned(nDataSize, 1, XN_DEFAULT_MEM_ALIGN);
nRetVal = mockDepth.SetData(1, 0, nDataSize, pData);
CHECK_RC(nRetVal, "set empty depth map");
m_DepthGenerator = mockDepth;
}
nRetVal = m_Context.FindExistingNode(XN_NODE_TYPE_USER, m_UserGenerator);
if (nRetVal != XN_STATUS_OK)
{
nRetVal = m_UserGenerator.Create(m_Context);
CHECK_RC(nRetVal, "Find user generator");
}
if (!m_UserGenerator.IsCapabilitySupported(XN_CAPABILITY_SKELETON))
{
printf("Supplied user generator doesn't support skeleton\n");
return;
}
m_UserGenerator.GetSkeletonCap().SetSkeletonProfile(XN_SKEL_PROFILE_ALL);
nRetVal = m_Context.StartGeneratingAll();
CHECK_RC(nRetVal, "StartGenerating");
m_pExitPoseDetector=XN_NEW(ExitPoseDetector,m_UserGenerator);
if(!(m_pExitPoseDetector->Valid()))
{
printf("Exit pose is not supported by user node. Therefore will continue to run without support for exit pose\n");
XN_DELETE(m_pExitPoseDetector);
m_pExitPoseDetector=NULL;
}
m_bValid=TRUE;
}
void XnOniDevice::destroyStream(oni::driver::StreamBase* pStream)
{
XN_DELETE(pStream);
}
XnStatus PS1200Device::UsbTest(XnUInt32 nSeconds, XnUInt32& endpointsCount, XnUsbTestEndpointResult* endpoints)
{
XnStatus nRetVal = XN_STATUS_OK;
xn::ClientUSBConnectionFactory* pConnFactory = GetConnectionFactory();
if (m_linkInputStreamsMgr.HasStreams())
{
xnLogWarning(XN_MASK_PS1200_DEVICE, "Can't start USB test when other streams exists!");
return XN_STATUS_ERROR;
}
XnUInt16 nNumEndpoints = pConnFactory->GetNumInputDataConnections();
if (nNumEndpoints > endpointsCount)
{
xnLogWarning(XN_MASK_PS1200_DEVICE, "Endpoints array is too small");
return XN_STATUS_BAD_PARAM;
}
xn::IAsyncInputConnection* aEndpoints[20];
UsbEndpointTester aTesters[20];
for (int i = 0; i < nNumEndpoints; ++i)
{
nRetVal = pConnFactory->CreateInputDataConnection((XnUInt16)i, aEndpoints[i]);
if (nRetVal != XN_STATUS_OK)
{
for (int j = 0; j < i; ++j)
{
XN_DELETE(aEndpoints[j]);
}
return nRetVal;
}
aTesters[i].Reset();
aTesters[i].m_nEP = i;
aEndpoints[i]->SetDataDestination(&aTesters[i]);
aEndpoints[i]->Connect();
}
nRetVal = m_linkControlEndpoint.StartUsbTest();
if (nRetVal != XN_STATUS_OK)
{
for (int i = 0; i < nNumEndpoints; ++i)
{
XN_DELETE(aEndpoints[i]);
}
return nRetVal;
}
// let the test run
xnOSSleep(nSeconds*1000);
nRetVal = m_linkControlEndpoint.StopUsbTest();
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_PS1200_DEVICE, "Failed to stop USB test!");
XN_ASSERT(FALSE);
}
for (int i = 0; i < nNumEndpoints; ++i)
{
XN_DELETE(aEndpoints[i]);
endpoints[i].averageBytesPerSecond = aTesters[i].m_nTotalBytes / (XnDouble)nSeconds;
endpoints[i].lostPackets = aTesters[i].m_nLostPackets;
}
endpointsCount = nNumEndpoints;
return (XN_STATUS_OK);
}
void XnStreamReaderDevice::DestroyStreamModule(XnDeviceModuleHolder* pStreamHolder)
{
XN_DELETE(pStreamHolder->GetModule());
XN_DELETE(pStreamHolder);
}
void XnExportedSensorGenerator::Destroy(xn::ModuleProductionNode* pInstance)
{
XnSensorGenerator* pGenerator = dynamic_cast<XnSensorGenerator*>(pInstance);
pGenerator->GetSensor()->DestroyStream(pGenerator->GetModuleName());
XN_DELETE(pGenerator);
}
XnStatus XnStreamDeviceStreamHolder::ChooseCodec()
{
XnStatus nRetVal = XN_STATUS_OK;
// create new codec (we also need to register on all the properties)
XnCodec* pCodec;
XnPropertiesList CodecProps;
switch (GetCompression())
{
case XN_COMPRESSION_NONE:
{
XN_VALIDATE_NEW_AND_INIT(pCodec, XnUncompressedCodec);
}
break;
case XN_COMPRESSION_16Z:
{
XN_VALIDATE_NEW_AND_INIT(pCodec, Xn16zCodec);
}
break;
case XN_COMPRESSION_16Z_EMB_TABLE:
{
// first we need to find max depth
XnIntProperty* pDeviceMaxDepthProp;
nRetVal = GetStream()->GetProperty(XN_STREAM_PROPERTY_DEVICE_MAX_DEPTH, &pDeviceMaxDepthProp);
XN_IS_STATUS_OK(nRetVal);
XnUInt64 nMaxDepth;
nRetVal = pDeviceMaxDepthProp->GetValue(&nMaxDepth);
XN_IS_STATUS_OK(nRetVal);
nRetVal = CodecProps.AddLast(pDeviceMaxDepthProp);
XN_IS_STATUS_OK(nRetVal);
XN_VALIDATE_NEW_AND_INIT(pCodec, Xn16zEmbTablesCodec, (XnDepthPixel)nMaxDepth);
}
break;
case XN_COMPRESSION_COLOR_8Z:
{
XN_VALIDATE_NEW_AND_INIT(pCodec, Xn8zCodec);
}
break;
case XN_COMPRESSION_JPEG:
{
// check what is the output format
XnIntProperty* pOutputFormatProp;
nRetVal = GetStream()->GetProperty(XN_STREAM_PROPERTY_OUTPUT_FORMAT, &pOutputFormatProp);
XN_IS_STATUS_OK(nRetVal);
XnUInt64 nOutputFormat;
nRetVal = pOutputFormatProp->GetValue(&nOutputFormat);
XN_IS_STATUS_OK(nRetVal);
XnBool bRGB = FALSE;
switch (nOutputFormat)
{
case XN_OUTPUT_FORMAT_GRAYSCALE8:
bRGB = FALSE;
break;
case XN_OUTPUT_FORMAT_RGB24:
bRGB = TRUE;
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Codec factory currently supports JPEG codec only for streams of type Gray8 or RGB24!");
}
nRetVal = CodecProps.AddLast(pOutputFormatProp);
XN_IS_STATUS_OK(nRetVal);
// X res
XnIntProperty* pXResProp;
nRetVal = GetStream()->GetProperty(XN_STREAM_PROPERTY_X_RES, &pXResProp);
XN_IS_STATUS_OK(nRetVal);
XnUInt64 nXRes;
nRetVal = pXResProp->GetValue(&nXRes);
XN_IS_STATUS_OK(nRetVal);
nRetVal = CodecProps.AddLast(pXResProp);
XN_IS_STATUS_OK(nRetVal);
// Y res
XnIntProperty* pYResProp;
nRetVal = GetStream()->GetProperty(XN_STREAM_PROPERTY_Y_RES, &pYResProp);
XN_IS_STATUS_OK(nRetVal);
XnUInt64 nYRes;
nRetVal = pYResProp->GetValue(&nYRes);
XN_IS_STATUS_OK(nRetVal);
// Cropping
XnGeneralProperty* pCroppingProp;
nRetVal = GetStream()->GetProperty(XN_STREAM_PROPERTY_CROPPING, &pCroppingProp);
XN_IS_STATUS_OK(nRetVal);
XnCropping cropping;
nRetVal = pCroppingProp->GetValue(XN_PACK_GENERAL_BUFFER(cropping));
XN_IS_STATUS_OK(nRetVal);
nRetVal = CodecProps.AddLast(pCroppingProp);
XN_IS_STATUS_OK(nRetVal);
// calc x,y
if (cropping.bEnabled)
{
nXRes = cropping.nXSize;
nYRes = cropping.nYSize;
}
XN_VALIDATE_NEW_AND_INIT(pCodec, XnJpegCodec, bRGB, (XnUInt32)nXRes, (XnUInt32)nYRes);
}
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Codec factory does not support compression type %d", GetCompression());
}
// register to new props
for (XnPropertiesList::Iterator it = CodecProps.Begin(); it != CodecProps.End(); ++it)
{
XnProperty* pProp = *it;
XnPropertiesHash::Iterator hashIt = m_CodecProperties.End();
nRetVal = m_CodecProperties.Find(pProp, hashIt);
if (nRetVal == XN_STATUS_NO_MATCH)
{
XnCallbackHandle hCallbackDummy;
nRetVal = pProp->OnChangeEvent().Register(CodecPropertyChangedCallback, this, hCallbackDummy);
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pCodec);
return (nRetVal);
}
nRetVal = m_CodecProperties.Set(pProp, NULL);
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pCodec);
return (nRetVal);
}
}
else if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pCodec);
return (nRetVal);
}
}
// replace it
XN_DELETE(m_pCodec);
m_pCodec = pCodec;
return (XN_STATUS_OK);
}
/// @brief The main function of the sample
///
/// This is the main function of the sample. Its purpose is to be the starting point for the
/// sample and according to the command line arguments, to decide which sample behavior to use.
/// @ingroup UserSelectionMain
int main(int argc, char** argv)
{
SampleManager* pSampleManager=NULL; // will hold the sample manager which initializes and runs the sample
if(argc>1)
{
// check if the argument is asking for help...
if(xnOSStrCmp(argv[1],"--help")==0 ||
xnOSStrCmp(argv[1],"-help")==0 ||
xnOSStrCmp(argv[1],"/help")==0 ||
xnOSStrCmp(argv[1],"\\help")==0 ||
xnOSStrCmp(argv[1],"?")==0 ||
xnOSStrCmp(argv[1],"--?")==0 ||
xnOSStrCmp(argv[1],"-?")==0 ||
xnOSStrCmp(argv[1],"/?")==0 ||
xnOSStrCmp(argv[1],"\\?")==0)
{
UsageAndExit(argv[0]);
}
// go over the arguments and see if we have the '-s' switch. If so it means we
// are going to choose the selector type.
for(int i=1; i<argc-1; i++)
{
if(xnOSStrCmp(argv[i],"-s")==0)
{
if(xnOSStrCmp(argv[i+1],"ClosestSelector")==0)
{
// we are in the option '-s ClosestSelector N'.
if(argc<=i+2 || strlen(argv[i+2])>2)
{
UsageAndExit(argv[0]); // either there is no N at all or it is more than 1 digit
}
XnUInt32 n=argv[i+2][0]-'0'; // translate digit to number
pSampleManager=XN_NEW(ClosestSampleManager,n); // choose ClosestSelector with n
}
else if(xnOSStrCmp(argv[i+1],"SingleWave")==0)
{
// option is '-s SingleWave'
pSampleManager=XN_NEW(SingleWaveSampleManager);
}
else if(xnOSStrCmp(argv[i+1],"MultipleWave")==0)
{
// option is '-s SingleWave N'
if(argc<=i+2 || strlen(argv[i+2])>2)
{
UsageAndExit(argv[0]); // either there is no N at all or it is more than 1 digit
}
XnUInt32 n=argv[i+2][0]-'0'; // translate digit to number
pSampleManager=XN_NEW(MultipleWaveSampleManager,n);
}
else
{
// an illegal option was used...
UsageAndExit(argv[0]);
}
break; // we found the switch so we ignore all others
}
}
}
if(pSampleManager==NULL) // by default we use the closest detector option
{
//pSampleManager=XN_NEW(ClosestSampleManager,1); // choose the default.
pSampleManager=XN_NEW(SingleWaveSampleManager); // choose the default.
}
if(pSampleManager->StartSample(argc,argv)!=XN_STATUS_OK)
{
XN_DELETE(pSampleManager);
UsageAndExit(argv[0]); // The manager will only return if it fails to initialize...
}
}
void PlayerDevice::destroyStream(oni::driver::StreamBase* pStream)
{
m_streams.Remove((PlayerStream*)pStream);
XN_DELETE(pStream);
}
driver::StreamBase* PlayerDevice::createStream(OniSensorType sensorType)
{
// Find the requested source.
Lock();
PlayerSource* pSource = NULL;
for (SourceList::Iterator iter = m_sources.Begin(); iter != m_sources.End(); ++iter)
{
if ((*iter)->GetInfo()->sensorType == sensorType)
{
pSource = (*iter);
break;
}
}
Unlock();
// Check if source was found.
if (pSource == NULL)
{
return NULL;
}
// Create a new stream using the source.
PlayerStream* pStream = XN_NEW(PlayerStream, pSource);
if (pStream == NULL)
{
return NULL;
}
// Initialize the stream.
OniStatus rc = pStream->Initialize();
if (rc != ONI_STATUS_OK)
{
XN_DELETE(pStream);
return NULL;
}
Lock();
XnStatus xnrc = m_streams.AddLast(pStream);
if (xnrc != XN_STATUS_OK)
{
Unlock();
XN_DELETE(pStream);
return NULL;
}
// Register to ready for data event.
// NOTE: handle is discarded, as device will always exist longer than stream, therefore device can never unregister.
OniCallbackHandle handle;
rc = pStream->RegisterReadyForDataEvent(ReadyForDataCallback, this, handle);
if (rc != ONI_STATUS_OK)
{
m_streams.Remove(pStream);
Unlock();
XN_DELETE(pStream);
return NULL;
}
// Register to stream destroy event.
// NOTE: handle is discarded, as device will always exist longer than stream, therefore device can never unregister.
rc = pStream->RegisterDestroyEvent(StreamDestroyCallback, this, handle);
if (rc != ONI_STATUS_OK)
{
m_streams.Remove(pStream);
Unlock();
XN_DELETE(pStream);
return NULL;
}
Unlock();
return pStream;
}
XnStatus XnExportedSensorDevice::Create(xn::Context& context,
const XnChar* strInstanceName,
const XnChar* strCreationInfo,
xn::NodeInfoList* /*pNeededTrees*/,
const XnChar* strConfigurationDir,
xn::ModuleProductionNode** ppInstance)
{
XnStatus nRetVal = XN_STATUS_OK;
XnChar strGlobalConfigFile[XN_FILE_MAX_PATH];
nRetVal = XnSensor::ResolveGlobalConfigFileName(strGlobalConfigFile, XN_FILE_MAX_PATH, strConfigurationDir);
XN_IS_STATUS_OK(nRetVal);
// multi-process is not supported on Mac
#if (XN_PLATFORM == XN_PLATFORM_MACOSX)
XnBool bEnableMultiProcess = FALSE;
#else
XnBool bEnableMultiProcess = XN_SENSOR_DEFAULT_MULTI_PROCESS;
XnUInt32 nValue;
if (XN_STATUS_OK == xnOSReadIntFromINI(strGlobalConfigFile, XN_SENSOR_SERVER_CONFIG_FILE_SECTION, XN_MODULE_PROPERTY_ENABLE_MULTI_PROCESS, &nValue))
{
bEnableMultiProcess = (nValue == TRUE);
}
#endif
XnDeviceBase* pSensor = NULL;
if (bEnableMultiProcess)
{
XN_VALIDATE_NEW(pSensor, XnSensorClient);
}
else
{
XN_VALIDATE_NEW(pSensor, XnSensor);
}
XnDeviceConfig config;
config.DeviceMode = XN_DEVICE_MODE_READ;
config.cpConnectionString = strCreationInfo;
config.SharingMode = XN_DEVICE_EXCLUSIVE;
config.pInitialValues = NULL;
if (strConfigurationDir != NULL)
{
if (bEnableMultiProcess)
{
XnSensorClient* pClient = (XnSensorClient*)pSensor;
pClient->SetConfigDir(strConfigurationDir);
}
else
{
XnSensor* pActualSensor = (XnSensor*)pSensor;
pActualSensor->SetGlobalConfigFile(strGlobalConfigFile);
}
}
nRetVal = pSensor->Init(&config);
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pSensor);
return (nRetVal);
}
XnSensorDevice* pDevice = XN_NEW(XnSensorDevice, context, pSensor, strInstanceName);
if (pDevice == NULL)
{
XN_DELETE(pSensor);
return (XN_STATUS_ALLOC_FAILED);
}
nRetVal = pDevice->Init();
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pDevice);
XN_DELETE(pSensor);
return (nRetVal);
}
nRetVal = m_createdDevices.AddLast(DeviceKey(context.GetUnderlyingObject(), strCreationInfo));
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pDevice);
XN_DELETE(pSensor);
return (nRetVal);
}
*ppInstance = pDevice;
return (XN_STATUS_OK);
}
void ExportedCodec::Destroy(ModuleProductionNode* pInstance)
{
XnCodec* pCodec = dynamic_cast<XnCodec*>(pInstance);
XN_DELETE(pCodec);
}
void PlayerDriver::deviceClose(oni::driver::DeviceBase* pDevice)
{
XN_DELETE(pDevice);
}
void XnDeviceBase::DestroyModule(XnDeviceModuleHolder* pModuleHolder)
{
XN_DELETE(pModuleHolder->GetModule());
XN_DELETE(pModuleHolder);
}
XnStatus Context::loadLibraries(const char* directoryName)
{
XnStatus nRetVal;
// Get a file list of Xiron devices
XnInt32 nFileCount = 0;
typedef XnChar FileName[XN_FILE_MAX_PATH];
FileName* acsFileList = NULL;
#if (ONI_PLATFORM != ONI_PLATFORM_ANDROID_ARM)
XnChar cpSearchString[XN_FILE_MAX_PATH] = "";
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Looking for drivers in drivers repository '%s'", directoryName);
// Build the search pattern string
XN_VALIDATE_STR_APPEND(cpSearchString, directoryName, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_FILE_DIR_SEP, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_SHARED_LIBRARY_PREFIX, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_FILE_ALL_WILDCARD, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_SHARED_LIBRARY_POSTFIX, XN_FILE_MAX_PATH, nRetVal);
nRetVal = xnOSCountFiles(cpSearchString, &nFileCount);
if (nRetVal != XN_STATUS_OK || nFileCount == 0)
{
xnLogError(XN_MASK_ONI_CONTEXT, "Found no drivers matching '%s'", cpSearchString);
m_errorLogger.Append("Found no files matching '%s'", cpSearchString);
return XN_STATUS_NO_MODULES_FOUND;
}
acsFileList = XN_NEW_ARR(FileName, nFileCount);
nRetVal = xnOSGetFileList(cpSearchString, NULL, acsFileList, nFileCount, &nFileCount);
#else
// Android
nFileCount = 3;
acsFileList = XN_NEW_ARR(FileName, nFileCount);
strcpy(acsFileList[0], "libPS1080.so");
strcpy(acsFileList[1], "libOniFile.so");
strcpy(acsFileList[2], "libPSLink.so");
#endif
// Save directory
XnChar workingDir[XN_FILE_MAX_PATH];
xnOSGetCurrentDir(workingDir, XN_FILE_MAX_PATH);
// Change directory
xnOSSetCurrentDir(directoryName);
for (int i = 0; i < nFileCount; ++i)
{
DeviceDriver* pDeviceDriver = XN_NEW(DeviceDriver, acsFileList[i], m_frameManager, m_errorLogger);
if (pDeviceDriver == NULL || !pDeviceDriver->isValid())
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Couldn't use file '%s' as a device driver", acsFileList[i]);
m_errorLogger.Append("Couldn't understand file '%s' as a device driver", acsFileList[i]);
XN_DELETE(pDeviceDriver);
continue;
}
OniCallbackHandle dummy;
pDeviceDriver->registerDeviceConnectedCallback(deviceDriver_DeviceConnected, this, dummy);
pDeviceDriver->registerDeviceDisconnectedCallback(deviceDriver_DeviceDisconnected, this, dummy);
pDeviceDriver->registerDeviceStateChangedCallback(deviceDriver_DeviceStateChanged, this, dummy);
if (!pDeviceDriver->initialize())
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Couldn't use file '%s' as a device driver", acsFileList[i]);
m_errorLogger.Append("Couldn't initialize device driver from file '%s'", acsFileList[i]);
XN_DELETE(pDeviceDriver);
continue;
}
m_cs.Lock();
m_deviceDrivers.AddLast(pDeviceDriver);
m_cs.Unlock();
}
// Return to directory
xnOSSetCurrentDir(workingDir);
if (m_deviceDrivers.Size() == 0)
{
xnLogError(XN_MASK_ONI_CONTEXT, "Found no valid drivers");
m_errorLogger.Append("Found no valid drivers in '%s'", directoryName);
return XN_STATUS_NO_MODULES_FOUND;
}
XN_DELETE_ARR(acsFileList);
return XN_STATUS_OK;
}
XnStatus XnFileDevice::HandleStreamRemoved(const XnChar* strName)
{
XnStatus nRetVal = XN_STATUS_OK;
// check for specific case: all streams are removed and then end-of-file is reached.
// in this case, we don't really want to destroy streams, just wrap around.
XnStringsHash StreamsToRemove;
nRetVal = StreamsToRemove.Set(strName, NULL);
XN_IS_STATUS_OK(nRetVal);
XnPackedDataType nType = XN_PACKED_STREAM_REMOVED;
XnUInt32 nPositionBefore;
while (TRUE)
{
nRetVal = m_pInputStream->Tell(&nPositionBefore);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_pDataPacker->ReadNextObject(&nType);
XN_IS_STATUS_OK(nRetVal);
if (nType == XN_PACKED_STREAM_REMOVED)
{
XnChar strTempName[XN_DEVICE_MAX_STRING_LENGTH];
nRetVal = m_pDataPacker->ReadStreamRemoved(strTempName);
XN_IS_STATUS_OK(nRetVal);
nRetVal = StreamsToRemove.Set(strTempName, NULL);
XN_IS_STATUS_OK(nRetVal);
}
else
{
break;
}
}
if (nType != XN_PACKED_END)
{
// Not the case we were looking for. Remove those streams.
for (XnStringsHash::Iterator it = StreamsToRemove.begin(); it != StreamsToRemove.end(); ++it)
{
nRetVal = m_pNotifications->OnNodeRemoved(m_pNotificationsCookie, it.Key());
XN_IS_STATUS_OK(nRetVal);
XnNodeInfo* pNodeInfo;
m_nodeInfoMap.Get(it.Key(), pNodeInfo);
XN_DELETE(pNodeInfo->pXnCodec);
m_nodeInfoMap.Remove(it.Key());
m_ignoreNewNodes.Remove(it.Key());
}
m_bNodeCollectionChanged = TRUE;
}
// in any case, the last object we read wasn't handled yet (end-of-stream or another event), so
// seek back, so it will be handled.
nRetVal = m_pInputStream->Seek(nPositionBefore);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
void XnDeviceFileWriter::DestroyStreamModule(XnDeviceModuleHolder* pStreamHolder)
{
XN_DELETE(pStreamHolder->GetModule());
XN_DELETE(pStreamHolder);
}
void XnDeviceFileWriter::DestroyIOStreamImpl(XnIOStream* pStream)
{
pStream->Free();
XN_DELETE(pStream);
}
