//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnDumpWriterFileHandle XnDumpFileWriter::OpenFile(const XnChar* /*strDumpName*/, XnBool bSessionDump, const XnChar* strFileName)
{
XnStatus nRetVal = XN_STATUS_OK;
XnDumpWriterFileHandle result = { NULL };
XN_FILE_HANDLE* phFile = (XN_FILE_HANDLE*)xnOSMalloc(sizeof(XN_FILE_HANDLE));
if (phFile == NULL)
{
return result;
}
XnChar strFullPath[XN_FILE_MAX_PATH];
nRetVal = xnLogCreateNewFile(strFileName, bSessionDump, strFullPath, XN_FILE_MAX_PATH, phFile);
if (nRetVal != XN_STATUS_OK)
{
// we don't have much to do if files can't be open. Dump will not be written
xnLogWarning(XN_MASK_LOG, "Couldn't create dump file %s! Dump will not be written", strFileName);
}
else
{
result.pInternal = phFile;
}
return result;
}
XnStatus XnDepthProcessor::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnFrameStreamProcessor::Init();
XN_IS_STATUS_OK(nRetVal);
switch (GetStream()->GetOutputFormat())
{
case ONI_PIXEL_FORMAT_SHIFT_9_2:
{
// optimization. We create a LUT shift-to-shift. See comment up.
m_pShiftToDepthTable = (OniDepthPixel*)xnOSMalloc(sizeof(OniDepthPixel)*XN_DEVICE_SENSOR_MAX_SHIFT_VALUE);
XN_VALIDATE_ALLOC_PTR(m_pShiftToDepthTable);
for (XnUInt32 i = 0; i < XN_DEVICE_SENSOR_MAX_SHIFT_VALUE; ++i)
{
m_pShiftToDepthTable[i] = (OniDepthPixel)i;
}
m_bShiftToDepthAllocated = TRUE;
m_noDepthValue = 2047;
}
break;
case ONI_PIXEL_FORMAT_DEPTH_1_MM:
case ONI_PIXEL_FORMAT_DEPTH_100_UM:
m_noDepthValue = 0;
break;
default:
XN_ASSERT(FALSE);
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_SENSOR_PROTOCOL_DEPTH, "Unknown Depth output: %d", GetStream()->GetOutputFormat());
}
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XnDeviceProxyCreateDeviceByName(const XnChar* csDeviceName, XnDeviceHandle* pDeviceHandle, const XnDeviceConfig* pDeviceConfig)
{
XnStatus nRetVal = XN_STATUS_OK;
// get device interface
XnDeviceDescriptor* pDescriptor = NULL;
nRetVal = XnDeviceManagerGetDeviceByName(csDeviceName, &pDescriptor);
XN_IS_STATUS_OK(nRetVal);
// now create the actual device
XnDeviceHandle ActualDevice;
nRetVal = pDescriptor->Interface.Create(&ActualDevice, pDeviceConfig);
XN_IS_STATUS_OK(nRetVal);
// create our handle
XnDeviceProxyDeviceHandle* pHandle = (XnDeviceProxyDeviceHandle*)xnOSMalloc(sizeof(XnDeviceProxyDeviceHandle));
if (pHandle == NULL)
{
pDescriptor->Interface.Destroy(&ActualDevice);
return XN_STATUS_ALLOC_FAILED;
}
pHandle->ActualDevice = ActualDevice;
pHandle->pDesc = pDescriptor;
// and give it to user
*pDeviceHandle = pHandle;
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus XnActualPropertyFactory::CreateProperty(XnPropertyType nType, const XnChar* strName, XnProperty** ppProperty, XnUInt32 nSize /* = 0 */)
{
switch (nType)
{
case XN_PROPERTY_TYPE_INTEGER:
XN_VALIDATE_NEW(*ppProperty, XnActualIntProperty, strName);
break;
case XN_PROPERTY_TYPE_REAL:
XN_VALIDATE_NEW(*ppProperty, XnActualRealProperty, strName);
break;
case XN_PROPERTY_TYPE_STRING:
XN_VALIDATE_NEW(*ppProperty, XnActualStringProperty, strName);
break;
case XN_PROPERTY_TYPE_GENERAL:
XnGeneralBuffer gbValue;
gbValue.pData = xnOSMalloc(nSize);
XN_VALIDATE_ALLOC_PTR(gbValue.pData);
gbValue.nDataSize = nSize;
XN_VALIDATE_NEW(*ppProperty, XnActualGeneralProperty, strName, gbValue);
break;
}
return (XN_STATUS_OK);
}
XN_C_API XnChar* xnOSStrDup(const XnChar* strSource)
{
XnUInt32 nLen = strlen(strSource);
++nLen;
XnChar* result = (XnChar*)xnOSMalloc(nLen);
strcpy(result, strSource);
return result;
}
OniStatus Recorder::recordStreamProperty(
VideoStream& stream,
int propertyId,
const void* pData,
int dataSize)
{
xnl::LockGuard< AttachedStreams > guard(m_streams);
VideoStream* pStream = &stream;
if (m_streams.Find(pStream) == m_streams.End())
{
return ONI_STATUS_BAD_PARAMETER;
}
// The original pData will not be valid after this function ends.
// Free this pointer when soon after handling the PropertyMessage!
void *newPtr = xnOSMalloc(dataSize);
xnOSMemCopy(newPtr, pData, dataSize);
send(Message::MESSAGE_RECORDPROPERTY, pStream, newPtr, propertyId, dataSize, m_propertyPriority);
return ONI_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;
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus FindEntry(const XnChar* cpINIFile, const XnChar* cpSection, const XnChar* cpKey, XnChar* cpDest)
{
XnStatus nRetVal = XN_STATUS_OK;
// get file size
XnUInt32 nFileSize;
nRetVal = xnOSGetFileSize(cpINIFile, &nFileSize);
XN_IS_STATUS_OK(nRetVal);
// read entire file to memory
XnChar* csFileData = (XnChar*)xnOSMalloc(sizeof(XnChar)*nFileSize + 1);
XN_VALIDATE_ALLOC_PTR(csFileData);
nRetVal = xnOSLoadFile(cpINIFile, csFileData, nFileSize);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(csFileData);
return nRetVal;
}
// place NULL at the end
csFileData[nFileSize] = '\0';
// now parse file
XnChar* pCurPos = csFileData;
XnBool bIsInRequestedSection = FALSE;
XnChar csTempString[XN_INI_MAX_LEN];
XnUInt32 nTempStringLength = 0;
while (TRUE)
{
// ignore spaces
while (*pCurPos && XN_IS_SPACE(pCurPos))
{
pCurPos++;
}
// check we haven't reached the end
if (!*pCurPos)
{
break;
}
if (*pCurPos == ';' || *pCurPos == '#') // comment
{
XN_SKIP_LINE(pCurPos);
continue;
}
if (*pCurPos == '[') // start of section
{
pCurPos++;
XN_READ_TILL(pCurPos, *pCurPos == ']' || XN_IS_NEWLINE(pCurPos), csTempString, nTempStringLength);
if (*pCurPos == ']') // valid section name
{
if (bIsInRequestedSection)
{
// we're leaving the requested section, and string wasn't found
xnOSFree(csFileData);
return XN_STATUS_OS_INI_READ_FAILED;
}
if (strcmp(csTempString, cpSection) == 0)
{
bIsInRequestedSection = TRUE;
}
}
// in any case, move to the next line
XN_SKIP_LINE(pCurPos);
continue;
} // section
// if we're not in the right section, we don't really care what's written in this line. Just skip it.
if (!bIsInRequestedSection)
{
XN_SKIP_LINE(pCurPos);
continue;
}
// regular line. check if this is a key (look for the '=' sign)
XN_READ_TILL(pCurPos, *pCurPos == '=' || XN_IS_NEWLINE(pCurPos), csTempString, nTempStringLength);
if (*pCurPos == '=') // we found a key
{
if (strcmp(csTempString, cpKey) == 0)
{
// we found our key. The value is the rest of the line
pCurPos++;
XN_READ_TILL(pCurPos, XN_IS_NEWLINE(pCurPos), cpDest, nTempStringLength);
xnOSFree(csFileData);
return XN_STATUS_OK;
}
}
// if we got here, skip to the next line
XN_SKIP_LINE(pCurPos);
} // while loop
xnOSFree(csFileData);
return (XN_STATUS_OS_INI_READ_FAILED);
}
