XnPrdNode.h

Go to the documentation of this file.

/*****************************************************************************
*                                                                            *
*  OpenNI 1.0 Alpha                                                          *
*  Copyright (C) 2010 PrimeSense Ltd.                                        *
*                                                                            *
*  This file is part of OpenNI.                                              *
*                                                                            *
*  OpenNI is free software: you can redistribute it and/or modify            *
*  it under the terms of the GNU Lesser General Public License as published  *
*  by the Free Software Foundation, either version 3 of the License, or      *
*  (at your option) any later version.                                       *
*                                                                            *
*  OpenNI is distributed in the hope that it will be useful,                 *
*  but WITHOUT ANY WARRANTY; without even the implied warranty of            *
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
*  GNU Lesser General Public License for more details.                       *
*                                                                            *
*  You should have received a copy of the GNU Lesser General Public License  *
*  along with OpenNI. If not, see <http://www.gnu.org/licenses/>.            *
*                                                                            *
*****************************************************************************/




#ifndef __XN_PRD_NODE_H__
#define __XN_PRD_NODE_H__

//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------
#include <XnTypes.h>

//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------

XN_C_API XnNodeInfo* xnGetNodeInfo(XnNodeHandle hNode);

XN_C_API const XnChar* xnGetNodeName(XnNodeHandle hNode);

XN_C_API XnContext* xnGetContextFromNodeHandle(XnNodeHandle hNode);

XN_C_API XnBool xnIsCapabilitySupported(XnNodeHandle hInstance, const XnChar* strCapabilityName);

XN_C_API XnStatus xnSetIntProperty(XnNodeHandle hInstance, const XnChar* strName, XnUInt64 nValue);
XN_C_API XnStatus xnSetRealProperty(XnNodeHandle hInstance, const XnChar* strName, XnDouble dValue);
XN_C_API XnStatus xnSetStringProperty(XnNodeHandle hInstance, const XnChar* strName, const XnChar* strValue);
XN_C_API XnStatus xnSetGeneralProperty(XnNodeHandle hInstance, const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer);

XN_C_API XnStatus xnGetIntProperty(XnNodeHandle hInstance, const XnChar* strName, XnUInt64* pnValue);
XN_C_API XnStatus xnGetRealProperty(XnNodeHandle hInstance, const XnChar* strName, XnDouble* pdValue);
XN_C_API XnStatus xnGetStringProperty(XnNodeHandle hInstance, const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize);
XN_C_API XnStatus xnGetGeneralProperty(XnNodeHandle hInstance, const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer);

XN_C_API XnStatus xnLockNodeForChanges(XnNodeHandle hInstance, XnLockHandle* phLock);

XN_C_API XnStatus xnUnlockNodeForChanges(XnNodeHandle hInstance, XnLockHandle hLock);

XN_C_API XnStatus xnLockedNodeStartChanges(XnNodeHandle hInstance, XnLockHandle hLock);

XN_C_API XnStatus xnLockedNodeEndChanges(XnNodeHandle hInstance, XnLockHandle hLock);

XN_C_API XnStatus xnAddNeededNode(XnNodeHandle hInstance, XnNodeHandle hNeededNode);

XN_C_API XnStatus xnRemoveNeededNode(XnNodeHandle hInstance, XnNodeHandle hNeededNode);

//---------------------------------------------------------------------------
// ErrorState Capability
//---------------------------------------------------------------------------

XN_C_API XnStatus xnGetNodeErrorState(XnNodeHandle hInstance);

XN_C_API XnStatus xnRegisterToNodeErrorStateChange
        (XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromNodeErrorStateChange
        (XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Generators
//---------------------------------------------------------------------------

XN_C_API XnStatus xnStartGenerating(XnNodeHandle hInstance);

XN_C_API XnBool xnIsGenerating(XnNodeHandle hInstance);

XN_C_API XnStatus xnStopGenerating(XnNodeHandle hInstance);

XN_C_API XnStatus xnRegisterToGenerationRunningChange
        (XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromGenerationRunningChange
        (XnNodeHandle hInstance, XnCallbackHandle hCallback);


XN_C_API XnStatus xnRegisterToNewDataAvailable
        (XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromNewDataAvailable
        (XnNodeHandle hInstance, XnCallbackHandle hCallback);

XN_C_API XnBool xnIsNewDataAvailable(XnNodeHandle hInstance, XnUInt64* pnTimestamp);


XN_C_API XnStatus xnWaitAndUpdateData(XnNodeHandle hInstance);


XN_C_API XnBool xnIsDataNew(XnNodeHandle hInstance);

XN_C_API XnUInt32 xnGetDataSize(XnNodeHandle hInstance);

XN_C_API XnUInt64 xnGetTimestamp(XnNodeHandle hInstance);

XN_C_API XnUInt32 xnGetFrameID(XnNodeHandle hInstance);

//---------------------------------------------------------------------------
// Mirror Capability
//---------------------------------------------------------------------------

XN_C_API XnStatus xnSetMirror(XnNodeHandle hInstance, XnBool bMirror);

XN_C_API XnBool xnIsMirrored(XnNodeHandle hInstance);

XN_C_API XnStatus xnRegisterToMirrorChange
        (XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromMirrorChange
        (XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Alternative View Point Capability
//---------------------------------------------------------------------------

XN_C_API XnBool xnIsViewPointSupported(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnStatus xnSetViewPoint(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnStatus xnResetViewPoint(XnNodeHandle hInstance);

XN_C_API XnBool xnIsViewPointAs(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnStatus xnRegisterToViewPointChange(XnNodeHandle hInstance, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromViewPointChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// FrameSync Capability
//---------------------------------------------------------------------------

XN_C_API XnBool xnCanFrameSyncWith(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnStatus xnFrameSyncWith(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnStatus xnStopFrameSyncWith(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnBool xnIsFrameSyncedWith(XnNodeHandle hInstance, XnNodeHandle hOther);

XN_C_API XnStatus xnRegisterToFrameSyncChange(XnNodeHandle hInstance, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromFrameSyncChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Map Generators
//---------------------------------------------------------------------------

XN_C_API XnUInt32 xnGetSupportedMapOutputModesCount(XnNodeHandle hInstance);

XN_C_API XnStatus xnGetSupportedMapOutputModes(XnNodeHandle hInstance, XnMapOutputMode* aModes, XnUInt32* pnCount);

XN_C_API XnStatus xnSetMapOutputMode(XnNodeHandle hInstance, const XnMapOutputMode* pOutputMode);

XN_C_API XnStatus xnGetMapOutputMode(XnNodeHandle hInstance, XnMapOutputMode* pOutputMode);

XN_C_API XnStatus xnRegisterToMapOutputModeChange(XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromMapOutputModeChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Cropping Capability
//---------------------------------------------------------------------------


XN_C_API XnStatus xnSetCropping(XnNodeHandle hInstance, const XnCropping* pCropping);

XN_C_API XnStatus xnGetCropping(XnNodeHandle hInstance, XnCropping* pCropping);

XN_C_API XnStatus xnRegisterToCroppingChange(XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromCroppingChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Depth Generators
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateDepthGenerator(
        XnContext* pContext,
        XnNodeHandle* phDepthGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors);

XN_C_API XnDepthPixel xnGetDeviceMaxDepth(XnNodeHandle hInstance);

XN_C_API XnStatus xnGetDepthFieldOfView(XnNodeHandle hInstance, XnFieldOfView* pFOV);

XN_C_API XnStatus xnRegisterToDepthFieldOfViewChange(XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromDepthFieldOfViewChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

XN_C_API XnStatus xnConvertProjectiveToRealWorld(
        XnNodeHandle hInstance, XnUInt32 nCount, const XnPoint3D* aProjective, XnPoint3D* aRealWorld);

XN_C_API XnStatus xnConvertRealWorldToProjective(
        XnNodeHandle hInstance, XnUInt32 nCount, const XnPoint3D* aRealWorld, XnPoint3D* aProjective);

XN_C_API XnDepthPixel* xnGetDepthMap(XnNodeHandle hInstance);

XN_C_API void xnGetDepthMetaData(XnNodeHandle hInstance, XnDepthMetaData* pMetaData);

//---------------------------------------------------------------------------
// User Position Capability
//---------------------------------------------------------------------------

XN_C_API XnUInt32 xnGetSupportedUserPositionsCount(XnNodeHandle hInstance);

XN_C_API XnStatus xnSetUserPosition(XnNodeHandle hInstance, XnUInt32 nIndex, const XnBoundingBox3D* pPosition);

XN_C_API XnStatus xnGetUserPosition(XnNodeHandle hInstance, XnUInt32 nIndex, XnBoundingBox3D* pPosition);

XN_C_API XnStatus xnRegisterToUserPositionChange(XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromUserPositionChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Image Generators
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateImageGenerator(
        XnContext* pContext,
        XnNodeHandle* phImageGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API XnRGB24Pixel* xnGetRGB24ImageMap(XnNodeHandle hInstance);

XN_C_API XnYUV422DoublePixel* xnGetYUV422ImageMap(XnNodeHandle hInstance);

XN_C_API XnGrayscale8Pixel* xnGetGrayscale8ImageMap(XnNodeHandle hInstance);

XN_C_API XnGrayscale16Pixel* xnGetGrayscale16ImageMap(XnNodeHandle hInstance);

XN_C_API XnUInt8* xnGetImageMap(XnNodeHandle hInstance);

XN_C_API XnBool xnIsPixelFormatSupported(XnNodeHandle hInstance, XnPixelFormat Format);

XN_C_API XnStatus xnSetPixelFormat(XnNodeHandle hInstance, XnPixelFormat Format);

XN_C_API XnPixelFormat xnGetPixelFormat(XnNodeHandle hInstance);

XN_C_API XnStatus xnRegisterToPixelFormatChange(XnNodeHandle hInstance, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromPixelFormatChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

XN_C_API void xnGetImageMetaData(XnNodeHandle hInstance, XnImageMetaData* pMetaData);

//---------------------------------------------------------------------------
// IR Generators
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateIRGenerator(
        XnContext* pContext,
        XnNodeHandle* phIRGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API XnIRPixel* xnGetIRMap(XnNodeHandle hInstance);

XN_C_API void xnGetIRMetaData(XnNodeHandle hInstance, XnIRMetaData* pMetaData);

//---------------------------------------------------------------------------
// Gesture Generators
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateGestureGenerator(
        XnContext* pContext,
        XnNodeHandle* phGestureGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API XnStatus xnAddGesture(XnNodeHandle hInstance, const XnChar* strGesture, XnBoundingBox3D* pArea);
XN_C_API XnStatus xnRemoveGesture(XnNodeHandle hInstance, const XnChar* strGesture);
XN_C_API XnStatus xnGetActiveGestures(XnNodeHandle hInstance, XnChar** pstrGestures, XnUInt16* nGestures);
XN_C_API XnStatus xnEnumerateGestures(XnNodeHandle hInstance, XnChar** pstrGestures, XnUInt16* nGestures);
XN_C_API XnBool xnIsGestureAvailable(XnNodeHandle hInstance, const XnChar* strGesture);
XN_C_API XnBool xnIsGestureProgressSupported(XnNodeHandle hInstance, const XnChar* strGesture);
XN_C_API XnStatus xnRegisterGestureCallbacks(XnNodeHandle hInstance, XnGestureRecognized RecognizedCB, XnGestureProgress ProgressCB, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterGestureCallbacks(XnNodeHandle hInstance, XnCallbackHandle hCallback);
XN_C_API XnStatus xnRegisterToGestureChange(XnNodeHandle hInstance, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterFromGestureChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Scene Analysis
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateSceneAnalyzer(
        XnContext* pContext,
        XnNodeHandle* phSceneAnalyzer,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API const XnLabel* xnGetLabelMap(XnNodeHandle hInstance);
XN_C_API XnStatus xnGetFloor(XnNodeHandle hInstance, XnPlane3D* pPlane);

XN_C_API void xnGetSceneMetaData(XnNodeHandle hInstance, XnSceneMetaData* pMetaData);

//---------------------------------------------------------------------------
// User Generator
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateUserGenerator(
        XnContext* pContext,
        XnNodeHandle* phUserGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API XnUInt16 xnGetNumberOfUsers(XnNodeHandle hInstance);
XN_C_API XnStatus xnGetUsers(XnNodeHandle hInstance, XnUserID* pUsers, XnUInt16* pnUsers);
XN_C_API XnStatus xnGetUserCoM(XnNodeHandle hInstance, XnUserID user, XnPoint3D* pCoM);
XN_C_API XnStatus xnGetUserPixels(XnNodeHandle hInstance, XnUserID user, XnSceneMetaData* pScene);
XN_C_API XnStatus xnRegisterUserCallbacks(XnNodeHandle hInstance, XnUserHandler NewUserCB, XnUserHandler LostUserCB, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterUserCallbacks(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Skeleton Capability
//---------------------------------------------------------------------------

XN_C_API XnBool xnIsJointAvailable(XnNodeHandle hInstance, XnSkeletonJoint eJoint);
XN_C_API XnBool xnIsProfileAvailable(XnNodeHandle hInstance, XnSkeletonProfile eProfile);
XN_C_API XnStatus xnSetSkeletonProfile(XnNodeHandle hInstance, XnSkeletonProfile eProfile);
XN_C_API XnStatus xnSetJointActive(XnNodeHandle hInstance, XnSkeletonJoint eJoint, XnBool bState);
XN_C_API XnBool xnIsJointActive(XnNodeHandle hInstance, XnSkeletonJoint eJoint);
XN_C_API XnStatus xnRegisterToJointConfigurationChange(XnNodeHandle hInstance, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterFromJointConfigurationChange(XnNodeHandle hInstance, XnCallbackHandle hCallback);
XN_C_API XnStatus xnEnumerateActiveJoints(XnNodeHandle hInstance, XnSkeletonJoint* pJoints, XnUInt16* pnJoints);
XN_C_API XnStatus xnGetSkeletonJoint(XnNodeHandle hInstance, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation* pJoint);
XN_C_API XnStatus xnGetSkeletonJointPosition(XnNodeHandle hInstance, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition* pJoint);
XN_C_API XnStatus xnGetSkeletonJointOrientation(XnNodeHandle hInstance, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation* pJoint);
XN_C_API XnBool xnIsSkeletonTracking(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnBool xnIsSkeletonCalibrated(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnBool xnIsSkeletonCalibrating(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnStatus xnRequestSkeletonCalibration(XnNodeHandle hInstance, XnUserID user, XnBool bForce);
XN_C_API XnStatus xnAbortSkeletonCalibration(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnStatus xnSaveSkeletonCalibrationData(XnNodeHandle hInstance, XnUserID user, XnUInt32 nSlot);
XN_C_API XnStatus xnLoadSkeletonCalibrationData(XnNodeHandle hInstance, XnUserID user, XnUInt32 nSlot);
XN_C_API XnStatus xnClearSkeletonCalibrationData(XnNodeHandle hInstance, XnUInt32 nSlot);
XN_C_API XnBool xnIsSkeletonCalibrationData(XnNodeHandle hInstance, XnUInt32 nSlot);
XN_C_API XnStatus xnStartSkeletonTracking(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnStatus xnStopSkeletonTracking(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnStatus xnResetSkeleton(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnBool xnNeedPoseForSkeletonCalibration(XnNodeHandle hInstance);
XN_C_API XnStatus xnGetSkeletonCalibrationPose(XnNodeHandle hInstance, XnChar* strPose);
XN_C_API XnStatus xnSetSkeletonSmoothing(XnNodeHandle hInstance, XnFloat fFactor);
XN_C_API XnStatus xnRegisterCalibrationCallbacks(XnNodeHandle hInstance, XnCalibrationStart CalibrationStartCB, XnCalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterCalibrationCallbacks(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Pose Detection Capability
//---------------------------------------------------------------------------

XN_C_API XnUInt32 xnGetNumberOfPoses(XnNodeHandle hInstance);
XN_C_API XnStatus xnGetAvailablePoses(XnNodeHandle hInstance, XnChar** pstrPoses, XnUInt32* pnPoses);
XN_C_API XnStatus xnStartPoseDetection(XnNodeHandle hInstance,const  XnChar* strPose, XnUserID user);
XN_C_API XnStatus xnStopPoseDetection(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnStatus xnRegisterToPoseCallbacks(XnNodeHandle hInstance, XnPoseDetectionCallback PoseDetectionStartCB, XnPoseDetectionCallback PoseDetectionEndCB, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterFromPoseCallbacks(XnNodeHandle hInstance, XnCallbackHandle hCallback);

//---------------------------------------------------------------------------
// Hands Generator
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateHandsGenerator(
        XnContext* pContext,
        XnNodeHandle* phHandsGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API XnStatus xnRegisterHandCallbacks(XnNodeHandle hInstance, XnHandCreate CreateCB, XnHandUpdate UpdateCB, XnHandDestroy DestroyCB, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterHandCallbacks(XnNodeHandle hInstance, XnCallbackHandle hCallback);
XN_C_API XnStatus xnStopTracking(XnNodeHandle hInstance, XnUserID user);
XN_C_API XnStatus xnStopTrackingAll(XnNodeHandle hInstance);
XN_C_API XnStatus xnStartTracking(XnNodeHandle hInstance, const XnPoint3D* pPosition);
XN_C_API XnStatus xnSetTrackingSmoothing(XnNodeHandle hInstance, XnFloat fFactor);

//---------------------------------------------------------------------------
// Audio Generator
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateAudioGenerator(
        XnContext* pContext,
        XnNodeHandle* phAudioGenerator,
        XnNodeQuery* pQuery, 
        XnEnumerationErrors* pErrors
        );

XN_C_API XnUChar* xnGetAudioBuffer(XnNodeHandle hInstance);
XN_C_API XnUInt32 xnGetSupportedWaveOutputModesCount(XnNodeHandle hInstance);
XN_C_API XnStatus xnGetSupportedWaveOutputModes(XnNodeHandle hInstance, XnWaveOutputMode* aSupportedModes, XnUInt32* pnCount);
XN_C_API XnStatus xnSetWaveOutputMode(XnNodeHandle hInstance, const XnWaveOutputMode* OutputMode);
XN_C_API XnStatus xnGetWaveOutputMode(XnNodeHandle hInstance, XnWaveOutputMode* OutputMode);
XN_C_API XnStatus xnRegisterToWaveOutputModeChanges(XnNodeHandle hInstance, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);
XN_C_API void xnUnregisterFromWaveOutputModeChanges(XnNodeHandle hInstance, XnCallbackHandle hCallback);

XN_C_API void xnGetAudioMetaData(XnNodeHandle hInstance, XnAudioMetaData* pMetaData);

//---------------------------------------------------------------------------
// Mocks
//---------------------------------------------------------------------------

XN_C_API XnStatus xnMockDepthSetData(XnNodeHandle hInstance, XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnDepthPixel* pData);
XN_C_API XnStatus xnMockImageSetData(XnNodeHandle hInstance, XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pData);
XN_C_API XnStatus xnMockIRSetData(XnNodeHandle hInstance, XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnIRPixel* pData);
XN_C_API XnStatus xnMockAudioSetData(XnNodeHandle hInstance, XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pData);

//---------------------------------------------------------------------------
// Codecs
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreateCodec(XnContext* pContext, XnCodecID codecID, XnNodeHandle hInitializerNode, XnNodeHandle* phCodec);
XN_C_API XnCodecID xnGetCodecID(XnNodeHandle hCodec);
XN_C_API XnStatus xnEncodeData(XnNodeHandle hCodec, const void* pSrc, XnUInt32 nSrcSize, 
                                                           void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten);
XN_C_API XnStatus xnDecodeData(XnNodeHandle hCodec, const void* pSrc, XnUInt32 nSrcSize, 
                                                           void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten);

//---------------------------------------------------------------------------
// Recorder
//---------------------------------------------------------------------------
XN_C_API XnStatus xnCreateRecorder(XnContext* pContext, const XnChar* strFormatName, XnNodeHandle* phRecorder);

XN_C_API XnStatus xnSetRecorderDestination(XnNodeHandle hRecorder, XnRecordMedium destType, const XnChar* strDest);

XN_C_API XnStatus xnAddNodeToRecording(XnNodeHandle hRecorder, XnNodeHandle hNode, XnCodecID compression);

XN_C_API XnStatus xnRemoveNodeFromRecording(XnNodeHandle hRecorder, XnNodeHandle hNode);

XN_C_API XnStatus xnRecord(XnNodeHandle hRecorder);

XN_C_API const XnChar* xnGetRecorderFormat(XnNodeHandle hRecorder);

//---------------------------------------------------------------------------
// Player
//---------------------------------------------------------------------------

XN_C_API XnStatus xnCreatePlayer(XnContext* pContext, const XnChar* strFormatName, XnNodeHandle* phPlayer);

XN_C_API XnStatus xnSetPlayerRepeat(XnNodeHandle hPlayer, XnBool bRepeat);

XN_C_API XnStatus xnSetPlayerSource(XnNodeHandle hPlayer, XnRecordMedium sourceType, const XnChar* strSource);

XN_C_API XnStatus xnGetPlayerSource(XnNodeHandle hPlayer, XnRecordMedium* pSourceType, XnChar* strSource, XnUInt32 nBufSize);

XN_C_API XnStatus xnPlayerReadNext(XnNodeHandle hPlayer);

XN_C_API XnStatus xnSeekPlayerToTimeStamp(XnNodeHandle hPlayer, XnInt64 nTimeOffset, XnPlayerSeekOrigin origin);

XN_C_API XnStatus xnSeekPlayerToFrame(XnNodeHandle hPlayer, const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin);

XN_C_API XnStatus xnTellPlayerTimestamp(XnNodeHandle hPlayer, XnUInt64* pnTimestamp);

XN_C_API XnStatus xnTellPlayerFrame(XnNodeHandle hPlayer, const XnChar* strNodeName, XnUInt32* pnFrame);

XN_C_API XnStatus xnGetPlayerNumFrames(XnNodeHandle hPlayer, const XnChar* strNodeName, XnUInt32* pnFrames);

XN_C_API const XnChar* xnGetPlayerSupportedFormat(XnNodeHandle hPlayer);

XN_C_API XnStatus xnEnumeratePlayerNodes(XnNodeHandle hPlayer, XnNodeInfoList** ppList);

XN_C_API XnBool xnIsPlayerAtEOF(XnNodeHandle hPlayer);

XN_C_API XnStatus xnRegisterToEndOfFileReached
        (XnNodeHandle hPlayer, XnStateChangedHandler handler,
        void* pCookie, XnCallbackHandle* phCallback);

XN_C_API void xnUnregisterFromEndOfFileReached
        (XnNodeHandle hInstance, XnCallbackHandle hCallback);

#endif // __XN_PRD_NODE_H__