XnStatus XnServerSensorInvoker::OnPropertyChanged(const XnProperty* pProp) { // some special handling if (strcmp(pProp->GetName(), XN_STREAM_PROPERTY_STATE) == 0) { // ignore STATE property (every client has its own value) return XN_STATUS_OK; } else if (strcmp(pProp->GetName(), XN_MODULE_PROPERTY_ERROR_STATE) == 0) { XnActualIntProperty* pActualIntProp = (XnActualIntProperty*)pProp; XnStatus nOldErrorState = m_errorState; m_errorState = (XnStatus)pActualIntProp->GetValue(); switch (m_errorState) { case XN_STATUS_DEVICE_NOT_CONNECTED: //TODO: Handle disconnection break; case XN_STATUS_OK: if (nOldErrorState == XN_STATUS_DEVICE_NOT_CONNECTED) { //TODO: Handle re-connection break; } } } // raise event m_propChangedEvent.Raise(pProp); return (XN_STATUS_OK); }
XnStatus XnSensorStreamHelper::ConfigureFirmware(XnActualIntProperty& Property) { XnStatus nRetVal = XN_STATUS_OK; XnSensorStreamHelperCookie* pPropData = NULL; nRetVal = m_FirmwareProperties.Get(&Property, pPropData); XN_IS_STATUS_OK(nRetVal); XnUInt64 nFirmwareValue = Property.GetValue(); if (pPropData->pStreamToFirmwareFunc != NULL) { nRetVal = pPropData->pStreamToFirmwareFunc(Property.GetValue(), &nFirmwareValue); XN_IS_STATUS_OK(nRetVal); } nRetVal = pPropData->pFirmwareProp->SetValue(nFirmwareValue); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XN_DDK_API XnStatus XnPropertySetCloneModule(const XnPropertySet* pSource, XnPropertySet* pDest, const XnChar* strModule, const XnChar* strNewName) { XnStatus nRetVal = XN_STATUS_OK; XnActualPropertiesHash* pModuleProps = NULL; nRetVal = pSource->pData->Get(strModule, pModuleProps); XN_IS_STATUS_OK(nRetVal); nRetVal = XnPropertySetAddModule(pDest, strNewName); XN_IS_STATUS_OK(nRetVal); for (XnActualPropertiesHash::ConstIterator it = pModuleProps->Begin(); it != pModuleProps->End(); ++it) { XnProperty* pProp = it->Value(); switch (pProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp; nRetVal = XnPropertySetAddIntProperty(pDest, strNewName, pIntProp->GetName(), pIntProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp; nRetVal = XnPropertySetAddRealProperty(pDest, strNewName, pRealProp->GetName(), pRealProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pStrProp = (XnActualStringProperty*)pProp; nRetVal = XnPropertySetAddStringProperty(pDest, strNewName, pStrProp->GetName(), pStrProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProp; nRetVal = XnPropertySetAddGeneralProperty(pDest, strNewName, pGenProp->GetName(), &pGenProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Unknown property type: %d", pProp->GetType()); } } return (XN_STATUS_OK); }
XnStatus XnDataPacker::WritePropertySetProperties(const XnPropertySet* pSet) { XnStatus nRetVal = XN_STATUS_OK; for (XnPropertySetData::Iterator it = pSet->pData->Begin(); it != pSet->pData->End(); ++it) { XnActualPropertiesHash* pModule = it->Value(); for (XnActualPropertiesHash::ConstIterator itProp = pModule->Begin(); itProp != pModule->End(); ++itProp) { switch (itProp->Value()->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pProp = (XnActualIntProperty*)itProp->Value(); nRetVal = WritePropertyImpl(pProp->GetModule(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pProp = (XnActualRealProperty*)itProp->Value(); nRetVal = WritePropertyImpl(pProp->GetModule(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pProp = (XnActualStringProperty*)itProp->Value(); nRetVal = WritePropertyImpl(pProp->GetModule(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pProp = (XnActualGeneralProperty*)itProp->Value(); nRetVal = WritePropertyImpl(pProp->GetModule(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Unknown property type: %d", itProp->Value()->GetType()); } } } StartWritingIntenalObject(XN_PACKED_PROPERTY_SET_PROPERTIES_END_MARKER); EndWritingInternalObject(); return (XN_STATUS_OK); }
XnStatus XnDeviceModuleHolder::UnsafeSetProperty(const XnProperty* pRequest, XnProperty* pProp) { XnStatus nRetVal = XN_STATUS_OK; if (pRequest->GetType() != pProp->GetType()) { XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_PROPERTY_BAD_TYPE, XN_MASK_DDK, "Property '%s' has the wrong type!", pRequest->GetName()); } switch (pRequest->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pActualRequest = (XnActualIntProperty*)pRequest; XnActualIntProperty* pActualProp = (XnActualIntProperty*)pProp; nRetVal = pActualProp->UnsafeUpdateValue(pActualRequest->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pActualRequest = (XnActualRealProperty*)pRequest; XnActualRealProperty* pActualProp = (XnActualRealProperty*)pProp; nRetVal = pActualProp->UnsafeUpdateValue(pActualRequest->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pActualRequest = (XnActualStringProperty*)pRequest; XnActualStringProperty* pActualProp = (XnActualStringProperty*)pProp; nRetVal = pActualProp->UnsafeUpdateValue(pActualRequest->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pActualRequest = (XnActualGeneralProperty*)pRequest; XnActualGeneralProperty* pActualProp = (XnActualGeneralProperty*)pProp; nRetVal = pActualProp->UnsafeUpdateValue(pActualRequest->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Unknown property type: %d\n", pRequest->GetType()); } // switch return (XN_STATUS_OK); }
XN_DDK_API XnStatus XnPropertySetEnumeratorGetIntValue(const XnPropertySetEnumerator* pEnumerator, XnUInt64* pnValue) { XN_VALIDATE_INPUT_PTR(pEnumerator); XN_VALIDATE_OUTPUT_PTR(pnValue); XnProperty* pPropBase = pEnumerator->itProp->Value(); if (pPropBase->GetType() != XN_PROPERTY_TYPE_INTEGER) { return XN_STATUS_DEVICE_PROPERTY_BAD_TYPE; } XnActualIntProperty* pProp = (XnActualIntProperty*)pPropBase; *pnValue = pProp->GetValue(); return (XN_STATUS_OK); }
XnStatus XnActualPropertiesHash::CopyFrom(const XnActualPropertiesHash& other) { XnStatus nRetVal = XN_STATUS_OK; Clear(); strncpy(m_strName, other.m_strName, XN_DEVICE_MAX_STRING_LENGTH); for (ConstIterator it = other.Begin(); it != other.End(); ++it) { switch (it->Value()->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pProp = (XnActualIntProperty*)it->Value(); nRetVal = Add(pProp->GetId(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pProp = (XnActualRealProperty*)it->Value(); nRetVal = Add(pProp->GetId(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pProp = (XnActualStringProperty*)it->Value(); nRetVal = Add(pProp->GetId(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pProp = (XnActualGeneralProperty*)it->Value(); nRetVal = Add(pProp->GetId(), pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Unknown property type: %d\n", it->Value()->GetType()); } } return (XN_STATUS_OK); }
XnStatus XnDeviceModule::UnsafeBatchConfig(const XnActualPropertiesHash& props) { XnStatus nRetVal = XN_STATUS_OK; for (XnActualPropertiesHash::ConstIterator it = props.Begin(); it != props.End(); ++it) { XnProperty* pRequestProp = it->Value(); switch (pRequestProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pProp = (XnActualIntProperty*)pRequestProp; nRetVal = UnsafeUpdateProperty(pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pProp = (XnActualRealProperty*)pRequestProp; nRetVal = UnsafeUpdateProperty(pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pProp = (XnActualStringProperty*)pRequestProp; nRetVal = UnsafeUpdateProperty(pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pProp = (XnActualGeneralProperty*)pRequestProp; nRetVal = UnsafeUpdateProperty(pProp->GetName(), pProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Unknown property type: %d\n", pRequestProp->GetType()); } // type switch } // props loop return (XN_STATUS_OK); }
XnStatus XnFileDevice::SetInitialState(XnPropertySet* pSet) { XnStatus nRetVal = XN_STATUS_OK; // Fix state (remove some properties that we don't wish to reflect in reader device) XnActualPropertiesHash* pDeviceModule = NULL; if (XN_STATUS_OK == pSet->pData->Get(XN_MODULE_NAME_DEVICE, pDeviceModule)) { pDeviceModule->Remove(XN_MODULE_PROPERTY_READ_WRITE_MODE); pDeviceModule->Remove(XN_MODULE_PROPERTY_PRIMARY_STREAM); // check for timestamps resolution XnActualIntProperty* pIntProp = NULL; if (XN_STATUS_OK == pDeviceModule->Get(XN_MODULE_PROPERTY_HIGH_RES_TIMESTAMPS, (XnProperty*&)pIntProp)) { m_bHighresTimestamps = (pIntProp->GetValue() == TRUE); } } // TODO: create DEVICE node // now create the rest of the modules and streams (DEVICE was already created) XnPropertySetData* pPropSetData = pSet->pData; for (XnPropertySetData::ConstIterator it = pPropSetData->Begin(); it != pPropSetData->End(); ++it) { // ignore module DEVICE if (strcmp(XN_MODULE_NAME_DEVICE, it->Key()) == 0) { continue; } // check if this is a stream XnActualPropertiesHash::ConstIterator itProp = it->Value()->End(); if (XN_STATUS_OK == it->Value()->Find(XN_STREAM_PROPERTY_TYPE, itProp)) { XnActualStringProperty* pTypeProp = (XnActualStringProperty*)itProp->Value(); nRetVal = HandleNewStream(pTypeProp->GetValue(), it->Key(), it->Value()); XN_IS_STATUS_OK(nRetVal); } } // modules loop return (XN_STATUS_OK); }
XnStatus XnDeviceModuleHolder::CreateProperty(XnProperty* pRequestProp) { XnStatus nRetVal = XN_STATUS_OK; XnProperty* pNewProp = NULL; switch (pRequestProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pProp = (XnActualIntProperty*)pRequestProp; XN_VALIDATE_NEW(pNewProp, XnActualIntProperty, pProp->GetName(), pProp->GetValue()); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pProp = (XnActualRealProperty*)pRequestProp; XN_VALIDATE_NEW(pNewProp, XnActualRealProperty, pProp->GetName(), pProp->GetValue()); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pProp = (XnActualStringProperty*)pRequestProp; XN_VALIDATE_NEW(pNewProp, XnActualStringProperty, pProp->GetName(), pProp->GetValue()); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pProp = (XnActualGeneralProperty*)pRequestProp; // create new buffer XnGeneralBuffer gbNew; nRetVal = XnGeneralBufferAlloc(&gbNew, pProp->GetValue().nDataSize); XN_IS_STATUS_OK(nRetVal); // copy content xnOSMemCopy(gbNew.pData, pProp->GetValue().pData, pProp->GetValue().nDataSize); XnActualGeneralProperty* pNewGeneralProp = NULL; XN_VALIDATE_NEW(pNewGeneralProp, XnActualGeneralProperty, pProp->GetName(), gbNew); pNewGeneralProp->SetAsBufferOwner(TRUE); pNewProp = pNewGeneralProp; break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Unknown property type: %d\n", pRequestProp->GetType()); } // switch // add the property to the module nRetVal = m_pModule->AddProperty(pNewProp); if (nRetVal != XN_STATUS_OK) { XN_DELETE(pNewProp); return (nRetVal); } // and add it to the list of allocated ones (so we'll delete it afterwards) m_Allocated.AddLast(pNewProp); return XN_STATUS_OK; }
XnStatus XnFileDevice::HandleNewStream(const XnChar *strType, const XnChar *strName, const XnActualPropertiesHash *pInitialValues) { XnStatus nRetVal = XN_STATUS_OK; // check if we need to ignore that (stream was not removed upon Rewind). XnNodeInfoMap::Iterator it = m_ignoreNewNodes.End(); if (m_ignoreNewNodes.Find(strName, it) == XN_STATUS_OK) { // ignore return (XN_STATUS_OK); } XnProductionNodeType type = GetNodeType(strType); if (type == -1) { XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid node type: %s", strType); } // find compression type XnActualIntProperty* pComp = NULL; nRetVal = pInitialValues->Get(XN_STREAM_PROPERTY_COMPRESSION, (XnProperty*&)pComp); XN_IS_STATUS_OK(nRetVal); XnCodecID codecID = XnCodec::GetCodecIDFromCompressionFormat((XnCompressionFormats)pComp->GetValue()); if (codecID == XN_CODEC_NULL) { XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid compression type: %llu", pComp->GetValue()); } // notify we have a new node nRetVal = m_pNotifications->OnNodeAdded(m_pNotificationsCookie, strName, type, codecID); XN_IS_STATUS_OK(nRetVal); // we support the mirror capability nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_MIRROR, 1); XN_IS_STATUS_OK(nRetVal); // we support the extended serialization capability nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_EXTENDED_SERIALIZATION, 1); XN_IS_STATUS_OK(nRetVal); // now write state for (XnActualPropertiesHash::ConstIterator it = pInitialValues->Begin(); it != pInitialValues->End(); ++it) { XnProperty* pProp = it->Value(); switch (pProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp; nRetVal = HandleIntProperty(strName, pProp->GetName(), pIntProp->GetValue()); } break; case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp; nRetVal = HandleRealProperty(strName, pProp->GetName(), pRealProp->GetValue()); } break; case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pStrProp = (XnActualStringProperty*)pProp; nRetVal = HandleStringProperty(strName, pProp->GetName(), pStrProp->GetValue()); } break; case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProp; nRetVal = HandleGeneralProperty(strName, pProp->GetName(), pGenProp->GetValue()); } break; default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_FILE, "Unknown property type: %d", pProp->GetType()); } XN_IS_STATUS_OK(nRetVal); } // at this stage, a node should exist with this name xn::ProductionNode node; nRetVal = m_context.GetProductionNodeByName(strName, node); XN_IS_STATUS_OK(nRetVal); // S2D & RW if (type == XN_NODE_TYPE_DEPTH) { nRetVal = UpdateS2DTables(xn::DepthGenerator(node)); XN_IS_STATUS_OK(nRetVal); nRetVal = UpdateRWData(xn::DepthGenerator(node)); XN_IS_STATUS_OK(nRetVal); } // notify end-of-state nRetVal = m_pNotifications->OnNodeStateReady(m_pNotificationsCookie, strName); XN_IS_STATUS_OK(nRetVal); // add it to the map XnNodeInfo nodeInfo = {0}; nRetVal = m_nodeInfoMap.Set(strName, nodeInfo); XN_IS_STATUS_OK(nRetVal); // create codec nRetVal = CreateCodec(node); XN_IS_STATUS_OK(nRetVal); // check IR compatibility nRetVal = CheckIRCompatibility(node); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnServerSensorInvoker::OnStreamAdded(const XnChar* StreamName) { XnStatus nRetVal = XN_STATUS_OK; // get all props XN_PROPERTY_SET_CREATE_ON_STACK(props); nRetVal = m_sensor.GetAllProperties(&props, FALSE, StreamName); XN_IS_STATUS_OK(nRetVal); // register to all props nRetVal = RegisterToProps(&props); XN_IS_STATUS_OK(nRetVal); XnActualPropertiesHash* pStreamProps = props.pData->Begin()->Value(); // create stream data SensorInvokerStream serverStream; xnOSMemSet(&serverStream, 0, sizeof(serverStream)); strcpy(serverStream.strType, StreamName); XN_VALIDATE_NEW(serverStream.pNewDataEvent, NewStreamDataEvent); // check if this is a frame stream XnProperty* pIsFrameBased; nRetVal = pStreamProps->Get(XN_STREAM_PROPERTY_IS_FRAME_BASED, pIsFrameBased); if (nRetVal == XN_STATUS_OK) { XnActualIntProperty* pIntProp = (XnActualIntProperty*)pIsFrameBased; serverStream.bFrameStream = (pIntProp->GetValue() == TRUE); } if (serverStream.bFrameStream) { // create the "shared memory name" property XN_VALIDATE_NEW(serverStream.pSharedMemoryName, XnActualStringProperty, XN_STREAM_PROPERTY_SHARED_BUFFER_NAME); // and add it to the stream XnDeviceStream* pStream; nRetVal = m_sensor.GetStream(StreamName, &pStream); if (nRetVal != XN_STATUS_OK) { XN_DELETE(serverStream.pNewDataEvent); XN_DELETE(serverStream.pSharedMemoryName); return nRetVal; } nRetVal = pStream->AddProperty(serverStream.pSharedMemoryName); if (nRetVal != XN_STATUS_OK) { XN_DELETE(serverStream.pNewDataEvent); XN_DELETE(serverStream.pSharedMemoryName); return nRetVal; } // create a shared memory buffer pool for it nRetVal = SetStreamSharedMemory(&serverStream); if (nRetVal != XN_STATUS_OK) { XN_DELETE(serverStream.pNewDataEvent); XN_DELETE(serverStream.pSharedMemoryName); return nRetVal; } } // create a stream data object for the stream nRetVal = m_sensor.CreateStreamData(StreamName, &serverStream.pStreamData); if (nRetVal != XN_STATUS_OK) { XN_DELETE(serverStream.pNewDataEvent); XN_DELETE(serverStream.pSharedMemoryName); return (nRetVal); } // and add it to our list of streams nRetVal = m_streams.Set(StreamName, serverStream); if (nRetVal != XN_STATUS_OK) { XN_DELETE(serverStream.pNewDataEvent); XN_DELETE(serverStream.pSharedMemoryName); return (nRetVal); } return (XN_STATUS_OK); }
XnStatus XnServerSession::OnPropertyChanged(const XnProperty* pProp) { XnStatus nRetVal = XN_STATUS_OK; XnAutoCSLocker streamLocker(m_hStreamsLock); SessionStream* pStream = NULL; nRetVal = FindStreamByServerName(pProp->GetModule(), &pStream); XN_IS_STATUS_OK(nRetVal); // send message m_pLogger->DumpMessage("PropChange", 0, m_nID, pProp->GetName()); XnAutoCSLocker commLocker(m_hCommLock); switch (pProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pActualProp = (XnActualIntProperty*)pProp; nRetVal = m_privateOutgoingPacker.WriteProperty(pStream->strClientStreamName, pProp->GetName(), pActualProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pActualProp = (XnActualRealProperty*)pProp; nRetVal = m_privateOutgoingPacker.WriteProperty(pStream->strClientStreamName, pProp->GetName(), pActualProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pActualProp = (XnActualStringProperty*)pProp; nRetVal = m_privateOutgoingPacker.WriteProperty(pStream->strClientStreamName, pProp->GetName(), pActualProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pActualProp = (XnActualGeneralProperty*)pProp; nRetVal = m_privateOutgoingPacker.WriteProperty(pStream->strClientStreamName, pProp->GetName(), pActualProp->GetValue()); XN_IS_STATUS_OK(nRetVal); break; } default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_SENSOR_SERVER, "Unknown property type: %d", pProp->GetType()); } return (XN_STATUS_OK); }
XnStatus XnSensorProductionNode::NotifyExState(XnNodeNotifications* pNotifications, void* pCookie) { XnStatus nRetVal = XN_STATUS_OK; // get all properties XN_PROPERTY_SET_CREATE_ON_STACK(props); nRetVal = m_pSensor->GetAllProperties(&props, FALSE, GetModuleName()); XN_IS_STATUS_OK(nRetVal); XnActualPropertiesHash* pPropsHash = props.pData->begin().Value(); // filter properties (remove the ones already exposed as OpenNI interfaces) FilterProperties(pPropsHash); const XnChar* astrIntProps[200] = {0}; const XnChar* astrRealProps[200] = {0}; const XnChar* astrStringProps[200] = {0}; const XnChar* astrGeneralProps[200] = {0}; XnUInt32 nIntProps = 0; XnUInt32 nRealProps = 0; XnUInt32 nStringProps = 0; XnUInt32 nGeneralProps = 0; // enumerate over properties for (XnActualPropertiesHash::Iterator it = pPropsHash->begin(); it != pPropsHash->end(); ++it) { XnProperty* pProp = it.Value(); switch (pProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp; pNotifications->OnNodeIntPropChanged(pCookie, GetInstanceName(), pProp->GetName(), pIntProp->GetValue()); astrIntProps[nIntProps++] = pProp->GetName(); } break; case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp; pNotifications->OnNodeRealPropChanged(pCookie, GetInstanceName(), pProp->GetName(), pRealProp->GetValue()); astrRealProps[nRealProps++] = pProp->GetName(); } break; case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pStrProp = (XnActualStringProperty*)pProp; pNotifications->OnNodeStringPropChanged(pCookie, GetInstanceName(), pProp->GetName(), pStrProp->GetValue()); astrStringProps[nStringProps++] = pProp->GetName(); } break; case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProp; pNotifications->OnNodeGeneralPropChanged(pCookie, GetInstanceName(), pProp->GetName(), pGenProp->GetValue().nDataSize, pGenProp->GetValue().pData); astrGeneralProps[nGeneralProps++] = pProp->GetName(); } break; default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DEVICE_SENSOR, "Unknown property type: %d", pProp->GetType()); } } // TODO: also register to these properties, and if changed, notify. // store notifications object m_pNotifications = pNotifications; m_pCookie = pCookie; return (XN_STATUS_OK); }