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 XnSensorStreamHelper::BatchConfig(const XnActualPropertiesHash& props)
{
XnStatus nRetVal = XN_STATUS_OK;
XnBool bShouldClose = FALSE;
if (m_pStream->IsOpen())
{
// check if one of the properties requires to close the stream
for (FirmareProperties::Iterator it = m_FirmwareProperties.Begin(); it != m_FirmwareProperties.End(); ++it)
{
if (!it->Value().bAllowWhileOpen)
{
XnProperty* pProp;
if (XN_STATUS_OK == props.Get(it->Value().pStreamProp->GetName(), pProp))
{
bShouldClose = TRUE;
break;
}
}
}
}
if (bShouldClose)
{
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "closing stream before batch config...");
nRetVal = m_pStream->Close();
XN_IS_STATUS_OK(nRetVal);
}
nRetVal = m_pStream->XnDeviceStream::BatchConfig(props);
XN_IS_STATUS_OK(nRetVal);
if (bShouldClose)
{
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "re-opening stream after batch config...");
nRetVal = m_pStream->Open();
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 XnDeviceFileReader::ReadInitialState(XnPropertySet *pSet)
{
XnStatus nRetVal = XN_STATUS_OK;
if (m_nFileVersion < 4)
{
if (m_pBCData == NULL)
{
nRetVal = BCInit();
XN_IS_STATUS_OK(nRetVal);
}
return BCReadInitialState(pSet);
}
// first read first object - modules properties - using base
nRetVal = XnStreamReaderDevice::ReadInitialState(pSet);
XN_IS_STATUS_OK(nRetVal);
// now continue reading until we get to first data
XnPackedDataType nType;
XnBool bStateEnd = FALSE;
XnUInt64 nPositionBefore;
while (!bStateEnd)
{
nRetVal = GetIOStream()->Tell(&nPositionBefore);
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetDataPacker()->ReadNextObject(&nType);
XN_IS_STATUS_OK(nRetVal);
switch (nType)
{
case XN_PACKED_NEW_STREAM:
{
XnChar strType[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strName[XN_DEVICE_MAX_STRING_LENGTH];
XN_PROPERTY_SET_CREATE_ON_STACK(props);
nRetVal = GetDataPacker()->ReadNewStream(strType, strName, &props);
XN_IS_STATUS_OK(nRetVal);
XnActualPropertiesHash* pStreamProps;
nRetVal = XnPropertySetDataDetachModule(props.pData, strName, &pStreamProps);
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnPropertySetDataAttachModule(pSet->pData, strName, pStreamProps);
XN_IS_STATUS_OK(nRetVal);
break;
}
case XN_PACKED_INT_PROPERTY:
{
XnChar strModule[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strProp[XN_DEVICE_MAX_STRING_LENGTH];
XnUInt64 nValue;
nRetVal = GetDataPacker()->ReadProperty(strModule, strProp, &nValue);
XN_IS_STATUS_OK(nRetVal);
XnActualPropertiesHash* pModule = NULL;
nRetVal = pSet->pData->Get(strModule, pModule);
XN_IS_STATUS_OK(nRetVal);
XnProperty* pProp = NULL;
nRetVal = pModule->Get(strProp, pProp);
XN_IS_STATUS_OK(nRetVal);
XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp;
nRetVal = pIntProp->UnsafeUpdateValue(nValue);
XN_IS_STATUS_OK(nRetVal);
break;
}
case XN_PACKED_REAL_PROPERTY:
{
XnChar strModule[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strProp[XN_DEVICE_MAX_STRING_LENGTH];
XnDouble dValue;
nRetVal = GetDataPacker()->ReadProperty(strModule, strProp, &dValue);
XN_IS_STATUS_OK(nRetVal);
XnActualPropertiesHash* pModule;
nRetVal = pSet->pData->Get(strModule, pModule);
XN_IS_STATUS_OK(nRetVal);
XnProperty* pProp;
nRetVal = pModule->Get(strProp, pProp);
XN_IS_STATUS_OK(nRetVal);
XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp;
nRetVal = pRealProp->UnsafeUpdateValue(dValue);
XN_IS_STATUS_OK(nRetVal);
break;
}
case XN_PACKED_STRING_PROPERTY:
{
XnChar strModule[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strProp[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strValue[XN_DEVICE_MAX_STRING_LENGTH];
nRetVal = GetDataPacker()->ReadProperty(strModule, strProp, strValue);
XN_IS_STATUS_OK(nRetVal);
XnActualPropertiesHash* pModule;
nRetVal = pSet->pData->Get(strModule, pModule);
XN_IS_STATUS_OK(nRetVal);
XnProperty* pProp;
nRetVal = pModule->Get(strProp, pProp);
XN_IS_STATUS_OK(nRetVal);
XnActualStringProperty* pStringProp = (XnActualStringProperty*)pProp;
nRetVal = pStringProp->UnsafeUpdateValue(strValue);
XN_IS_STATUS_OK(nRetVal);
break;
}
case XN_PACKED_GENERAL_PROPERTY:
{
XnChar strModule[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strProp[XN_DEVICE_MAX_STRING_LENGTH];
XnGeneralBuffer gbValue;
nRetVal = GetDataPacker()->ReadProperty(strModule, strProp, &gbValue);
XN_IS_STATUS_OK(nRetVal);
XnActualPropertiesHash* pModule;
nRetVal = pSet->pData->Get(strModule, pModule);
XN_IS_STATUS_OK(nRetVal);
XnProperty* pProp;
nRetVal = pModule->Get(strProp, pProp);
XN_IS_STATUS_OK(nRetVal);
XnActualGeneralProperty* pIntProp = (XnActualGeneralProperty*)pProp;
nRetVal = pIntProp->UnsafeUpdateValue(gbValue);
XN_IS_STATUS_OK(nRetVal);
break;
}
default:
// reached end of initial state. go back to beginning of this object
nRetVal = GetIOStream()->Seek(nPositionBefore);
XN_IS_STATUS_OK(nRetVal);
// stop reading
bStateEnd = TRUE;
}
} // objects loop
return (XN_STATUS_OK);
}