XnStatus XnDeviceBase::IsNewDataAvailable(const XnChar* StreamName, XnBool* pbNewDataAvailable, XnUInt64* pnTimestamp)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(StreamName);
XN_VALIDATE_OUTPUT_PTR(pbNewDataAvailable);
*pbNewDataAvailable = FALSE;
if (strcmp(StreamName, XN_PRIMARY_STREAM_ANY) == 0)
{
const XnChar* aStreamNames[100];
XnUInt32 nCount = 100;
nRetVal = GetStreamNames(aStreamNames, &nCount);
XN_IS_STATUS_OK(nRetVal);
for (XnUInt32 i = 0; i < nCount; ++i)
{
// find stream
XnDeviceStream* pStream = NULL;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
if (pStream->IsNewDataAvailable())
{
*pbNewDataAvailable = TRUE;
*pnTimestamp = pStream->GetLastTimestamp();
break;
}
}
}
else
{
// find stream
XnDeviceStream* pStream = NULL;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
if (pStream->IsNewDataAvailable())
{
*pbNewDataAvailable = TRUE;
*pnTimestamp = pStream->GetLastTimestamp();
}
}
return (XN_STATUS_OK);
}
XnStatus XnSensor::GetBufferPool(const XnChar* strStream, XnBufferPool** ppBufferPool)
{
XnStatus nRetVal = XN_STATUS_OK;
XnDeviceModuleHolder* pHolder;
nRetVal = FindStream(strStream, &pHolder);
XN_IS_STATUS_OK(nRetVal);
XnSensorStreamHolder* pSensorStreamHolder = (XnSensorStreamHolder*)(pHolder);
XnDeviceStream* pStream = pSensorStreamHolder->GetStream();
XnUInt64 nFrameBased;
nRetVal = pStream->GetProperty(XN_STREAM_PROPERTY_IS_FRAME_BASED, &nFrameBased);
XN_IS_STATUS_OK(nRetVal);
if (nFrameBased == 0)
{
return XN_STATUS_BAD_TYPE;
}
XnFrameStream* pFrameStream = (XnFrameStream*)pStream;
*ppBufferPool = pFrameStream->GetBufferPool();
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::WriteStream(XnStreamData* pStreamData)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pStreamData);
if (m_ReadWriteMode.GetValue() != XN_DEVICE_MODE_WRITE)
{
return XN_STATUS_IO_DEVICE_WRONG_MODE;
}
// take the stream to write
XnDeviceStream* pStream;
nRetVal = FindStream(pStreamData->StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
// make sure it is open
if (!pStream->IsOpen())
{
return XN_STATUS_STREAM_NOT_OPEN;
}
// and write
nRetVal = pStream->Write(pStreamData);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::ReadStream(XnStreamData* pStreamOutput)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pStreamOutput);
if (m_ReadWriteMode.GetValue() == XN_DEVICE_MODE_WRITE)
{
return XN_STATUS_IO_DEVICE_WRONG_MODE;
}
// take the stream to read
XnDeviceStream* pStream;
nRetVal = FindStream(pStreamOutput->StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
// make sure it is open
if (!pStream->IsNewDataAvailable() && !pStream->IsOpen())
{
return XN_STATUS_STREAM_NOT_OPEN;
}
// wait for it to advance
nRetVal = WaitForStream(m_hNewDataEvent, pStream);
XN_IS_STATUS_OK(nRetVal);
// and read
nRetVal = ReadFromStreamImpl(pStream, pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceFileWriter::DestroyStream(const XnChar* StreamName)
{
XnStatus nRetVal = XN_STATUS_OK;
// before closing this stream, we want to write down how many frames were written
XnFileWriterStream* pStream;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
XnUInt64 nCurPos;
nRetVal = GetIOStream()->Tell(&nCurPos);
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetIOStream()->Seek(pStream->m_nNumFramesPos);
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetDataPacker()->WriteProperty(StreamName, XN_STREAM_PROPERTY_NUMBER_OF_FRAMES, pStream->GetNumberOfFrames());
XN_IS_STATUS_OK(nRetVal);
// now seek back
nRetVal = GetIOStream()->Seek(nCurPos);
XN_IS_STATUS_OK(nRetVal);
// and destroy it
nRetVal = XnStreamWriterDevice::DestroyStream(StreamName);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceFileReader::HandleStreamData(XnStreamData* pDataProps, XnCompressionFormats nCompression, XnUInt32 nCompressedSize)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt64 nPosition;
nRetVal = GetIOStream()->Tell(&nPosition);
XN_IS_STATUS_OK(nRetVal);
XnUIntHash::Iterator it = m_PositionsToIgnore.End();
if (XN_STATUS_OK == m_PositionsToIgnore.Find(nPosition, it))
{
// ignore this one. Just update the frame ID
XnStreamDeviceStreamHolder* pHolder;
nRetVal = FindStream(pDataProps->StreamName, &pHolder);
XN_IS_STATUS_OK(nRetVal);
XnStreamReaderStream* pStream = (XnStreamReaderStream*)pHolder->GetStream();
pStream->NewDataAvailable(pDataProps->nTimestamp, pDataProps->nFrameID);
// and remove it from list
nRetVal = m_PositionsToIgnore.Remove(it);
XN_IS_STATUS_OK(nRetVal);
}
else
{
// normal case. handle it
nRetVal = XnStreamReaderDevice::HandleStreamData(pDataProps, nCompression, nCompressedSize);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::DestroyStream(const XnChar* StreamName)
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogInfo(XN_MASK_DDK, "Destroying stream '%s'...", StreamName);
// keep the stream name (we now delete the module, so the name will be lost)
XnChar strStreamName[XN_DEVICE_MAX_STRING_LENGTH];
strncpy(strStreamName, StreamName, XN_DEVICE_MAX_STRING_LENGTH);
// Find the stream
XnDeviceModuleHolder* pStreamHolder;
nRetVal = FindStream(strStreamName, &pStreamHolder);
XN_IS_STATUS_OK(nRetVal);
// remove it from map
nRetVal = RemoveModule(strStreamName);
XN_IS_STATUS_OK(nRetVal);
// and free it's memory
DestroyStreamModule(pStreamHolder);
// free memory of registered properties to this stream
FreeModuleRegisteredProperties(StreamName);
// raise event
m_OnStreamsChangeEvent.Raise(GetDeviceHandle(), strStreamName, XN_DEVICE_STREAM_DELETED);
xnLogVerbose(XN_MASK_DDK, "'%s' stream destroyed.", strStreamName);
return XN_STATUS_OK;
}
XnStatus XnDeviceBase::FindStream(const XnChar* StreamName, XnDeviceStream** ppStream)
{
// find the module
XnDeviceModuleHolder* pStreamHolder = NULL;
XnStatus nRetVal = FindStream(StreamName, &pStreamHolder);
XN_IS_STATUS_OK(nRetVal);
*ppStream = (XnDeviceStream*)pStreamHolder->GetModule();
return XN_STATUS_OK;
}
XnBool XnSensor::HasSynchedFrameArrived(const XnChar* strDepthStream, const XnChar* strImageStream)
{
// find both streams
XnDeviceStream* pDepth;
XnDeviceStream* pImage;
if (XN_STATUS_OK != FindStream(strDepthStream, &pDepth))
return FALSE;
if (XN_STATUS_OK != FindStream(strImageStream, &pImage))
return FALSE;
XnUInt32 nThreshold = XN_SENSOR_FRAME_SYNC_MAX_DIFF;
if (IsHighResTimestamps())
nThreshold *= 1000;
// wait for both to advance, and time difference to be less than threshold
XnInt32 nTimestampDiff = XnInt32(pDepth->GetLastTimestamp() - pImage->GetLastTimestamp());
XnBool bConditionMet = (
pDepth->IsNewDataAvailable() &&
pImage->IsNewDataAvailable() &&
(XnUInt32)abs(nTimestampDiff) <= nThreshold
);
if (xnLogIsDumpMaskEnabled(XN_DUMP_FRAME_SYNC))
{
XnUInt64 nNow;
xnOSGetHighResTimeStamp(&nNow);
xnDumpWriteString(m_FrameSyncDump, "%llu,%u,%llu,%u,%llu,%s\n",
nNow,
pDepth->IsNewDataAvailable(),
pDepth->GetLastTimestamp(),
pImage->IsNewDataAvailable(),
pImage->GetLastTimestamp(),
bConditionMet ? "OK" : "Waiting");
}
return bConditionMet;
}
int main() {
int stream[]= {1, 2, 3, 4};
int n=sizeof(stream)/sizeof(stream[0]);
FindStream(stream,n);
return 0;
}
XnStatus XnSensor::GetStream(const XnChar* strStream, XnDeviceStream** ppStream)
{
XnStatus nRetVal = XN_STATUS_OK;
XnDeviceModuleHolder* pHolder;
nRetVal = FindStream(strStream, &pHolder);
XN_IS_STATUS_OK(nRetVal);
XnSensorStreamHolder* pSensorStreamHolder = (XnSensorStreamHolder*)(pHolder);
*ppStream = pSensorStreamHolder->GetStream();
return XN_STATUS_OK;
}
XnStatus XnSensor::GetSharedBufferPool(const XnChar* strStream, XnSharedMemoryBufferPool** ppBufferPool)
{
XnStatus nRetVal = XN_STATUS_OK;
XnDeviceModuleHolder* pHolder;
nRetVal = FindStream(strStream, &pHolder);
XN_IS_STATUS_OK(nRetVal);
XnSensorStreamHolder* pSensorStreamHolder = (XnSensorStreamHolder*)(pHolder);
*ppBufferPool = pSensorStreamHolder->GetSharedBufferPool();
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::GetStreamRequiredDataSize(const XnChar* StreamName, XnUInt32* pnRequiredSize)
{
XnStatus nRetVal = XN_STATUS_OK;
// find stream
XnDeviceStream* pStream;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
*pnRequiredSize = pStream->GetRequiredDataSize();
return XN_STATUS_OK;
}
XnStatus XnSensorClient::HandlePackedObject(XnPackedDataType nObjectType)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nDataSize = sizeof(m_LastReply);
switch (nObjectType)
{
case XN_SENSOR_SERVER_MESSAGE_GENERAL_OP_RESPOND:
case XN_SENSOR_SERVER_MESSAGE_GET_INT_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_GET_REAL_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_GET_STRING_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_GET_GENERAL_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_READ_STREAM:
case XN_SENSOR_SERVER_MESSAGE_BYE:
{
nRetVal = GetDataPacker()->ReadCustomData(nObjectType, &m_LastReply, &nDataSize);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSSetEvent(m_hReplyEvent);
XN_IS_STATUS_OK(nRetVal);
break;
}
case XN_SENSOR_SERVER_MESSAGE_NEW_STREAM_DATA:
{
XnSensorServerNewStreamData message;
XnUInt32 nDataSize = sizeof(message);
nRetVal = GetDataPacker()->ReadCustomData(nObjectType, &message, &nDataSize);
XN_IS_STATUS_OK(nRetVal);
// find the stream
XnStreamDeviceStreamHolder* pHolder = NULL;
nRetVal = FindStream(message.strStreamName, &pHolder);
XN_IS_STATUS_OK(nRetVal);
pHolder->GetStream()->NewDataAvailable(message.nTimestamp, message.nFrameID);
break;
}
default:
{
nRetVal = XnStreamReaderDevice::HandlePackedObject(nObjectType);
XN_IS_STATUS_OK(nRetVal);
}
}
return (XN_STATUS_OK);
}
//
// HaveTarget
//
// True if target is alive (will attempt to setup if not)
//
Bool FileSrcStream::HaveTarget()
{
// Is the target already alive
if (target.Alive())
{
return (TRUE);
}
// Try and find the target
ResourceStream *s = FindStream(targetName.crc);
// Setup our reaper
target = s;
// Return TRUE if we found the target
return (s ? TRUE : FALSE);
}
XnBool XnDeviceBase::HasPrimaryStreamAdvanced(XnStreamDataSet* pOutputSet)
{
if (strcmp(m_PrimaryStream.GetValue(), XN_PRIMARY_STREAM_NONE) == 0)
{
// special case of None: condition is always true
return TRUE;
}
const XnChar* astrNames[XN_DEVICE_BASE_MAX_STREAMS_COUNT];
XnUInt32 nArraySize = XN_DEVICE_BASE_MAX_STREAMS_COUNT;
// take a list of streams to check for new data
if (strcmp(m_PrimaryStream.GetValue(), XN_PRIMARY_STREAM_ANY) != 0)
{
// we have a specific stream. Add it to the list
astrNames[0] = m_PrimaryStream.GetValue();
nArraySize = 1;
}
else
{
// special case of ANY. we need to check every one of requested streams
XnStreamData* apStreamOutputs[XN_DEVICE_BASE_MAX_STREAMS_COUNT];
if (XN_STATUS_OK != XnStreamDataSetCopyToArray(pOutputSet, apStreamOutputs, &nArraySize))
{
return FALSE;
}
for (XnUInt32 i = 0; i < nArraySize; ++i)
{
astrNames[i] = apStreamOutputs[i]->StreamName;
}
}
// now check if we have new data
for (XnUInt32 i = 0; i < nArraySize; ++i)
{
XnDeviceStream* pStream = NULL;
if (XN_STATUS_OK == FindStream(astrNames[i], &pStream))
{
if (pStream->IsNewDataAvailable())
return TRUE;
}
}
return FALSE;
}
XnStatus XnDeviceBase::CreateStreamData(const XnChar* StreamName, XnStreamData** ppStreamData)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(StreamName);
XN_VALIDATE_OUTPUT_PTR(ppStreamData);
// find stream
XnDeviceStream* pStream;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
// and create stream output
nRetVal = pStream->CreateStreamData(ppStreamData);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnSensorClient::HandleNewStream(const XnChar* strType, const XnChar* strName, const XnActualPropertiesHash* pInitialValues)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = XnStreamReaderDevice::HandleNewStream(strType, strName, pInitialValues);
XN_IS_STATUS_OK(nRetVal);
// open shared memory
XnStreamDeviceStreamHolder* pHolder = NULL;
nRetVal = FindStream(strName, &pHolder);
XN_IS_STATUS_OK(nRetVal);
XnSensorClientStream* pStream = (XnSensorClientStream*)pHolder->GetStream();
nRetVal = pStream->OpenSharedMemory();
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::Read(XnStreamDataSet* pStreamOutputSet)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pStreamOutputSet);
if (m_ReadWriteMode.GetValue() == XN_DEVICE_MODE_WRITE)
{
return XN_STATUS_IO_DEVICE_WRONG_MODE;
}
XnUInt64 nNow;
xnOSGetHighResTimeStamp(&nNow);
xnDumpFileWriteString(m_StreamsDataDump, "%llu,Read Called\n", nNow);
// First thing to do is wait for primary stream to advance. We do this BEFORE checking streams
// because device streams might change during this wait.
nRetVal = WaitForPrimaryStream(m_hNewDataEvent, pStreamOutputSet);
XN_IS_STATUS_OK(nRetVal);
xnOSGetHighResTimeStamp(&nNow);
xnDumpFileWriteString(m_StreamsDataDump, "%llu,Read Condition Met\n", nNow);
// take the list of stream output objects
XnStreamData* apStreamOutputs[XN_DEVICE_BASE_MAX_STREAMS_COUNT];
XnUInt32 nOutputsCount = XN_DEVICE_BASE_MAX_STREAMS_COUNT;
nRetVal = XnStreamDataSetCopyToArray(pStreamOutputSet, apStreamOutputs, &nOutputsCount);
XN_IS_STATUS_OK(nRetVal);
// now read
for (XnUInt32 nIndex = 0; nIndex < nOutputsCount; ++nIndex)
{
// find its corresponding stream
XnDeviceStream* pStream;
nRetVal = FindStream(apStreamOutputs[nIndex]->StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ReadFromStreamImpl(pStream, apStreamOutputs[nIndex]);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::Write(XnStreamDataSet* pStreamDataSet)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pStreamDataSet);
if (m_ReadWriteMode.GetValue() != XN_DEVICE_MODE_WRITE)
{
return XN_STATUS_IO_DEVICE_WRONG_MODE;
}
// take the list of stream output objects
XnStreamData* apStreamOutputs[XN_DEVICE_BASE_MAX_STREAMS_COUNT];
XnUInt32 nOutputsCount = XN_DEVICE_BASE_MAX_STREAMS_COUNT;
nRetVal = XnStreamDataSetCopyToArray(pStreamDataSet, apStreamOutputs, &nOutputsCount);
XN_IS_STATUS_OK(nRetVal);
// find the stream for each one
XnDeviceStream* apStreams[XN_DEVICE_BASE_MAX_STREAMS_COUNT];
for (XnUInt32 nIndex = 0; nIndex < nOutputsCount; ++nIndex)
{
// find its corresponding stream
nRetVal = FindStream(apStreamOutputs[nIndex]->StreamName, &apStreams[nIndex]);
XN_IS_STATUS_OK(nRetVal);
// make sure it is open
if (!apStreams[nIndex]->IsOpen())
{
return XN_STATUS_STREAM_NOT_OPEN;
}
}
// go over them, and write into each one
for (XnUInt32 nIndex = 0; nIndex < nOutputsCount; ++nIndex)
{
nRetVal = apStreams[nIndex]->Write(apStreamOutputs[nIndex]);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::CloseStream(const XnChar* StreamName)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(StreamName);
xnLogVerbose(XN_MASK_DDK, "Closing stream %s...", StreamName);
// find this stream
XnDeviceStream* pStream;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
// close it
nRetVal = pStream->Close();
XN_IS_STATUS_OK(nRetVal);
xnLogInfo(XN_MASK_DDK, "Stream %s is closed.", StreamName);
return (XN_STATUS_OK);
}
XnStatus XnDeviceFileWriter::CreateStream(const XnChar* StreamType, const XnChar* StreamName /* = NULL */, const XnPropertySet* pInitialValues /* = NULL */)
{
XnStatus nRetVal = XN_STATUS_OK;
// create stream using base (this will also write it down to the file)
nRetVal = XnStreamWriterDevice::CreateStream(StreamType, StreamName, pInitialValues);
XN_IS_STATUS_OK(nRetVal);
// now, we leave a place for a property change - the number of frames. We will update this
// property once the stream is closed.
XnFileWriterStream* pStream;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetIOStream()->Tell(&pStream->m_nNumFramesPos);
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetDataPacker()->WriteProperty(StreamName, XN_STREAM_PROPERTY_NUMBER_OF_FRAMES, 0ULL);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::DestroyStream(const XnChar* StreamName)
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogInfo(XN_MASK_DDK, "Destroying stream '%s'...", StreamName);
// keep the stream name (we now delete the module, so the name will be lost)
XnChar strStreamName[XN_DEVICE_MAX_STRING_LENGTH];
strncpy(strStreamName, StreamName, XN_DEVICE_MAX_STRING_LENGTH);
xnl::AutoCSLocker lock(m_hLock);
// Find the stream
XnDeviceModuleHolder* pStreamHolder;
nRetVal = FindStream(strStreamName, &pStreamHolder);
XN_IS_STATUS_OK(nRetVal);
XnDeviceStream* pStream = (XnDeviceStream*)pStreamHolder->GetModule();
XnUInt32 nRefCount = pStream->DecRef();
if (0 == nRefCount)
{
// remove it from map
nRetVal = RemoveModule(strStreamName);
XN_IS_STATUS_OK(nRetVal);
// and free it's memory
DestroyStreamModule(pStreamHolder);
// free memory of registered properties to this stream
FreeModuleRegisteredProperties(StreamName);
xnLogVerbose(XN_MASK_DDK, "'%s' stream destroyed.", strStreamName);
}
else
{
xnLogVerbose(XN_MASK_DDK, "'%s' stream now has %d references.", strStreamName, nRefCount);
}
return XN_STATUS_OK;
}
XnStatus XnDeviceBase::SetPrimaryStream(const XnChar* strPrimaryStream)
{
XnStatus nRetVal = XN_STATUS_OK;
if (strcmp(strPrimaryStream, XN_PRIMARY_STREAM_ANY) != 0 &&
strcmp(strPrimaryStream, XN_PRIMARY_STREAM_NONE) != 0)
{
// specific stream. check it exists
XnDeviceStream* pStream;
nRetVal = FindStream(strPrimaryStream, &pStream);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_UNSUPPORTED_STREAM;
}
}
// OK. set the value
nRetVal = m_PrimaryStream.UnsafeUpdateValue(strPrimaryStream);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnStreamReaderDevice::HandleStreamData(XnStreamData* pDataProps, XnCompressionFormats nCompression, XnUInt32 nCompressedSize)
{
XnStatus nRetVal = XN_STATUS_OK;
// find the stream
XnStreamDeviceStreamHolder* pStreamHolder;
nRetVal = FindStream(pDataProps->StreamName, &pStreamHolder);
XN_IS_STATUS_OK(nRetVal);
XnStreamReaderStream* pStream = (XnStreamReaderStream*)pStreamHolder->GetStream();
XnStreamData* pStreamData = pStream->GetStreamData();
// check size
nRetVal = XnStreamDataCheckSize(pStreamData, pStream->GetRequiredDataSize());
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetDataPacker()->ReadStreamData(pStreamData, pStreamHolder->GetCodec());
XN_IS_STATUS_OK(nRetVal);
pStream->NewDataAvailable(pStreamData->nTimestamp, pStreamData->nFrameID);
return (XN_STATUS_OK);
}
bool Multiplexer::SendWaypointToGPS(RoutePoint *prp, wxString &com_name, wxGauge *pProgress)
{
bool ret_bool = false;
DataStream *old_stream = FindStream( com_name );
if( old_stream ) {
SaveStreamProperties( old_stream );
StopAndRemoveStream( old_stream );
}
#ifdef USE_GARMINHOST
#ifdef __WXMSW__
if(com_name.Upper().Matches(_T("*GARMIN*"))) // Garmin USB Mode
{
// if(m_pdevmon)
// m_pdevmon->StopIOThread(true);
int v_init = Garmin_GPS_Init(wxString(_T("usb:")));
if(v_init < 0)
{
wxString msg(_T(" Garmin USB GPS could not be initialized"));
wxLogMessage(msg);
msg.Printf(_T(" Error Code is %d"), v_init);
wxLogMessage(msg);
msg = _T(" LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
}
else
{
wxLogMessage(_T("Garmin USB Initialized"));
wxString msg = _T("USB Unit identifies as: ");
wxString GPS_Unit = Garmin_GPS_GetSaveString();
msg += GPS_Unit;
wxLogMessage(msg);
wxLogMessage(_T("Sending Waypoint..."));
// Create a RoutePointList with one item
RoutePointList rplist;
rplist.Append(prp);
int ret1 = Garmin_GPS_SendWaypoints(wxString(_T("usb:")), &rplist);
if(ret1 != 1)
{
wxLogMessage(_T(" Error Sending Waypoint to Garmin USB"));
wxString msg;
msg = _T(" LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
}
else
ret_bool = true;
}
// if(m_pdevmon)
// m_pdevmon->RestartIOThread();
return ret_bool;
}
#endif
// Are we using Garmin Host mode for uploads?
if(g_bGarminHostUpload)
{
RoutePointList rplist;
int ret_val;
wxString short_com = com_name.Mid(7);
// Initialize the Garmin receiver, build required Jeeps internal data structures
int v_init = Garmin_GPS_Init(short_com);
if(v_init < 0)
{
wxString msg(_T("Garmin GPS could not be initialized on port: "));
msg +=com_name;
wxString err;
err.Printf(_T(" Error Code is %d"), v_init);
msg += err;
msg += _T("\n LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
goto ret_point;
}
else
{
wxString msg(_T("Sent waypoint(s) to Garmin GPS on port: "));
msg +=com_name;
msg += _T("\n Unit identifies as: ");
wxString GPS_Unit = Garmin_GPS_GetSaveString();
msg += GPS_Unit;
wxLogMessage(msg);
}
// Create a RoutePointList with one item
rplist.Append(prp);
ret_val = Garmin_GPS_SendWaypoints(short_com, &rplist);
if(ret_val != 1)
{
wxString msg(_T("Error Sending Waypoint(s) to Garmin GPS on port: "));
msg +=com_name;
wxString err;
err.Printf(_T(" Error Code is %d"), ret_val);
msg += err;
msg += _T("\n LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
goto ret_point;
}
else
ret_bool = true;
goto ret_point;
}
else
#endif //USE_GARMINHOST
{ // Standard NMEA mode
// If the port was temporarily closed, reopen as I/O type
// Otherwise, open another port using default properties
wxString baud;
if( old_stream ) {
baud = baud_rate_save;
}
else {
baud = _T("4800");
}
DataStream *dstr = new DataStream( this,
com_name,
baud,
DS_TYPE_INPUT_OUTPUT,
0 );
SENTENCE snt;
NMEA0183 oNMEA0183;
oNMEA0183.TalkerID = _T ( "EC" );
if ( pProgress )
pProgress->SetRange ( 100 );
if(g_GPS_Ident == _T("Generic"))
{
if ( prp->m_lat < 0. )
oNMEA0183.Wpl.Position.Latitude.Set ( -prp->m_lat, _T ( "S" ) );
else
oNMEA0183.Wpl.Position.Latitude.Set ( prp->m_lat, _T ( "N" ) );
if ( prp->m_lon < 0. )
oNMEA0183.Wpl.Position.Longitude.Set ( -prp->m_lon, _T ( "W" ) );
else
oNMEA0183.Wpl.Position.Longitude.Set ( prp->m_lon, _T ( "E" ) );
oNMEA0183.Wpl.To = prp->GetName().Truncate ( 6 );
oNMEA0183.Wpl.Write ( snt );
}
else if(g_GPS_Ident == _T("FurunoGP3X"))
{
oNMEA0183.TalkerID = _T ( "PFEC," );
if ( prp->m_lat < 0. )
oNMEA0183.GPwpl.Position.Latitude.Set ( -prp->m_lat, _T ( "S" ) );
else
oNMEA0183.GPwpl.Position.Latitude.Set ( prp->m_lat, _T ( "N" ) );
if ( prp->m_lon < 0. )
oNMEA0183.GPwpl.Position.Longitude.Set ( -prp->m_lon, _T ( "W" ) );
else
oNMEA0183.GPwpl.Position.Longitude.Set ( prp->m_lon, _T ( "E" ) );
oNMEA0183.GPwpl.To = prp->GetName().Truncate ( 8 );
oNMEA0183.GPwpl.Write ( snt );
}
if( dstr->SendSentence( snt.Sentence ) )
LogOutputMessage( snt.Sentence, dstr->GetPort(), false );
wxString msg(_T("-->GPS Port:"));
msg += com_name;
msg += _T(" Sentence: ");
msg += snt.Sentence;
msg.Trim();
wxLogMessage(msg);
if(g_GPS_Ident == _T("FurunoGP3X"))
{
wxString term;
term.Printf(_T("$PFEC,GPxfr,CTL,E%c%c"), 0x0d, 0x0a);
if( dstr->SendSentence( term ) )
LogOutputMessage( term, dstr->GetPort(), false );
wxString msg(_T("-->GPS Port:"));
msg += com_name;
msg += _T(" Sentence: ");
msg += term;
msg.Trim();
wxLogMessage(msg);
}
if ( pProgress )
{
pProgress->SetValue ( 100 );
pProgress->Refresh();
pProgress->Update();
}
wxMilliSleep ( 500 );
// All finished with the temp port
dstr->Close();
ret_bool = true;
}
ret_point:
if( old_stream )
CreateAndRestoreSavedStreamProperties();
return ret_bool;
}
bool Multiplexer::SendRouteToGPS(Route *pr, wxString &com_name, bool bsend_waypoints, wxGauge *pProgress)
{
bool ret_bool = false;
DataStream *old_stream = FindStream( com_name );
if( old_stream ) {
SaveStreamProperties( old_stream );
StopAndRemoveStream( old_stream );
}
#ifdef USE_GARMINHOST
#ifdef __WXMSW__
if(com_name.Upper().Matches(_T("*GARMIN*"))) // Garmin USB Mode
{
// if(m_pdevmon)
// m_pdevmon->StopIOThread(true);
int v_init = Garmin_GPS_Init(wxString(_T("usb:")));
if(v_init < 0)
{
wxString msg(_T(" Garmin USB GPS could not be initialized"));
wxLogMessage(msg);
msg.Printf(_T(" Error Code is %d"), v_init);
wxLogMessage(msg);
msg = _T(" LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
}
else
{
wxLogMessage(_T("Garmin USB Initialized"));
wxString msg = _T("USB Unit identifies as: ");
wxString GPS_Unit = Garmin_GPS_GetSaveString();
msg += GPS_Unit;
wxLogMessage(msg);
wxLogMessage(_T("Sending Routes..."));
int ret1 = Garmin_GPS_SendRoute(wxString(_T("usb:")), pr, pProgress);
if(ret1 != 1)
{
wxLogMessage(_T(" Error Sending Routes"));
wxString msg;
msg = _T(" LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
}
else
ret_bool = true;
}
// if(m_pdevmon)
// m_pdevmon->RestartIOThread();
goto ret_point_1;
}
#endif
if(g_bGarminHostUpload)
{
int ret_val;
if ( pProgress )
{
pProgress->SetValue ( 20 );
pProgress->Refresh();
pProgress->Update();
}
wxString short_com = com_name.Mid(7);
// Initialize the Garmin receiver, build required Jeeps internal data structures
int v_init = Garmin_GPS_Init(short_com);
if(v_init < 0)
{
wxString msg(_T("Garmin GPS could not be initialized on port: "));
msg +=short_com;
wxString err;
err.Printf(_T(" Error Code is %d"), v_init);
msg += err;
msg += _T("\n LastGarminError is: ");
msg += GetLastGarminError();
wxLogMessage(msg);
ret_bool = false;
goto ret_point;
}
else
{
wxString msg(_T("Sent Route to Garmin GPS on port: "));
msg +=short_com;
msg += _T("\n Unit identifies as: ");
wxString GPS_Unit = Garmin_GPS_GetSaveString();
msg += GPS_Unit;
wxLogMessage(msg);
}
if ( pProgress )
{
pProgress->SetValue ( 40 );
pProgress->Refresh();
pProgress->Update();
}
ret_val = Garmin_GPS_SendRoute(short_com, pr, pProgress);
if(ret_val != 1)
{
wxString msg(_T("Error Sending Route to Garmin GPS on port: "));
msg +=short_com;
wxString err;
err.Printf(_T(" Error Code is %d"), ret_val);
msg += _T("\n LastGarminError is: ");
msg += GetLastGarminError();
msg += err;
wxLogMessage(msg);
ret_bool = false;
goto ret_point;
}
else
ret_bool = true;
ret_point:
if ( pProgress )
{
pProgress->SetValue ( 100 );
pProgress->Refresh();
pProgress->Update();
}
wxMilliSleep ( 500 );
goto ret_point_1;
}
else
#endif //USE_GARMINHOST
{
{ // Standard NMEA mode
// If the port was temporarily closed, reopen as I/O type
// Otherwise, open another port using default properties
wxString baud;
if( old_stream ) {
baud = baud_rate_save;
}
else {
baud = _T("4800");
}
DataStream *dstr = new DataStream( this,
com_name,
baud,
DS_TYPE_INPUT_OUTPUT,
0 );
SENTENCE snt;
NMEA0183 oNMEA0183;
oNMEA0183.TalkerID = _T ( "EC" );
int nProg = pr->pRoutePointList->GetCount() + 1;
if ( pProgress )
pProgress->SetRange ( 100 );
int progress_stall = 500;
if(pr->pRoutePointList->GetCount() > 10)
progress_stall = 500;
// Send out the waypoints, in order
if ( bsend_waypoints )
{
wxRoutePointListNode *node = pr->pRoutePointList->GetFirst();
int ip = 1;
while ( node )
{
RoutePoint *prp = node->GetData();
if(g_GPS_Ident == _T("Generic"))
{
if ( prp->m_lat < 0. )
oNMEA0183.Wpl.Position.Latitude.Set ( -prp->m_lat, _T ( "S" ) );
else
oNMEA0183.Wpl.Position.Latitude.Set ( prp->m_lat, _T ( "N" ) );
if ( prp->m_lon < 0. )
oNMEA0183.Wpl.Position.Longitude.Set ( -prp->m_lon, _T ( "W" ) );
else
oNMEA0183.Wpl.Position.Longitude.Set ( prp->m_lon, _T ( "E" ) );
oNMEA0183.Wpl.To = prp->GetName().Truncate ( 6 );
oNMEA0183.Wpl.Write ( snt );
}
else if(g_GPS_Ident == _T("FurunoGP3X"))
{
oNMEA0183.TalkerID = _T ( "PFEC," );
if ( prp->m_lat < 0. )
oNMEA0183.GPwpl.Position.Latitude.Set ( -prp->m_lat, _T ( "S" ) );
else
oNMEA0183.GPwpl.Position.Latitude.Set ( prp->m_lat, _T ( "N" ) );
if ( prp->m_lon < 0. )
oNMEA0183.GPwpl.Position.Longitude.Set ( -prp->m_lon, _T ( "W" ) );
else
oNMEA0183.GPwpl.Position.Longitude.Set ( prp->m_lon, _T ( "E" ) );
oNMEA0183.GPwpl.To = prp->GetName().Truncate ( 8 );
oNMEA0183.GPwpl.Write ( snt );
}
if( dstr->SendSentence( snt.Sentence ) )
LogOutputMessage( snt.Sentence, dstr->GetPort(), false );
wxString msg(_T("-->GPS Port:"));
msg += com_name;
msg += _T(" Sentence: ");
msg += snt.Sentence;
msg.Trim();
wxLogMessage(msg);
if ( pProgress )
{
pProgress->SetValue ( ( ip * 100 ) / nProg );
pProgress->Refresh();
pProgress->Update();
}
wxMilliSleep ( progress_stall );
node = node->GetNext();
ip++;
}
}
// Create the NMEA Rte sentence
oNMEA0183.Rte.Empty();
oNMEA0183.Rte.TypeOfRoute = CompleteRoute;
if ( pr->m_RouteNameString.IsEmpty() )
oNMEA0183.Rte.RouteName = _T ( "1" );
else
oNMEA0183.Rte.RouteName = pr->m_RouteNameString;
if(g_GPS_Ident == _T("FurunoGP3X"))
{
oNMEA0183.Rte.RouteName = _T ( "1" );
oNMEA0183.TalkerID = _T ( "GP" );
}
oNMEA0183.Rte.total_number_of_messages = 1;
oNMEA0183.Rte.message_number = 1;
// add the waypoints
wxRoutePointListNode *node = pr->pRoutePointList->GetFirst();
while ( node )
{
RoutePoint *prp = node->GetData();
wxString name = prp->GetName().Truncate ( 6 );
if(g_GPS_Ident == _T("FurunoGP3X"))
{
name = prp->GetName().Truncate ( 7 );
name.Prepend(_T(" "));
}
oNMEA0183.Rte.AddWaypoint ( name );
node = node->GetNext();
}
oNMEA0183.Rte.Write ( snt );
unsigned int max_length = 70;
if(snt.Sentence.Len() > max_length)
{
// Make a route with one waypoint to get tare load.
NMEA0183 tNMEA0183;
SENTENCE tsnt;
tNMEA0183.TalkerID = _T ( "EC" );
tNMEA0183.Rte.Empty();
tNMEA0183.Rte.TypeOfRoute = CompleteRoute;
if(g_GPS_Ident != _T("FurunoGP3X"))
{
if ( pr->m_RouteNameString.IsEmpty() )
tNMEA0183.Rte.RouteName = _T ( "1" );
else
tNMEA0183.Rte.RouteName = pr->m_RouteNameString;
tNMEA0183.Rte.AddWaypoint ( _T("123456") );
}
else
{
if (( pr->m_RouteNameString.IsNumber() ) &&
( pr->m_RouteNameString.Len() <= 2 ) ) {
if( pr->m_RouteNameString.Len() == 2) {
tNMEA0183.Rte.RouteName = pr->m_RouteNameString;
}
else {
tNMEA0183.Rte.RouteName = _T("0");
tNMEA0183.Rte.RouteName += pr->m_RouteNameString;
}
}
else
{
tNMEA0183.Rte.RouteName = _T ( "01" );
}
tNMEA0183.Rte.AddWaypoint ( _T(" 1234567") );
}
tNMEA0183.Rte.Write ( tsnt );
unsigned int tare_length = tsnt.Sentence.Len();
wxArrayString sentence_array;
// Trial balloon: add the waypoints, with length checking
int n_total = 1;
bool bnew_sentence = true;
int sent_len=0;
wxRoutePointListNode *node = pr->pRoutePointList->GetFirst();
while ( node )
{
RoutePoint *prp = node->GetData();
unsigned int name_len = prp->GetName().Truncate ( 6 ).Len();
if(g_GPS_Ident == _T("FurunoGP3X"))
name_len = 1 + prp->GetName().Truncate ( 7 ).Len();
if(bnew_sentence)
{
sent_len = tare_length;
sent_len += name_len;
bnew_sentence = false;
node = node->GetNext();
}
else
{
if(sent_len + name_len > max_length)
{
n_total ++;
bnew_sentence = true;
}
else
{
sent_len += name_len;
node = node->GetNext();
}
}
}
// Now we have the sentence count, so make the real sentences using the same counting logic
int final_total = n_total;
int n_run = 1;
bnew_sentence = true;
node = pr->pRoutePointList->GetFirst();
while ( node )
{
RoutePoint *prp = node->GetData();
wxString name = prp->GetName().Truncate ( 6 );
if(g_GPS_Ident == _T("FurunoGP3X"))
{
name = prp->GetName().Truncate ( 7 );
name.Prepend(_T(" "));
}
unsigned int name_len = name.Len();
if(bnew_sentence)
{
sent_len = tare_length;
sent_len += name_len;
bnew_sentence = false;
oNMEA0183.Rte.Empty();
oNMEA0183.Rte.TypeOfRoute = CompleteRoute;
if(g_GPS_Ident != _T("FurunoGP3X"))
{
if ( pr->m_RouteNameString.IsEmpty() )
oNMEA0183.Rte.RouteName = _T ( "1" );
else
oNMEA0183.Rte.RouteName = pr->m_RouteNameString;
}
else {
if (( pr->m_RouteNameString.IsNumber() ) &&
( pr->m_RouteNameString.Len() <= 2 ) ) {
if( pr->m_RouteNameString.Len() == 2) {
oNMEA0183.Rte.RouteName = pr->m_RouteNameString;
}
else {
oNMEA0183.Rte.RouteName = _T("0");
oNMEA0183.Rte.RouteName += pr->m_RouteNameString;
}
}
else {
oNMEA0183.Rte.RouteName = _T ( "01" );
}
}
oNMEA0183.Rte.total_number_of_messages = final_total;
oNMEA0183.Rte.message_number = n_run;
snt.Sentence.Clear();
oNMEA0183.Rte.AddWaypoint ( name );
node = node->GetNext();
}
else
{
if(sent_len + name_len > max_length)
{
n_run ++;
bnew_sentence = true;
oNMEA0183.Rte.Write ( snt );
// printf("%s", snt.Sentence.mb_str());
sentence_array.Add(snt.Sentence);
}
else
{
sent_len += name_len;
oNMEA0183.Rte.AddWaypoint ( name );
node = node->GetNext();
}
}
}
oNMEA0183.Rte.Write ( snt ); //last one...
if(snt.Sentence.Len() > tare_length)
sentence_array.Add(snt.Sentence);
for(unsigned int ii=0 ; ii < sentence_array.GetCount(); ii++)
{
if(dstr->SendSentence( sentence_array.Item(ii) ) )
LogOutputMessage( sentence_array.Item(ii), dstr->GetPort(), false );
wxString msg(_T("-->GPS Port:"));
msg += com_name;
msg += _T(" Sentence: ");
msg += sentence_array.Item(ii);
msg.Trim();
wxLogMessage(msg);
wxMilliSleep ( 500 );
}
}
else
{
if( dstr->SendSentence( snt.Sentence ) )
LogOutputMessage( snt.Sentence, dstr->GetPort(), false );
wxString msg(_T("-->GPS Port:"));
msg += com_name;
msg += _T(" Sentence: ");
msg += snt.Sentence;
msg.Trim();
wxLogMessage(msg);
}
if(g_GPS_Ident == _T("FurunoGP3X"))
{
wxString term;
term.Printf(_T("$PFEC,GPxfr,CTL,E%c%c"), 0x0d, 0x0a);
if( dstr->SendSentence( term ) )
LogOutputMessage( term, dstr->GetPort(), false );
wxString msg(_T("-->GPS Port:"));
msg += com_name;
msg += _T(" Sentence: ");
msg += term;
msg.Trim();
wxLogMessage(msg);
}
if ( pProgress )
{
pProgress->SetValue ( 100 );
pProgress->Refresh();
pProgress->Update();
}
wxMilliSleep ( 500 );
ret_bool = true;
// All finished with the temp port
dstr->Close();
}
}
ret_point_1:
if( old_stream )
CreateAndRestoreSavedStreamProperties();
return ret_bool;
}
void MpegDemultiplexer::PES_packet()
{
int stream_id = m_file->m_next_code & 0xff;
uint16 PES_packet_length = m_file->getnbits(16);
m_file->m_countBits = 0;
switch (stream_id)
{
case 0xbc/*program_stream_map*/:
{
ASSERT(0);
}
break;
case 0xbf/*private-stream2*/:
{
/*m_file->m_bytepos =*/ m_file->SetBytePos(m_file->GetBytePos() + PES_packet_length);
//m_file->m_nstacked = 0;
}
break;
case 0xbe/*padding*/:
{
// Maybe check that all bytes are 0xFF
/*m_file->m_bytepos =*/ m_file->SetBytePos(m_file->GetBytePos() + PES_packet_length);
//m_file->m_nstacked = 0;
}
break;
default:
{
int fill = m_file->getnbits(2);
ASSERT(fill == 2);
int PES_scrambling_control = m_file->getnbits(2);// bslbf
int PES_priority = m_file->getbit();// bslbf
int data_alignment_indicator = m_file->getbit();// bslbf
int copyright = m_file->getbit();// bslbf
int original_or_copy = m_file->getbit();// bslbf
int PTS_DTS_flags = m_file->getnbits(2);// bslbf
int ESCR_flag = m_file->getbit();// bslbf
int ES_rate_flag = m_file->getbit();// bslbf
int DSM_trick_mode_flag = m_file->getbit();// bslbf
int additional_copy_info_flag = m_file->getbit();// bslbf
int PES_CRC_flag = m_file->getbit();// bslbf
int PES_extension_flag = m_file->getbit();// bslbf
uint8 PES_header_data_length = m_file->getnbits(8);
if (PTS_DTS_flags == 2)
{
int fill = m_file->getnbits(4);// '0010' 4 bslbf
ASSERT(fill == 2);
m_file->getnbits(3);//PTS [32..30] 3 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
m_file->getnbits(15);//PTS [29..15] 15 bslbf
m_file->getmarkerbit();// 1 bslbf
m_file->getnbits(15);//PTS [14..0] 15 bslbf
m_file->getmarkerbit();// 1 bslbf
}
else if (PTS_DTS_flags == 3)
{
int fill = m_file->getnbits(4);//
ASSERT(fill == 3);//'0011' 4 bslbf
m_file->getnbits(3);//PTS [32..30] 3 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
m_file->getnbits(15);//PTS [29..15] 15 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
m_file->getnbits(15);//PTS [14..0] 15 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
fill = m_file->getnbits(4);//marker_bit 1 bslbf
ASSERT(fill == 1);//'0001' 4 bslbf
m_file->getnbits(3);//DTS [32..30] 3 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
m_file->getnbits(15);//DTS [29..15] 15 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
m_file->getnbits(15);//DTS [14..0] 15 bslbf
m_file->getmarkerbit();//marker_bit 1 bslbf
}
if (ESCR_flag == 1)
{
ASSERT(0);
/*
reserved 2 bslbf
ESCR_base[32..30] 3 bslbf
marker_bit 1 bslbf
ESCR_base[29..15] 15 bslbf
marker_bit 1 bslbf
ESCR_base[14..0] 15 bslbf
marker_bit 1 bslbf
ESCR_extension 9 uimsbf
marker_bit 1 bslbf
*/
}
if (ES_rate_flag == 1)
{
ASSERT(0);
/*
marker_bit 1 bslbf
ES_rate 22 uimsbf
marker_bit 1 bslbf
*/
}
if (DSM_trick_mode_flag == 1)
{
ASSERT(0);
/*
trick_mode_control 3 uimsbf
if ( trick_mode_control = = fast_forward )
{
field_id 2 bslbf
intra_slice_refresh 1 bslbf
frequency_truncation 2 bslbf
}
else if ( trick_mode_control = = slow_motion )
{
rep_cntrl 5 uimsbf
}
else if ( trick_mode_control = = freeze_frame )
{
field_id 2 uimsbf
reserved 3 bslbf
}
else if ( trick_mode_control = = fast_reverse )
{
field_id 2 bslbf
intra_slice_refresh 1 bslbf
frequency_truncation 2 bslbf
}
else if ( trick_mode_control = = slow_reverse )
{
rep_cntrl 5 uimsbf
}
else
reserved 5 bslbf
*/
}
if (additional_copy_info_flag == 1)
{
m_file->getmarkerbit();// 1 bslbf
int additional_copy_info = m_file->getnbits(7);// bslbf
}
if (PES_CRC_flag == 1)
{
int previous_PES_packet_CRC = m_file->getnbits(16);// bslbf
}
if (PES_extension_flag == 1)
{
int PES_private_data_flag = m_file->getbit();// bslbf
int pack_header_field_flag = m_file->getbit();// 1 bslbf
int program_packet_sequence_counter_flag = m_file->getbit();// 1 bslbf
int P_STD_buffer_flag = m_file->getnbits(1);// 1 bslbf
m_file->getnbits(3);//reserved 3 bslbf
int PES_extension_flag_2 = m_file->getbit();// 1 bslbf
if ( PES_private_data_flag == 1)
{
m_file->skipnbits(128);
//PES_private_data 128 bslbf
}
if (pack_header_field_flag == 1)
{
int pack_field_length = m_file->getnbits(8);// uimsbf
pack_header();
}
if (program_packet_sequence_counter_flag == 1)
{
ASSERT(0);
/*
marker_bit 1 bslbf
program_packet_sequence_counter 7 uimsbf
marker_bit 1 bslbf
MPEG1_MPEG2_identifier 1 bslbf
original_stuff_length 6 uimsbf
*/
}
if (P_STD_buffer_flag == 1)
{
int fill = m_file->getnbits(2);//'01' 2 bslbf
ASSERT(fill == 1);
int P_STD_buffer_scale = m_file->getbit();//1 bslbf
int P_STD_buffer_size = m_file->getnbits(13);//13 uimsbf
}
if (PES_extension_flag_2 == 1)
{
m_file->getmarkerbit();// 1 bslbf
uint8 PES_extension_field_length = m_file->getnbits(7);// uimsbf
for (int i = 0; i < PES_extension_field_length; i++)
{
//reserved 8 bslbf
uint8 reserved = m_file->getnbits(8);
}
}
}
int i;
ASSERT((m_file->m_countBits & 0x3) == 0);
int n = (m_file->m_countBits >> 3);
int N1 = n - (PES_header_data_length+3);
int N2 = PES_packet_length - n;
for (i = 0; i < N1; i++)
{
m_file->getnbits(8);//stuffing_byte 8 bslbf
}
MpegStream* pStream = FindStream(stream_id);
if (pStream == NULL) // ???
{
pStream = new MpegStream;
pStream->m_pFilter = this;
pStream->m_stream_id = stream_id;
m_streams.push_back(pStream);
}
CPacket* pPacket = NULL;
if (pStream)
{
pPacket = new CPacket;
pPacket->m_pStream = pStream;
pStream->m_packets.push_back(pPacket);
}
pPacket->m_byteOffset = m_file->GetBytePos();
pPacket->m_byteLength = N2;
pStream->m_byteLength += pPacket->m_byteLength;
m_file->SetBytePos(pPacket->m_byteOffset + N2);
/*
for (i = 0; i < N2; i++)
{
m_file->getnbits(8);//PES_packet_data_byte 8 bslbf
}
*/
}
break;
}
m_file->next_start_code();
}
void Multiplexer::OnEvtStream(OCPN_DataStreamEvent& event)
{
wxString message = wxString(event.GetNMEAString().c_str(), wxConvUTF8);
wxString port = wxString(event.GetStreamName().c_str(), wxConvUTF8);
DataStream *stream = FindStream(port);
if( !message.IsEmpty() )
{
//Send to core consumers
//if it passes the source's input filter
// If there is no datastream, as for PlugIns, then pass everything
bool bpass = true;
if( stream )
bpass = stream->SentencePassesFilter( message, FILTER_INPUT );
if( bpass ) {
if( message.Mid(3,3).IsSameAs(_T("VDM")) ||
message.Mid(1,5).IsSameAs(_T("FRPOS")) ||
message.Mid(1,2).IsSameAs(_T("CD")) )
{
if( m_aisconsumer )
m_aisconsumer->AddPendingEvent(event);
}
else
{
if( m_gpsconsumer )
m_gpsconsumer->AddPendingEvent(event);
}
// Handle AIVDO messages from transponder....
if( message.Mid(3,3).IsSameAs(_T("VDO")) ) {
if( m_gpsconsumer )
m_gpsconsumer->AddPendingEvent(event);
}
}
//Send to the Debug Window, if open
LogInputMessage( message, port, !bpass );
//Send to plugins
if ( g_pi_manager )
g_pi_manager->SendNMEASentenceToAllPlugIns( message );
//Send to all the other outputs
for (size_t i = 0; i < m_pdatastreams->Count(); i++)
{
DataStream* s = m_pdatastreams->Item(i);
if ( s->IsOk() ) {
if((s->GetConnectionType() == SERIAL) || (s->GetPort() != port)) {
if ( s->GetIoSelect() == DS_TYPE_INPUT_OUTPUT || s->GetIoSelect() == DS_TYPE_OUTPUT ) {
bool bout_filter = true;
if(s->SentencePassesFilter( message, FILTER_OUTPUT ) ) {
s->SendSentence(message);
bout_filter = false;
}
//Send to the Debug Window, if open
LogOutputMessage( message, port, bout_filter );
}
}
}
}
}
}
extern "C" ULONG __far __loadds __cdecl DDCMD_EntryPoint(PDDCMDCOMMON pCommon)
{
STREAM *pstream = FindStream(pCommon->hStream);
// printf("MPU: DDCMD %lu stream=%p\n",pCommon->ulFunction,(void __far *) pstream);
switch (pCommon->ulFunction) {
case DDCMD_SETUP: {
Trace(TRACE_DDCMD_SETUP, (ULONG) (void __far *) pstream);
if (!pstream) return ERROR_INVALID_STREAM;
PDDCMDSETUP p = (PDDCMDSETUP) pCommon;
SETUP_PARM __far *psp = (SETUP_PARM __far *) p->pSetupParm;
pstream->ulCurrentTime = psp->ulStreamTime;
if (p->ulSetupParmSize > sizeof(ULONG)) {
fRecurringSupported = TRUE;
psp->ulFlags = SETUP_RECURRING_EVENTS;
}
break;
}
case DDCMD_READ:
Trace(TRACE_DDCMD_READ, (ULONG) (void __far *) pstream);
return ERROR_INVALID_FUNCTION;
case DDCMD_WRITE: {
Trace(TRACE_DDCMD_WRITE, (ULONG) (void __far *) pstream);
if (!pstream) return ERROR_INVALID_STREAM;
PDDCMDREADWRITE p = (PDDCMDREADWRITE) pCommon;
pstream->Write((PSTREAMBUF) p->pBuffer,(unsigned) p->ulBufferSize);
break;
}
case DDCMD_STATUS: {
Trace(TRACE_DDCMD_STATUS, (ULONG) (void __far *) pstream);
if (!pstream) return ERROR_INVALID_STREAM;
PDDCMDSTATUS p = (PDDCMDSTATUS) pCommon;
PSTATUS_PARM p2 = (PSTATUS_PARM) p->pStatus;
p2->ulTime = pstream->ulCurrentTime;
break;
}
case DDCMD_CONTROL: {
if (!pstream) return ERROR_INVALID_STREAM;
PDDCMDCONTROL p = (PDDCMDCONTROL) pCommon;
return pstream->Control(p);
}
case DDCMD_REG_STREAM: {
Trace(TRACE_DDCMD_REGISTER, (ULONG) (void __far *) pstream);
if (pstream)
return ERROR_HNDLR_REGISTERED;
pstream = FindFile(((PDDCMDREGISTER) pCommon)->ulSysFileNum);
if (!pstream)
return ERROR_STREAM_CREATION;
pstream->Register((PDDCMDREGISTER) pCommon);
return 0;
}
case DDCMD_DEREG_STREAM:
Trace(TRACE_DDCMD_DEREG, (ULONG) (void __far *) pstream);
if (!pstream) return ERROR_INVALID_STREAM;
pstream->DeRegister();
break;
default:
return ERROR_INVALID_FUNCTION;
}
return NO_ERROR;
}
