void XnFrameStreamProcessor::OnEndOfFrame(const XnSensorProtocolResponseHeader* pHeader) { // write dump XnBuffer* pCurWriteBuffer = m_pTripleBuffer->GetWriteBuffer(); xnDumpFileWriteBuffer(m_InternalDump, pCurWriteBuffer->GetData(), pCurWriteBuffer->GetSize()); xnDumpFileClose(m_InternalDump); xnDumpFileClose(m_InDump); if (!m_bFrameCorrupted) { // mark the buffer as stable XnUInt64 nTimestamp; if (m_pDevicePrivateData->pSensor->ShouldUseHostTimestamps()) { // use the host timestamp of the first packet nTimestamp = m_nFirstPacketTimestamp; } else { // use timestamp in last packet nTimestamp = CreateTimestampFromDevice(pHeader->nTimeStamp); } OniFrame* pFrame = m_pTripleBuffer->GetWriteFrame(); pFrame->timestamp = nTimestamp; XnUInt32 nFrameID; m_pTripleBuffer->MarkWriteBufferAsStable(&nFrameID); // let inheriting classes do their stuff OnFrameReady(nFrameID, nTimestamp); } else { // restart m_pTripleBuffer->GetWriteBuffer()->Reset(); } // log bandwidth XnUInt64 nSysTime; xnOSGetTimeStamp(&nSysTime); xnDumpFileWriteString(m_pDevicePrivateData->BandwidthDump, "%llu,%s,%d,%d\n", nSysTime, m_csName, GetCurrentFrameID(), m_nBytesReceived); // re-init dumps m_InDump = xnDumpFileOpen(m_csInDumpMask, "%s_%d.raw", m_csInDumpMask, GetCurrentFrameID()); m_InternalDump = xnDumpFileOpen(m_csInternalDumpMask, "%s_%d.raw", m_csInternalDumpMask, GetCurrentFrameID()); m_nBytesReceived = 0; }
XnStatus XnDeviceBase::InitImpl(const XnDeviceConfig* pDeviceConfig) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(pDeviceConfig); // create device module nRetVal = CreateDeviceModule(&m_pDevicePropertiesHolder); XN_IS_STATUS_OK(nRetVal); // check if we have initial values for device modules XnActualPropertiesHash* pDeviceModuleInitialProps = NULL; if (pDeviceConfig->pInitialValues != NULL) { pDeviceConfig->pInitialValues->pData->Get(XN_MODULE_NAME_DEVICE, pDeviceModuleInitialProps); } // init device module nRetVal = m_pDevicePropertiesHolder->Init(pDeviceModuleInitialProps); XN_IS_STATUS_OK(nRetVal); // add the device module nRetVal = AddModule(m_pDevicePropertiesHolder); XN_IS_STATUS_OK(nRetVal); // init dump m_StreamsDataDump = xnDumpFileOpen(XN_DUMP_STREAMS_DATA, "%s.csv", XN_DUMP_STREAMS_DATA); return (XN_STATUS_OK); }
XnAudioProcessor::XnAudioProcessor(XnSensorAudioStream* pStream, XnSensorStreamHelper* pHelper, XnUInt32 nInputPacketSize) : XnWholePacketProcessor(pHelper->GetPrivateData(), pStream->GetType(), nInputPacketSize), m_pStream(pStream), m_pHelper(pHelper), m_AudioInDump(NULL) { m_AudioInDump = xnDumpFileOpen(XN_DUMP_AUDIO_IN, "AudioIn.pcm"); }
XnStatus XnSensor::InitReading() { XnStatus nRetVal = XN_STATUS_OK; // open data endpoints nRetVal = m_SensorIO.OpenDataEndPoints((XnSensorUsbInterface)m_Interface.GetValue(), *m_Firmware.GetInfo()); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Interface.UnsafeUpdateValue(m_SensorIO.GetCurrentInterface()); XN_IS_STATUS_OK(nRetVal); // take frequency information XnFrequencyInformation FrequencyInformation; nRetVal = XnHostProtocolAlgorithmParams(&m_DevicePrivateData, XN_HOST_PROTOCOL_ALGORITHM_FREQUENCY, &FrequencyInformation, sizeof(XnFrequencyInformation), (XnResolutions)0, 0); if (nRetVal != XN_STATUS_OK) return nRetVal; m_DevicePrivateData.fDeviceFrequency = XN_PREPARE_VAR_FLOAT_IN_BUFFER(FrequencyInformation.fDeviceFrequency); // Init Dumps m_DevicePrivateData.BandwidthDump = xnDumpFileOpen(XN_DUMP_BANDWIDTH, "Bandwidth.csv"); xnDumpFileWriteString(m_DevicePrivateData.BandwidthDump, "Timestamp,Frame Type,Frame ID,Size\n"); m_DevicePrivateData.TimestampsDump = xnDumpFileOpen(XN_DUMP_TIMESTAMPS, "Timestamps.csv"); xnDumpFileWriteString(m_DevicePrivateData.TimestampsDump, "Host Time (us),Stream,Device TS,Time (ms),Comments\n"); m_DevicePrivateData.MiniPacketsDump = xnDumpFileOpen(XN_DUMP_MINI_PACKETS, "MiniPackets.csv"); xnDumpFileWriteString(m_DevicePrivateData.MiniPacketsDump, "HostTS,Type,ID,Size,Timestamp\n"); m_DevicePrivateData.nGlobalReferenceTS = 0; nRetVal = xnOSCreateCriticalSection(&m_DevicePrivateData.hEndPointsCS); XN_IS_STATUS_OK(nRetVal); // NOTE: when we go up, some streams might be open, and so we'll receive lots of garbage. // wait till streams are turned off, and then start reading. // pDevicePrivateData->bIgnoreDataPackets = TRUE; // open input threads nRetVal = XnDeviceSensorOpenInputThreads(GetDevicePrivateData(), (XnBool)m_ReadFromEP1.GetValue(), (XnBool)m_ReadFromEP2.GetValue(), (XnBool)m_ReadFromEP3.GetValue()); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
//--------------------------------------------------------------------------- // Code //--------------------------------------------------------------------------- XnFrameStreamProcessor::XnFrameStreamProcessor(XnFrameStream* pStream, XnSensorStreamHelper* pHelper, XnFrameBufferManager* pBufferManager, XnUInt16 nTypeSOF, XnUInt16 nTypeEOF) : XnStreamProcessor(pStream, pHelper), m_nTypeSOF(nTypeSOF), m_nTypeEOF(nTypeEOF), m_pTripleBuffer(pBufferManager), m_InDump(NULL), m_InternalDump(NULL), m_bFrameCorrupted(FALSE), m_bAllowDoubleSOF(FALSE), m_nLastSOFPacketID(0), m_nFirstPacketTimestamp(0), m_nLastSOFTimestamp(0), m_bProcessNextFrame(FALSE) { sprintf(m_csInDumpMask, "%sIn", pStream->GetType()); sprintf(m_csInternalDumpMask, "Internal%s", pStream->GetType()); m_InDump = xnDumpFileOpen(m_csInDumpMask, "%s_0.raw", m_csInDumpMask); m_InternalDump = xnDumpFileOpen(m_csInternalDumpMask, "%s_0.raw", m_csInternalDumpMask); }
void audioInit() { g_AudioData.hWaveOut = NULL; g_AudioData.bFlush = false; g_AudioData.nFirstToCheck = -1; g_AudioData.SyncDump = xnDumpFileOpen(AUDIO_SYNC_DUMP_MASK, "%s.txt", AUDIO_SYNC_DUMP_MASK);; // check if device audio is enabled const AudioMetaData* pAudioMD = getAudioMetaData(); if (pAudioMD == NULL) return; // start audio out device WAVEFORMATEX wf; wf.wFormatTag = 0x0001; // PCM wf.nChannels = pAudioMD->NumberOfChannels(); wf.nSamplesPerSec = pAudioMD->SampleRate(); wf.wBitsPerSample = pAudioMD->BitsPerSample(); wf.nBlockAlign = wf.wBitsPerSample * wf.nChannels / 8; wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec; MMRESULT mmRes = waveOutOpen(&g_AudioData.hWaveOut, WAVE_MAPPER, &wf, (DWORD_PTR)audioCallback, NULL, CALLBACK_FUNCTION); if (mmRes != MMSYSERR_NOERROR) { printf("Warning: Failed opening wave out device. Audio will not be played!\n"); g_AudioData.hWaveOut = NULL; return; } // create some wave headers for playing g_AudioData.pAudioBuffers = new WAVEHDR[NUMBER_OF_AUDIO_BUFFERS]; g_AudioData.pAudioTimestamps = new XnUInt64[NUMBER_OF_AUDIO_BUFFERS]; xnOSMemSet(g_AudioData.pAudioBuffers, 0, sizeof(WAVEHDR)*NUMBER_OF_AUDIO_BUFFERS); // allocate max buffer for one second g_AudioData.nBufferSize = wf.nAvgBytesPerSec; for (int i = 0; i < NUMBER_OF_AUDIO_BUFFERS; ++i) { g_AudioData.pAudioBuffers[i].lpData = new XnChar[g_AudioData.nBufferSize]; g_AudioData.pAudioBuffers[i].dwUser = i; g_AudioData.pAudioBuffers[i].dwFlags = WHDR_DONE; // mark this buffer as empty (already played) } g_AudioData.nAudioNextBuffer = 0; }
XnStatus XnDeviceBase::InitImpl(const XnDeviceConfig* pDeviceConfig) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(pDeviceConfig); // create device module nRetVal = CreateDeviceModule(&m_pDevicePropertiesHolder); XN_IS_STATUS_OK(nRetVal); // check if we have initial values for device modules XnActualPropertiesHash* pDeviceModuleInitialProps = NULL; if (pDeviceConfig->pInitialValues != NULL) { pDeviceConfig->pInitialValues->pData->Get(XN_MODULE_NAME_DEVICE, pDeviceModuleInitialProps); } // init device module nRetVal = m_pDevicePropertiesHolder->Init(pDeviceModuleInitialProps); XN_IS_STATUS_OK(nRetVal); // set read/write mode (we need to do it AFTER module init to override original value) nRetVal = m_ReadWriteMode.UnsafeUpdateValue(pDeviceConfig->DeviceMode); XN_IS_STATUS_OK(nRetVal); nRetVal = m_SharingMode.UnsafeUpdateValue(pDeviceConfig->SharingMode); XN_IS_STATUS_OK(nRetVal); // add the device module nRetVal = AddModule(m_pDevicePropertiesHolder); XN_IS_STATUS_OK(nRetVal); // create the new data event nRetVal = xnOSCreateEvent(&m_hNewDataEvent, FALSE); XN_IS_STATUS_OK(nRetVal); // init dump m_StreamsDataDump = xnDumpFileOpen(XN_DUMP_STREAMS_DATA, "%s.csv", XN_DUMP_STREAMS_DATA); return (XN_STATUS_OK); }
XnStatus LinkContInputStream::StartImpl() { XnStatus nRetVal = XN_STATUS_OK; if (m_bStreaming) { return XN_STATUS_OK; } m_pDumpFile = xnDumpFileOpen(m_strDumpName, "%s", m_strDumpName); //We only need log buffer output if dumping is on m_logParser.GenerateOutputBuffer(m_pDumpFile != NULL); nRetVal = m_pConnection->Connect(); XN_IS_STATUS_OK_LOG_ERROR("Connect stream's input connection", nRetVal); nRetVal = m_pLinkControlEndpoint->StartStreaming(m_nStreamID); XN_IS_STATUS_OK_LOG_ERROR("Start streaming", nRetVal); m_bStreaming = TRUE; return XN_STATUS_OK; }
//--------------------------------------------------------------------------- // Code //--------------------------------------------------------------------------- XnVideoSource::XnVideoSource(LPUNKNOWN lpunk, HRESULT *phr) : CSource(g_videoName, lpunk, CLSID_OpenNIVideo), m_pVideoProcAmp(NULL), m_pCameraControl(NULL), m_Dump(xnDumpFileOpen(XN_MASK_FILTER, "FilterFlow.log")) { ASSERT(phr != NULL); xnLogVerbose(XN_MASK_FILTER, "Creating video source filter"); CAutoLock cAutoLock(&m_cStateLock); // initialize OpenNI XnStatus nRetVal = m_context.Init(); if (nRetVal != XN_STATUS_OK) { xnLogWarning(XN_MASK_FILTER, "Can't init context"); *phr = E_UNEXPECTED; } // try to create an image generator nRetVal = m_image.Create(m_context); if (nRetVal != XN_STATUS_OK) { xnLogWarning(XN_MASK_FILTER, "Can't create image generator"); *phr = VFW_E_NO_CAPTURE_HARDWARE; return; } // create output pins. Every pin registers itself with the source object XnVideoStream* pStream = new XnVideoStream(phr, this, m_image, L"VideoOut"); if (pStream == NULL) { *phr = E_OUTOFMEMORY; } *phr = NOERROR; }
XnStatus XnSensor::InitImpl(const XnDeviceConfig *pDeviceConfig) { XnStatus nRetVal = XN_STATUS_OK; xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Initializing device sensor..."); // Frame Sync XnCallbackHandle hCallbackDummy; nRetVal = m_FrameSync.OnChangeEvent().Register(FrameSyncPropertyChangedCallback, this, hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = GetFirmware()->GetParams()->m_Stream0Mode.OnChangeEvent().Register(FrameSyncPropertyChangedCallback, this, hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = GetFirmware()->GetParams()->m_Stream1Mode.OnChangeEvent().Register(FrameSyncPropertyChangedCallback, this, hCallbackDummy); XN_IS_STATUS_OK(nRetVal); // other stuff m_FrameSyncDump = xnDumpFileOpen(XN_DUMP_FRAME_SYNC, "FrameSync.csv"); xnDumpFileWriteString(m_FrameSyncDump, "HostTime(us),DepthNewData,DepthTimestamp(ms),ImageNewData,ImageTimestamp(ms),Diff(ms),Action\n"); nRetVal = XnDeviceBase::InitImpl(pDeviceConfig); XN_IS_STATUS_OK(nRetVal); // now that everything is configured, open the sensor nRetVal = InitSensor(pDeviceConfig); if (nRetVal != XN_STATUS_OK) { Destroy(); return (nRetVal); } xnLogInfo(XN_MASK_DEVICE_SENSOR, "Device sensor initialized"); return (XN_STATUS_OK); }
XN_C_API void* xnOSLogMemAlloc(void* pMemBlock, XnAllocationType nAllocType, XnUInt32 nBytes, const XnChar* csFunction, const XnChar* csFile, XnUInt32 nLine, const XnChar* csAdditional) { static XnBool bFirstTime = TRUE; static XnBool bReentrent = FALSE; if (bFirstTime) { bFirstTime = FALSE; printf("************************************************************\n"); printf("** WARNING: Memory Profiling is on! **\n"); printf("************************************************************\n"); bReentrent = TRUE; xnOSCreateCriticalSection(&g_hCS); #ifdef XN_MEMORY_PROFILING_DUMP xnDumpSetMaskState("MemProf", TRUE); #endif g_dump = xnDumpFileOpen("MemProf", "MemProfiling.log"); xnDumpFileWriteString(g_dump, "Entry,Address,AllocType,Bytes,Function,File,Line,AdditionalInfo\n"); bReentrent = FALSE; } // ignore stuff that is being allocated during "first time" if (bReentrent) { return pMemBlock; } XnMemBlockDataNode* pNode; pNode = (XnMemBlockDataNode*)xnOSMalloc(sizeof(XnMemBlockDataNode)); pNode->Data.pMemBlock = pMemBlock; pNode->Data.nAllocType = nAllocType; pNode->Data.nBytes = nBytes; pNode->Data.csFunction = csFunction; pNode->Data.csFile = csFile; pNode->Data.nLine = nLine; pNode->Data.csAdditional = csAdditional; pNode->Data.nFrames = XN_MEM_PROF_MAX_FRAMES; xnDumpFileWriteString(g_dump, "Alloc,0x%x,%s,%u,%s,%s,%u,%s\n", pMemBlock, XnGetAllocTypeString(nAllocType), nBytes, csFunction, csFile, nLine, csAdditional); // try to get call stack (skip 2 frames - this one and the alloc func) XnChar* pstrFrames[XN_MEM_PROF_MAX_FRAMES]; for (XnUInt32 i = 0; i < XN_MEM_PROF_MAX_FRAMES; ++i) { pstrFrames[i] = pNode->Data.aFrames[i]; } if (XN_STATUS_OK != xnOSGetCurrentCallStack(2, pstrFrames, XN_MEM_PROF_MAX_FRAME_LEN, &pNode->Data.nFrames)) { pNode->Data.nFrames = 0; } pNode->pNext = NULL; XnAutoCSLocker lock(g_hCS); if (g_allocatedMemory.pLast == NULL) { g_allocatedMemory.pFirst = g_allocatedMemory.pLast = pNode; } else { g_allocatedMemory.pLast->pNext = pNode; g_allocatedMemory.pLast = pNode; } return pMemBlock; }