XN_C_API XnStatus xnOSGetFileSize(const XnChar* cpFileName, XnUInt32* pnFileSize)
{
// Local function variables
XN_FILE_HANDLE FileHandle;
XnStatus nRetVal = XN_STATUS_OK;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pnFileSize);
nRetVal = xnOSOpenFile(cpFileName, XN_OS_FILE_READ, &FileHandle);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSSeekFile(FileHandle, XN_OS_SEEK_END, 0);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSTellFile(FileHandle, pnFileSize);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCloseFile(&FileHandle);
XN_IS_STATUS_OK(nRetVal);
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSLoadFile(const XnChar* cpFileName, void* pBuffer, const XnUInt32 nBufferSize)
{
// Local function variables
XN_FILE_HANDLE FileHandle;
XnUInt32 nReadBytes = nBufferSize;
XnStatus nRetVal = XN_STATUS_OK;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pBuffer);
if (nBufferSize == 0)
{
return XN_STATUS_NULL_OUTPUT_PTR;
}
nRetVal = xnOSOpenFile(cpFileName, XN_OS_FILE_READ, &FileHandle);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSReadFile(FileHandle, pBuffer, &nReadBytes);
if ((nRetVal != XN_STATUS_OK) || (nReadBytes != nBufferSize))
{
xnOSCloseFile(&FileHandle);
return (XN_STATUS_OS_FILE_READ_FAILED);
}
nRetVal = xnOSCloseFile(&FileHandle);
XN_IS_STATUS_OK(nRetVal);
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSAppendFile(const XnChar* cpFileName, const void* pBuffer, const XnUInt32 nBufferSize)
{
// Local function variables
XN_FILE_HANDLE FileHandle;
XnUInt32 nReadBytes = nBufferSize;
XnStatus nRetVal = XN_STATUS_OK;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_INPUT_PTR(pBuffer);
nRetVal = xnOSOpenFile(cpFileName, XN_OS_FILE_WRITE | XN_OS_FILE_APPEND, &FileHandle);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSWriteFile(FileHandle, pBuffer, nBufferSize);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseFile(&FileHandle);
return (XN_STATUS_OS_FILE_WRITE_FAILED);
}
nRetVal = xnOSCloseFile(&FileHandle);
XN_IS_STATUS_OK(nRetVal);
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSGetFileSize64(const XnChar* cpFileName, XnUInt64* pnFileSize)
{
// Local function variables
XN_FILE_HANDLE FileHandle;
XnStatus nRetVal = XN_STATUS_OK;
LARGE_INTEGER liSize;
BOOL bSucceeded = 0;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pnFileSize);
nRetVal = xnOSOpenFile(cpFileName, XN_OS_FILE_READ, &FileHandle);
XN_IS_STATUS_OK(nRetVal);
bSucceeded = GetFileSizeEx(FileHandle, &liSize);
if (!bSucceeded)
return XN_STATUS_OS_FILE_GET_SIZE_FAILED;
*pnFileSize = liSize.QuadPart;
nRetVal = xnOSCloseFile(&FileHandle);
XN_IS_STATUS_OK(nRetVal);
// All is good...
return (XN_STATUS_OK);
}
OniStatus Recorder::initialize(const char* fileName)
{
m_fileName = fileName;
// Probe if we can actually open the file.
XN_FILE_HANDLE fileHandle = XN_INVALID_FILE_HANDLE;
XnStatus status = xnOSOpenFile(
/* file name = */ fileName,
/* open flags = */ XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE,
/* out handle = */ &fileHandle);
if (XN_STATUS_OK != status)
{
return ONI_STATUS_ERROR;
}
xnOSCloseFile(&fileHandle);
m_assembler.initialize();
status = xnOSCreateThread(threadMain, this, &m_thread);
if (XN_STATUS_OK != status)
{
return ONI_STATUS_ERROR;
}
send(Message::MESSAGE_INITIALIZE);
return ONI_STATUS_OK;
}
XN_C_API XnStatus xnLogCreateFile(const XnChar* csFileName, XN_FILE_HANDLE* phFile)
{
XnStatus nRetVal = XN_STATUS_OK;
// set log directory
if (g_logData.m_strLogDir[0] == '\0')
{
nRetVal = xnLogSetOutputFolder(XN_LOG_DIR_NAME);
XN_IS_STATUS_OK(nRetVal);
}
if (g_logData.m_strTime[0] == '\0')
{
time_t currtime;
time(&currtime);
strftime(g_logData.m_strTime, sizeof(g_logData.m_strTime)-1, "%Y_%m_%d__%H_%M_%S", localtime(&currtime));
}
XN_PROCESS_ID nProcID = 0;
xnOSGetCurrentProcessID(&nProcID);
// create full path file name - add process start time and process ID
XnChar strFilePath[XN_FILE_MAX_PATH];
sprintf(strFilePath, "%s%s_%u.%s", g_logData.m_strLogDir, g_logData.m_strTime, nProcID, csFileName);
// and open the file
nRetVal = xnOSOpenFile(strFilePath, XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE, phFile);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus xnLogCreateFile(const XnChar* csFileName, XN_FILE_HANDLE* phFile)
{
// create the log directory (to make sure it exists)
xnOSCreateDirectory(g_xnLoggerData.m_csLogDir);
// now open the file
return xnOSOpenFile(csFileName, XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE, phFile);
}
XnStatus XnIOFileStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSOpenFile(m_pcsFileName, m_nFlags, &m_hFile);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus XN_C_DECL xnLogCreateNewFile(const XnChar* strName, XnBool bSessionBased, XnChar* csFullPath, XnUInt32 nPathBufferSize, XN_FILE_HANDLE* phFile)
{
XnStatus nRetVal = XN_STATUS_OK;
LogData& logData = LogData::GetInstance();
// set log directory
if (logData.strLogDir[0] == '\0')
{
nRetVal = xnLogSetOutputFolder(XN_LOG_DIR_NAME);
XN_IS_STATUS_OK(nRetVal);
}
if (logData.strSessionTimestamp[0] == '\0')
{
time_t currtime;
time(&currtime);
strftime(logData.strSessionTimestamp, sizeof(logData.strSessionTimestamp)-1, "%Y_%m_%d__%H_%M_%S", localtime(&currtime));
}
XN_PROCESS_ID nProcID = 0;
xnOSGetCurrentProcessID(&nProcID);
// create full path file name - add process start time and process ID
XnUInt32 nPathSize = 0;
XnUInt32 nCharsWritten = 0;
nRetVal = xnOSStrFormat(csFullPath, nPathBufferSize - nPathSize, &nCharsWritten, "%s", logData.strLogDir);
XN_IS_STATUS_OK(nRetVal);
nPathSize += nCharsWritten;
if (bSessionBased)
{
nRetVal = xnOSStrFormat(csFullPath + nPathSize, nPathBufferSize - nPathSize, &nCharsWritten, "%s_%u.", logData.strSessionTimestamp, nProcID);
XN_IS_STATUS_OK(nRetVal);
nPathSize += nCharsWritten;
}
nRetVal = xnOSStrFormat(csFullPath + nPathSize, nPathBufferSize - nPathSize, &nCharsWritten, "%s", strName);
XN_IS_STATUS_OK(nRetVal);
nPathSize += nCharsWritten;
// and open the file
nRetVal = xnOSOpenFile(csFullPath, XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE, phFile);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
void Recorder::onInitialize()
{
XnStatus status = xnOSOpenFile(
/* file name = */ m_fileName.Data(),
/* open flags = */ XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE,
/* out handle = */ &m_file);
if (XN_STATUS_OK == status)
{
FileHeaderData fileHeader =
{
/* identity = */ { 'N', 'I', '1', '0' },
/* version = */ { 1, 0, 1, 0 },
/* maxTimeStamp = */ XN_MAX_UINT64,
/* maxNodeId = */ m_maxId,
};
m_fileHeader = fileHeader;
xnOSWriteFile(m_file, &m_fileHeader, sizeof(m_fileHeader));
}
}
XN_C_API void xnOSWriteMemoryReport(const XnChar* csFileName)
{
XN_FILE_HANDLE FileHandle;
XnStatus nRetVal = xnOSOpenFile(csFileName, XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE, &FileHandle);
if (nRetVal != XN_STATUS_OK) return;
const XnUInt32 nReportLineMaxSize = 2048;
XnChar csReportLine[nReportLineMaxSize];
XnUInt32 nReportLength = 0;
XnUInt32 nChars;
XnUInt32 nSum = 0;
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "Allocated memory blocks:\n");
nReportLength += nChars;
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "============================================\n");
nReportLength += nChars;
xnOSWriteFile(FileHandle, csReportLine, nReportLength);
nReportLength = 0;
{
XnAutoCSLocker lock(g_hCS);
for (XnMemBlockDataNode* pNode = g_allocatedMemory.pFirst; pNode != NULL; pNode = pNode->pNext)
{
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "%d bytes allocated at 0x%08x using %s", pNode->Data.nBytes, pNode->Data.pMemBlock, XnGetAllocTypeString(pNode->Data.nAllocType));
nReportLength += nChars;
if (pNode->Data.csAdditional != NULL)
{
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, " (%s)", pNode->Data.csAdditional);
nReportLength += nChars;
}
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, " at %s [%s, %d]\n", pNode->Data.csFunction, pNode->Data.csFile, pNode->Data.nLine);
nReportLength += nChars;
if (pNode->Data.nFrames > 0)
{
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "Callstack:\n");
nReportLength += nChars;
for (XnUInt i = 0; i < pNode->Data.nFrames; ++i)
{
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "\t%s\n", pNode->Data.aFrames[i]);
nReportLength += nChars;
}
}
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "\n");
nReportLength += nChars;
xnOSWriteFile(FileHandle, csReportLine, nReportLength);
nReportLength = 0;
nSum += pNode->Data.nBytes;
}
}
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "*******************************************************************\n\n");
nReportLength += nChars;
xnOSStrFormat(csReportLine + nReportLength, nReportLineMaxSize - nReportLength, &nChars, "Total allocated memory: %d bytes\n", nSum);
nReportLength += nChars;
xnOSWriteFile(FileHandle, csReportLine, nReportLength);
nReportLength = 0;
xnOSCloseFile(&FileHandle);
}
XnStatus XN_CALLBACK_TYPE PlayerDriver::FileOpen(void* pCookie)
{
PlayerDriver* pThis = (PlayerDriver*)pCookie;
return xnOSOpenFile(pThis->m_filePath.Data(), XN_OS_FILE_READ, &pThis->m_fileHandle);
}