XnStatus XnPixelStream::FixCropping() { XnStatus nRetVal = XN_STATUS_OK; XnCropping cropping = *GetCropping(); if (cropping.nXOffset > GetXRes() || cropping.nYOffset > GetYRes() || XnUInt32(cropping.nXOffset + cropping.nXSize) > GetXRes() || XnUInt32(cropping.nYOffset + cropping.nYSize) > GetYRes()) { // disable it cropping.bEnabled = FALSE; nRetVal = SetCropping(&cropping); XN_IS_STATUS_OK(nRetVal); } return (XN_STATUS_OK); }
XnStatus XnPixelStream::ValidateCropping(const OniCropping* pCropping) { if (pCropping->enabled) { if (pCropping->originX > (int)GetXRes() || XnUInt32(pCropping->originX + pCropping->width) > GetXRes() || pCropping->originY > (int)GetYRes() || XnUInt32(pCropping->originY + pCropping->height) > GetYRes()) { XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cropping values do not match stream resolution!"); } if (pCropping->width == 0 || pCropping->height == 0) { XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cannot set a cropping window of zero size!"); } } return (XN_STATUS_OK); }
XnStatus XnPixelStream::ValidateCropping(const XnCropping* pCropping) { XnStatus nRetVal = XN_STATUS_OK; if (pCropping->bEnabled) { if (pCropping->nXOffset > GetXRes() || XnUInt32(pCropping->nXOffset + pCropping->nXSize) > GetXRes() || pCropping->nYOffset > GetYRes() || XnUInt32(pCropping->nYOffset + pCropping->nYSize) > GetYRes()) { XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cropping values do not match stream resolution!"); } if (pCropping->nXSize == 0 || pCropping->nYSize == 0) { XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cannot set a cropping window of zero size!"); } } return (XN_STATUS_OK); }
void XnDeviceFileReader::FrameDelay(XnUInt64 nTimestamp) { if (m_FrameDelay.GetValue() != TRUE) return; if (!IsHighResTimestamps()) nTimestamp *= 1000; // first time if (m_nReferenceTime == 0) { xnOSQueryTimer(m_FrameDelayTimer, &m_nReferenceTime); m_nReferenceTimestamp = nTimestamp; return; } // delay XnUInt64 nNow; xnOSQueryTimer(m_FrameDelayTimer, &nNow); // check how much time has passed in the stream XnUInt64 nStreamDiff; if (nTimestamp < m_nReferenceTimestamp) { nStreamDiff = 0; } else { nStreamDiff = nTimestamp - m_nReferenceTimestamp; } // check how much time passed (for user) XnUInt64 nClockDiff = nNow - m_nReferenceTime; // update reference (so that frame delay will work with Pause / Resume) m_nReferenceTime = nNow; m_nReferenceTimestamp = nTimestamp; // check if we need to wait if (nClockDiff < nStreamDiff) { xnOSSleep(XnUInt32((nStreamDiff - nClockDiff) / 1000)); // take this time as a reference xnOSQueryTimer(m_FrameDelayTimer, &m_nReferenceTime); } }
void PlayerDevice::SleepToTimestamp(XnUInt64 nTimeStamp) { XnUInt64 nNow; xnOSGetHighResTimeStamp(&nNow); m_cs.Lock(); XnBool bHasTimeReference = TRUE; if (!m_bHasTimeReference /*&& (nTimeStamp <= m_nStartTimestamp)*/) { m_nStartTimestamp = nTimeStamp; m_nStartTime = nNow; m_bHasTimeReference = TRUE; bHasTimeReference = FALSE; } m_cs.Unlock(); if (bHasTimeReference && (m_dPlaybackSpeed > 0.0f)) { // check this data timestamp compared to when we started XnInt64 nTimestampDiff = nTimeStamp - m_nStartTimestamp; // in some recordings, frames are not ordered by timestamp. Make sure this does not break the mechanism if (nTimestampDiff > 0) { XnInt64 nTimeDiff = nNow - m_nStartTime; // check if we need to wait some time XnInt64 nRequestedTimeDiff = (XnInt64)(nTimestampDiff / m_dPlaybackSpeed); if (nTimeDiff < nRequestedTimeDiff) { XnUInt32 nSleep = XnUInt32((nRequestedTimeDiff - nTimeDiff)/1000); nSleep = XN_MIN(nSleep, XN_PLAYBACK_SPEED_SANITY_SLEEP); xnOSSleep(nSleep); } // update reference to current frame (this will handle cases in which application // stopped reading frames and continued after a while) m_nStartTimestamp = nTimeStamp; xnOSGetHighResTimeStamp(&m_nStartTime); } } }
XnStatus XnPixelStream::CropImpl(OniFrame* pFrame, const OniCropping* pCropping) { XnUChar* pPixelData = (XnUChar*)pFrame->data; XnUInt32 nCurDataSize = 0; for (XnUInt32 y = pCropping->originY; y < XnUInt32(pCropping->originY + pCropping->height); ++y) { XnUChar* pOrigLine = &pPixelData[y * GetXRes() * GetBytesPerPixel()]; // move line xnOSMemCopy(pPixelData + nCurDataSize, pOrigLine + pCropping->originX * GetBytesPerPixel(), pCropping->width * GetBytesPerPixel()); nCurDataSize += pCropping->width * GetBytesPerPixel(); } // update size pFrame->dataSize = nCurDataSize; return XN_STATUS_OK; }
int Util::CheckMissedFrame(const std::string msg, XnUInt64& nTimestamp, XnUInt32* pFrames, XnUInt64* pLastTime, XnUInt32* pMissedFrames) { int ret = 0; ++(*pFrames); // printf("Timestamp(User):%d\n", nTimestamp); // if ((*pLastTime != 0) && ((nTimestamp - *pLastTime) > 35000)) if ((*pLastTime != 0) && (GetTimeDiff(nTimestamp, *pLastTime) > 35)) { int missed = (int)(nTimestamp - *pLastTime) / 32000 - 1; printf("Missed %s: %llu -> %llu = %d > 35000 - %d frames\n", msg.c_str(), *pLastTime, nTimestamp, XnUInt32(nTimestamp - *pLastTime), missed); *pMissedFrames += missed; ret = missed; } *pLastTime = nTimestamp; return ret; }
XN_C_API XnStatus xnOSGetDirName(const XnChar* cpFilePath, XnChar* cpDirName, const XnUInt32 nBufferSize) { char strFullPath[XN_FILE_MAX_PATH]; char* pFileName; DWORD res = GetFullPathName(cpFilePath, XN_FILE_MAX_PATH, strFullPath, &pFileName); if (res == 0) { return XN_STATUS_ERROR; } if (XnUInt32(pFileName - strFullPath) > nBufferSize) { return XN_STATUS_OUTPUT_BUFFER_OVERFLOW; } pFileName[0] = '\0'; strcpy(cpDirName, strFullPath); return XN_STATUS_OK; }
XnStatus XnPixelStream::CropImpl(XnStreamData* pStreamOutput, const XnCropping* pCropping) { XnStatus nRetVal = XN_STATUS_OK; XnUChar* pPixelData = (XnUChar*)pStreamOutput->pData; XnUInt32 nCurDataSize = 0; for (XnUInt32 y = pCropping->nYOffset; y < XnUInt32(pCropping->nYOffset + pCropping->nYSize); ++y) { XnUChar* pOrigLine = &pPixelData[y * GetXRes() * GetBytesPerPixel()]; // move line xnOSMemCopy(pPixelData + nCurDataSize, pOrigLine + pCropping->nXOffset * GetBytesPerPixel(), pCropping->nXSize * GetBytesPerPixel()); nCurDataSize += pCropping->nXSize * GetBytesPerPixel(); } // update size pStreamOutput->nDataSize = nCurDataSize; return XN_STATUS_OK; }
XnStatus PlayerImpl::SetNodeNewData(const XnChar* strNodeName, XnUInt64 nTimeStamp, XnUInt32 nFrame, const void* pData, XnUInt32 nSize) { XnStatus nRetVal = XN_STATUS_OK; XnUInt64 nNow; xnOSGetHighResTimeStamp(&nNow); if (!m_bHasTimeReference) { m_nStartTimestamp = nTimeStamp; m_nStartTime = nNow; m_bHasTimeReference = TRUE; } if (m_dPlaybackSpeed != XN_PLAYBACK_SPEED_FASTEST) { // check this data timestamp compared to when we started XnInt64 nTimestampDiff = nTimeStamp - m_nStartTimestamp; XnInt64 nTimeDiff = nNow - m_nStartTime; // check if we need to wait some time XnInt64 nRequestedTimeDiff = (XnInt64)(nTimestampDiff / m_dPlaybackSpeed); if (nTimeDiff < nRequestedTimeDiff) { xnOSSleep(XnUInt32((nRequestedTimeDiff - nTimeDiff)/1000)); } // update reference to current frame (this will handle cases in which application // stopped reading frames and continued after a while) m_nStartTimestamp = nTimeStamp; xnOSGetHighResTimeStamp(&m_nStartTime); } PlayedNodeInfo playedNode; nRetVal = m_playedNodes.Get(strNodeName, playedNode); XN_IS_STATUS_OK(nRetVal); nRetVal = xnLockedNodeStartChanges(playedNode.hNode, playedNode.hLock); XN_IS_STATUS_OK(nRetVal); nRetVal = xnSetIntProperty(playedNode.hNode, XN_PROP_TIMESTAMP, nTimeStamp); if (nRetVal != XN_STATUS_OK) { xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); return (nRetVal); } nRetVal = xnSetIntProperty(playedNode.hNode, XN_PROP_FRAME_ID, nFrame); if (nRetVal != XN_STATUS_OK) { xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); return (nRetVal); } nRetVal = xnSetGeneralProperty(playedNode.hNode, XN_PROP_NEWDATA, nSize, pData); if (nRetVal != XN_STATUS_OK) { xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); return (nRetVal); } nRetVal = xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
// The recorder int main(int argc, char** argv) { // OpenNi objects xn::Context context; xn::DepthGenerator depthGenerator; xn::ImageGenerator imageGenerator; // To count missed frames XnUInt64 nLastDepthTime = 0; XnUInt64 nLastImageTime = 0; XnUInt32 nMissedDepthFrames = 0; XnUInt32 nMissedImageFrames = 0; XnUInt32 nDepthFrames = 0; XnUInt32 nImageFrames = 0; RecConfiguration config; XnStatus nRetVal = XN_STATUS_OK; // Parse the command line arguments if (!ParseArgs(argc, argv, config)) { printf("Parse error\n"); return 1; } if (config.bVerbose) { // Turn on log xnLogInitSystem(); xnLogSetConsoleOutput(TRUE); xnLogSetMaskMinSeverity(XN_LOG_MASK_ALL, XN_LOG_VERBOSE); } // Initialize OpenNI nRetVal = context.Init(); CHECK_RC(nRetVal, "Init"); nRetVal = ConfigureGenerators(config, context, depthGenerator, imageGenerator); CHECK_RC(nRetVal, "Config generators"); nRetVal = context.StartGeneratingAll(); CHECK_RC(nRetVal, "Generate all"); // Create and initialize the cyclic buffer CyclicBuffer cyclicBuffer(context, depthGenerator, imageGenerator, config); cyclicBuffer.Initialize(config.strDirName, config.nDumpTime); // Mainloop for (;;) { if (xnOSWasKeyboardHit()) { char c = xnOSReadCharFromInput(); XnBool bStop = FALSE; switch (c) { case 27: bStop = TRUE; break; case 'd': cyclicBuffer.Dump(); break; } if (bStop) { break; } } // Get next data context.WaitAndUpdateAll(); // Save data cyclicBuffer.Update(depthGenerator, imageGenerator); // Check for missed frames if (config.bRecordDepth) { ++nDepthFrames; XnUInt64 nTimestamp = depthGenerator.GetTimestamp(); if (nLastDepthTime != 0 && nTimestamp - nLastDepthTime > 35000) { int missed = (int)(nTimestamp-nLastDepthTime)/32000 - 1; printf("Missed depth: %llu -> %llu = %d > 35000 - %d frames\n", nLastDepthTime, nTimestamp, XnUInt32(nTimestamp-nLastDepthTime), missed); nMissedDepthFrames += missed; } nLastDepthTime = nTimestamp; } if (config.bRecordImage) { ++nImageFrames; XnUInt64 nTimestamp = imageGenerator.GetTimestamp(); if (nLastImageTime != 0 && nTimestamp - nLastImageTime > 35000) { int missed = (int)(nTimestamp-nLastImageTime)/32000 - 1; printf("Missed image: %llu -> %llu = %d > 35000 - %d frames\n", nLastImageTime, nTimestamp, XnUInt32(nTimestamp-nLastImageTime), missed); nMissedImageFrames += missed; } nLastImageTime = nTimestamp; } } if (config.bRecordDepth) { printf("Missed %d of %d depth frames (%5.2f%%)\n", nMissedDepthFrames, (nMissedDepthFrames+nDepthFrames), (nMissedDepthFrames*100.0)/(nMissedDepthFrames+nDepthFrames)); } if (config.bRecordImage) { printf("Missed %d of %d image frames (%5.2f%%)\n", nMissedImageFrames, (nMissedImageFrames+nImageFrames), (nMissedImageFrames*100.0)/(nMissedImageFrames+nImageFrames)); } imageGenerator.Release(); depthGenerator.Release(); context.Release(); return 0; }
void ofxOpenNIRecorder::update() { if (config.record_type == ONI_STREAMING) { //if (depth_generator.IsDataNew()) { // recorder.Record(); // is this really doing anything??? Don't think so ;-) //} } else if (config.record_type == ONI_CYCLIC && is_recording) { // store depth frame metadata to cyclic buffer array if(config.record_depth) { xn::DepthMetaData dmd; depth_generator.GetMetaData(dmd); frames[m_nNextWrite].depth_frame.CopyFrom(dmd); } // store image frame metadata to cyclic buffer array if(config.record_image) { xn::ImageMetaData imd; image_generator.GetMetaData(imd); frames[m_nNextWrite].image_frame.CopyFrom(imd); } // store ir frame metadata to cyclic buffer array if(config.record_ir) { xn::IRMetaData ird; ir_generator.GetMetaData(ird); frames[m_nNextWrite].ir_frame.CopyFrom(ird); } // See if buffer is already full if (m_nBufferCount < m_nBufferSize) m_nBufferCount++; // Make sure cylic buffer pointers are good m_nNextWrite++; // Reset cyclic buffer pointer if we're at the end if (m_nNextWrite == m_nBufferSize) m_nNextWrite = 0; } // Check for missed frames if (config.record_depth) { ++nDepthFrames; XnUInt64 nTimestamp = depth_generator.GetTimestamp(); if (nLastDepthTime != 0 && nTimestamp - nLastDepthTime > 35000) { int missed = (int)(nTimestamp-nLastDepthTime)/32000 - 1; printf("Missed depth: %llu -> %llu = %d > 35000 - %d frames\n", nLastDepthTime, nTimestamp, XnUInt32(nTimestamp-nLastDepthTime), missed); nMissedDepthFrames += missed; } nLastDepthTime = nTimestamp; } if (config.record_image) { ++nImageFrames; XnUInt64 nTimestamp = image_generator.GetTimestamp(); if (nLastImageTime != 0 && nTimestamp - nLastImageTime > 35000) { int missed = (int)(nTimestamp-nLastImageTime)/32000 - 1; printf("Missed image: %llu -> %llu = %d > 35000 - %d frames\n", nLastImageTime, nTimestamp, XnUInt32(nTimestamp-nLastImageTime), missed); nMissedImageFrames += missed; } nLastImageTime = nTimestamp; } if (config.record_ir) { ++nImageFrames; XnUInt64 nTimestamp = ir_generator.GetTimestamp(); if (nLastImageTime != 0 && nTimestamp - nLastImageTime > 35000) { int missed = (int)(nTimestamp-nLastImageTime)/32000 - 1; printf("Missed image (IR): %llu -> %llu = %d > 35000 - %d frames\n", nLastImageTime, nTimestamp, XnUInt32(nTimestamp-nLastImageTime), missed); nMissedImageFrames += missed; } nLastImageTime = nTimestamp; } }