XnStatus XnDeviceBase::UnregisterFromPropertyChange(const XnChar* Module, const XnChar* PropertyName, XnCallbackHandle hCallback) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(Module); XN_VALIDATE_INPUT_PTR(PropertyName); XN_VALIDATE_INPUT_PTR(hCallback); XnPropertyCallback* pRealCookie = (XnPropertyCallback*)hCallback; XnDeviceModule* pModule; nRetVal = FindModule(Module, &pModule); XN_IS_STATUS_OK(nRetVal); // first unregister it from property nRetVal = pModule->UnregisterFromOnPropertyValueChanged(PropertyName, pRealCookie->hCallback); XN_IS_STATUS_OK(nRetVal); XnValue val = pRealCookie; XnList::Iterator it = m_PropertyCallbacks.Find(val); if (it != m_PropertyCallbacks.end()) { m_PropertyCallbacks.Remove(it); } // now free the memory XN_DELETE(pRealCookie); return (XN_STATUS_OK); }
XnStatus XnServerSensorInvoker::RegisterToProps(XnPropertySet* pProps) { XnStatus nRetVal = XN_STATUS_OK; XnCallbackHandle hDummy = NULL; for (XnPropertySetData::Iterator itMod = pProps->pData->Begin(); itMod != pProps->pData->End(); ++itMod) { XnActualPropertiesHash* pHash = itMod->Value(); XnDeviceModule* pModule; nRetVal = m_sensor.FindModule(itMod->Key(), &pModule); XN_IS_STATUS_OK(nRetVal); for (XnActualPropertiesHash::Iterator itProp = pHash->Begin(); itProp != pHash->End(); ++itProp) { XnProperty* pProp; nRetVal = pModule->GetProperty(itProp->Key(), &pProp); XN_IS_STATUS_OK(nRetVal); // no need to keep the handle. We only want to unregister when the stream is destroyed, and then // it happens anyway. nRetVal = pProp->OnChangeEvent().Register(PropertyChangedCallback, this, hDummy); XN_IS_STATUS_OK(nRetVal); } } return (XN_STATUS_OK); }
XnStatus XnSensor::CreateDeviceModule(XnDeviceModuleHolder** ppModuleHolder) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = XnDeviceBase::CreateDeviceModule(ppModuleHolder); XN_IS_STATUS_OK(nRetVal); // add sensor properties XnDeviceModule* pModule = (*ppModuleHolder)->GetModule(); XnProperty* pProps[] = { &m_ErrorState, &m_ResetSensorOnStartup, &m_Interface, &m_ReadFromEP1, &m_ReadFromEP2, &m_ReadFromEP3, &m_ReadData, &m_NumberOfBuffers, &m_FirmwareParam, &m_CmosBlankingUnits, &m_CmosBlankingTime, &m_Reset, &m_FirmwareMode, &m_Version, &m_FixedParam, &m_FrameSync, &m_CloseStreamsOnShutdown, &m_InstancePointer, &m_ID, &m_USBPath, &m_DeviceName, &m_VendorSpecificData, }; nRetVal = pModule->AddProperties(pProps, sizeof(pProps)/sizeof(XnProperty*)); if (nRetVal != XN_STATUS_OK) { DestroyModule(*ppModuleHolder); *ppModuleHolder = NULL; return (nRetVal); } // configure it from global file if (m_strGlobalConfigFile[0] != '\0') { nRetVal = pModule->LoadConfigFromFile(m_strGlobalConfigFile); XN_IS_STATUS_OK(nRetVal); } return (XN_STATUS_OK); }
XnStatus XnDeviceBase::RegisterToPropertyChange(const XnChar* Module, const XnChar* PropertyName, XnDeviceOnPropertyChangedEventHandler Handler, void* pCookie, XnCallbackHandle* phCallback) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(Module, &pModule); XN_IS_STATUS_OK(nRetVal); XnPropertyCallback* pRealCookie; XN_VALIDATE_NEW(pRealCookie, XnPropertyCallback, GetDeviceHandle(), Module, PropertyName, Handler, pCookie); // register nRetVal = pModule->RegisterForOnPropertyValueChanged(PropertyName, PropertyValueChangedCallback, pRealCookie, &pRealCookie->hCallback); if (nRetVal != XN_STATUS_OK) { XN_DELETE(pRealCookie); return (nRetVal); } m_PropertyCallbacks.AddLast(pRealCookie); *phCallback = pRealCookie; return (XN_STATUS_OK); }
XnStatus XnDeviceBase::BatchConfig(const XnPropertySet* pChangeSet) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(pChangeSet); // start a transaction nRetVal = StartTransaction(); XN_IS_STATUS_OK(nRetVal); for (XnPropertySetData::ConstIterator itModule = pChangeSet->pData->begin(); itModule != pChangeSet->pData->end(); ++itModule) { // find this module XnDeviceModule* pModule = NULL; nRetVal = FindModule(itModule.Key(), &pModule); XN_CHECK_RC_ROLLBACK(nRetVal); nRetVal = pModule->BatchConfig(*itModule.Value()); XN_CHECK_RC_ROLLBACK(nRetVal); } nRetVal = CommitTransaction(); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnDeviceBase::GetProperty(const XnChar* ModuleName, const XnChar* PropertyName, const XnGeneralBuffer& gbValue) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->GetProperty(PropertyName, gbValue); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnDeviceBase::SetProperty(const XnChar* ModuleName, const XnChar* PropertyName, const XnChar* csValue) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->SetProperty(PropertyName, csValue); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnDeviceBase::GetPropertyType(const XnChar* ModuleName, const XnChar* PropertyName, XnPropertyType* pnType) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->GetPropertyType(PropertyName, pnType); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnDeviceBase::SetProperty(const XnChar* ModuleName, XnUInt32 propertyId, const OniGeneralBuffer& gbValue) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->SetProperty(propertyId, gbValue); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnSensor::ConfigureModuleFromGlobalFile(const XnChar* strModule, const XnChar* strSection /* = NULL */) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(strModule, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->LoadConfigFromFile(m_strGlobalConfigFile, strSection); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnDeviceBase::GetProperty(const XnChar* ModuleName, XnUInt32 propertyId, XnChar* csValue) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->GetProperty(propertyId, csValue); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnStreamReaderDevice::HandleGeneralProperty(const XnChar* strModule, const XnChar* strName, const XnGeneralBuffer& gbValue) { XnStatus nRetVal = XN_STATUS_OK; // find module XnDeviceModule* pModule; nRetVal = FindModule(strModule, &pModule); XN_IS_STATUS_OK(nRetVal); // update prop nRetVal = pModule->UnsafeUpdateProperty(strName, gbValue); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnDeviceBase::AddModule(XnDeviceModuleHolder* pModuleHolder) { XnDeviceModule* pModule = pModuleHolder->GetModule(); // make sure module doesn't exist yet if (m_Modules.Find(pModule->GetName()) != m_Modules.End()) { xnLogError(XN_MASK_DEVICE, "A module with the name %s already exists!", pModule->GetName()); return XN_STATUS_ERROR; } // add it to the list XnStatus nRetVal = m_Modules.Set(pModule->GetName(), pModuleHolder); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnDeviceBase::BatchConfig(const XnPropertySet* pChangeSet) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(pChangeSet); for (XnPropertySetData::ConstIterator itModule = pChangeSet->pData->Begin(); itModule != pChangeSet->pData->End(); ++itModule) { // find this module XnDeviceModule* pModule = NULL; nRetVal = FindModule(itModule->Key(), &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->BatchConfig(*itModule->Value()); XN_IS_STATUS_OK(nRetVal); } return (XN_STATUS_OK); }
XnStatus XnStreamReaderDevice::HandleIntProperty(const XnChar *strModule, const XnChar *strName, XnUInt64 nValue) { XnStatus nRetVal = XN_STATUS_OK; // ignore some properties if (strcmp(strModule, XN_MODULE_NAME_DEVICE) == 0 && strcmp(strName, XN_MODULE_PROPERTY_PRIMARY_STREAM) == 0) { return (XN_STATUS_OK); } // find module XnDeviceModule* pModule; nRetVal = FindModule(strModule, &pModule); XN_IS_STATUS_OK(nRetVal); // update prop nRetVal = pModule->UnsafeUpdateProperty(strName, nValue); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnSensorClient::CreateDeviceModule(XnDeviceModuleHolder** ppModuleHolder) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = XnDeviceBase::CreateDeviceModule(ppModuleHolder); XN_IS_STATUS_OK(nRetVal); // add sensor properties XnDeviceModule* pModule = (*ppModuleHolder)->GetModule(); XnProperty* pProps[] = { &m_InstancePointer, &m_ErrorState }; nRetVal = pModule->AddProperties(pProps, sizeof(pProps)/sizeof(XnProperty*)); if (nRetVal != XN_STATUS_OK) { DestroyModule(*ppModuleHolder); *ppModuleHolder = NULL; return (nRetVal); } return (XN_STATUS_OK); }
XnStatus XnDeviceBase::DoesPropertyExist(const XnChar* ModuleName, const XnChar* PropertyName, XnBool* pbDoesExist) { XnStatus nRetVal = XN_STATUS_OK; *pbDoesExist = FALSE; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); if (nRetVal == XN_STATUS_DEVICE_MODULE_NOT_FOUND) { return XN_STATUS_OK; } else { XN_IS_STATUS_OK(nRetVal); } nRetVal = pModule->DoesPropertyExist(PropertyName, pbDoesExist); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnDeviceFileReader::CreateDeviceModule(XnDeviceModuleHolder** ppModuleHolder) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = XnStreamReaderDevice::CreateDeviceModule(ppModuleHolder); XN_IS_STATUS_OK(nRetVal); XnDeviceModule* pModule = (*ppModuleHolder)->GetModule(); // add sensor properties XnProperty* pProps[] = { &m_FrameDelay, &m_InstancePointer }; nRetVal = pModule->AddProperties(pProps, sizeof(pProps)/sizeof(XnProperty*)); if (nRetVal != XN_STATUS_OK) { DestroyModule(*ppModuleHolder); *ppModuleHolder = NULL; return (nRetVal); } return (XN_STATUS_OK); }
XnStatus XnDeviceBase::CreateDeviceModule(XnDeviceModuleHolder** ppModuleHolder) { XnStatus nRetVal = XN_STATUS_OK; // create module nRetVal = CreateModule(XN_MODULE_NAME_DEVICE, ppModuleHolder); XN_IS_STATUS_OK(nRetVal); XnDeviceModule* pModule = (*ppModuleHolder)->GetModule(); // add device properties XnProperty* pProps[] = { &m_DeviceMirror }; nRetVal = pModule->AddProperties(pProps, sizeof(pProps)/sizeof(XnProperty*)); if (nRetVal != XN_STATUS_OK) { DestroyModule(*ppModuleHolder); *ppModuleHolder = NULL; return (nRetVal); } return XN_STATUS_OK; }
XnStatus XnDeviceBase::GetAllProperties(XnPropertySet* pSet, XnBool bNoStreams /* = FALSE */, const XnChar* strModule /* = NULL */) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(pSet); // clear the set nRetVal = XnPropertySetClear(pSet); XN_IS_STATUS_OK(nRetVal); if (strModule != NULL) { XnDeviceModule* pModule; nRetVal = FindModule(strModule, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->GetAllProperties(pSet); XN_IS_STATUS_OK(nRetVal); } else { // enumerate over modules for (XnStringsHash::Iterator it = m_Modules.begin(); it != m_Modules.end(); ++it) { XnDeviceModuleHolder* pModuleHolder = (XnDeviceModuleHolder*)it.Value(); if (bNoStreams && IsStream(pModuleHolder->GetModule())) continue; nRetVal = pModuleHolder->GetModule()->GetAllProperties(pSet); XN_IS_STATUS_OK(nRetVal); } } return XN_STATUS_OK; }
XnStatus XnDeviceBase::CreateDeviceModule(XnDeviceModuleHolder** ppModuleHolder) { XnStatus nRetVal = XN_STATUS_OK; // create module nRetVal = CreateModule(XN_MODULE_NAME_DEVICE, ppModuleHolder); XN_IS_STATUS_OK(nRetVal); XnDeviceModule* pModule = (*ppModuleHolder)->GetModule(); // add device properties XnProperty* pProps[] = { &m_ReadWriteMode, &m_SharingMode, &m_PrimaryStream, &m_DeviceMirror, &m_SDKVersionProp, &m_HighResTimestamps, &m_DeviceName }; nRetVal = pModule->AddProperties(pProps, sizeof(pProps)/sizeof(XnProperty*)); if (nRetVal != XN_STATUS_OK) { DestroyModule(*ppModuleHolder); *ppModuleHolder = NULL; return (nRetVal); } return XN_STATUS_OK; }
XnStatus XnDeviceModule::SetLockStateCallback(XnActualIntProperty* /*pSender*/, XnUInt64 nValue, void* pCookie) { XnDeviceModule* pThis = (XnDeviceModule*)pCookie; return pThis->SetLockState(nValue != FALSE); }
XnStatus XnDeviceBase::CreateStreamImpl(const XnChar* strType, const XnChar* strName, const XnActualPropertiesHash* pInitialSet) { XnStatus nRetVal = XN_STATUS_OK; xnLogInfo(XN_MASK_DDK, "Creating stream '%s' of type '%s'...", strName, strType); XnDeviceModule* pModule; if (FindModule(strName, &pModule) == XN_STATUS_OK) { // already exists. check sharing mode (when shared, we allow "creating" the same stream) if (GetSharingMode() != XN_DEVICE_SHARED || !IsStream(pModule) || strcmp(strType, ((XnDeviceStream*)pModule)->GetType()) != 0) { XN_LOG_WARNING_RETURN(XN_STATUS_STREAM_ALREADY_EXISTS, XN_MASK_DDK, "A stream with this name already exists!"); } // OK, we'll allow this. Just set new configuration if (pInitialSet != NULL) { nRetVal = pModule->BatchConfig(*pInitialSet); XN_IS_STATUS_OK(nRetVal); } } else { // create stream XnDeviceModuleHolder* pNewStreamHolder = NULL; nRetVal = CreateStreamModule(strType, strName, &pNewStreamHolder); XN_IS_STATUS_OK(nRetVal); XnDeviceStream* pNewStream = (XnDeviceStream*)(pNewStreamHolder->GetModule()); if (pNewStream == NULL) { DestroyStreamModule(pNewStreamHolder); XN_LOG_ERROR_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Internal Error: Invalid new stream!"); } // initialize the stream xnLogVerbose(XN_MASK_DDK, "Initializing stream '%s'...", strName); nRetVal = pNewStreamHolder->Init(pInitialSet); if (nRetVal != XN_STATUS_OK) { DestroyStreamModule(pNewStreamHolder); return (nRetVal); } // set it's mirror value (if not requested otherwise) XnBool bSetMirror = TRUE; if (pInitialSet != NULL) { XnActualPropertiesHash::ConstIterator it = pInitialSet->end(); if (XN_STATUS_OK == pInitialSet->Find(XN_MODULE_PROPERTY_MIRROR, it)) { bSetMirror = FALSE; } } if (bSetMirror) { nRetVal = pNewStream->SetMirror((XnBool)m_DeviceMirror.GetValue()); if (nRetVal != XN_STATUS_OK) { DestroyStreamModule(pNewStreamHolder); return (nRetVal); } } // add it to the list of existing modules nRetVal = AddModule(pNewStreamHolder); if (nRetVal != XN_STATUS_OK) { DestroyStreamModule(pNewStreamHolder); return (nRetVal); } xnLogInfo(XN_MASK_DDK, "Stream '%s' was initialized.", strName); nRetVal = StreamAdded(pNewStream); XN_IS_STATUS_OK(nRetVal); xnLogInfo(XN_MASK_DDK, "'%s' stream was created.", strName); } return (XN_STATUS_OK); }
XnStatus XnDeviceFileReader::Rewind() { XnStatus nRetVal = XN_STATUS_OK; // go back to start of stream nRetVal = GetIOStream()->Seek(XN_DEVICE_FILE_MAGIC_LEN); XN_IS_STATUS_OK(nRetVal); // read initial state XN_PROPERTY_SET_CREATE_ON_STACK(state); nRetVal = ReadInitialState(&state); XN_IS_STATUS_OK(nRetVal); // first handle current streams. remove or reset them XnDeviceModuleHolderList streams; nRetVal = GetStreamsList(streams); XN_IS_STATUS_OK(nRetVal); for (XnDeviceModuleHolderList::Iterator it = streams.Begin(); it != streams.End(); ++it) { XnDeviceModuleHolder* pHolder = *it; if (m_bStreamsCollectionChanged) { // we need to destroy all streams, and recreate them later nRetVal = DestroyStream(pHolder->GetModule()->GetName()); XN_IS_STATUS_OK(nRetVal); } else { // just reset frame ID XnStreamReaderStream* pStream = (XnStreamReaderStream*)pHolder->GetModule(); pStream->Reset(); } } // if we need, recreate streams if (m_bStreamsCollectionChanged) { nRetVal = CreateStreams(&state); XN_IS_STATUS_OK(nRetVal); } // now set state. for (XnPropertySetData::Iterator it = state.pData->Begin(); it != state.pData->End(); ++it) { const XnChar* strName = it->Key(); XnActualPropertiesHash* pHash = it->Value(); // fix it first if (strcmp(strName, XN_MODULE_NAME_DEVICE) == 0) { pHash->Remove(XN_MODULE_PROPERTY_READ_WRITE_MODE); pHash->Remove(XN_MODULE_PROPERTY_PRIMARY_STREAM); } XnDeviceModule* pModule; nRetVal = FindModule(strName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->UnsafeBatchConfig(*pHash); XN_IS_STATUS_OK(nRetVal); } ResetLastTimestampAndFrame(); m_nReferenceTimestamp = 0; m_nReferenceTime = 0; m_bStreamsCollectionChanged = FALSE; return (XN_STATUS_OK); }