XnTypes.h

Go to the documentation of this file.

/****************************************************************************
*                                                                           *
*  OpenNI 1.x Alpha                                                         *
*  Copyright (C) 2011 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_TYPES_H__
#define __XN_TYPES_H__

//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------
#include <XnStatus.h>
#include <XnOS.h>

//---------------------------------------------------------------------------
// Defines
//---------------------------------------------------------------------------
#define XN_MAX_NAME_LENGTH                  80

#define XN_MAX_CREATION_INFO_LENGTH         255

#define XN_MAX_LICENSE_LENGTH               255

#define XN_NODE_WAIT_FOR_DATA_TIMEOUT       2000

#define XN_VENDOR_OPEN_NI   "OpenNI"

#define XN_FORMAT_NAME_ONI  "oni"

#define XN_SCRIPT_FORMAT_XML    "xml"

#define XN_PLAYBACK_SPEED_FASTEST   0.0

#define XN_AUTO_CONTROL             XN_MIN_INT32

//---------------------------------------------------------------------------
// Forward Declarations
//---------------------------------------------------------------------------
struct XnInternalNodeData;

//---------------------------------------------------------------------------
// Types
//---------------------------------------------------------------------------

#if XN_PLATFORM != XN_PLATFORM_ARC
#pragma pack (push, 1)
#endif

typedef struct XnContext XnContext;

typedef struct XnInternalNodeData* XnNodeHandle;

typedef XnUInt32 XnLockHandle;

typedef XnInt32 XnProductionNodeType;

typedef enum XnPredefinedProductionNodeType
{
    XN_NODE_TYPE_INVALID = -1,

    XN_NODE_TYPE_DEVICE = 1,
    
    XN_NODE_TYPE_DEPTH = 2,
    
    XN_NODE_TYPE_IMAGE = 3,

    XN_NODE_TYPE_AUDIO = 4,
    
    XN_NODE_TYPE_IR = 5,

    XN_NODE_TYPE_USER = 6,
    
    XN_NODE_TYPE_RECORDER = 7,
    
    XN_NODE_TYPE_PLAYER = 8,
    
    XN_NODE_TYPE_GESTURE = 9,
    
    XN_NODE_TYPE_SCENE = 10,
    
    XN_NODE_TYPE_HANDS = 11,

    XN_NODE_TYPE_CODEC = 12,

    XN_NODE_TYPE_PRODUCTION_NODE = 13,
    XN_NODE_TYPE_GENERATOR = 14,
    XN_NODE_TYPE_MAP_GENERATOR = 15,
    XN_NODE_TYPE_SCRIPT = 16,

    XN_NODE_TYPE_FIRST_EXTENSION,

} XnPredefinedProductionNodeType;

typedef struct XnVersion
{
    XnUInt8 nMajor;
    XnUInt8 nMinor;
    XnUInt16 nMaintenance;
    XnUInt32 nBuild;
} XnVersion;

typedef struct XnProductionNodeDescription
{
    XnProductionNodeType Type;
    XnChar strVendor[XN_MAX_NAME_LENGTH];
    XnChar strName[XN_MAX_NAME_LENGTH];
    XnVersion Version;
} XnProductionNodeDescription;

typedef struct XnNodeInfo XnNodeInfo;

typedef struct XnNodeInfoListNode XnNodeInfoListNode;

typedef struct XnNodeInfoList XnNodeInfoList;

typedef struct XnNodeInfoListIterator
{
    XnNodeInfoListNode* pCurrent;
} XnNodeInfoListIterator;

typedef struct XnNodeQuery XnNodeQuery;

typedef struct XnLicense
{
    XnChar strVendor[XN_MAX_NAME_LENGTH];
    XnChar strKey[XN_MAX_LICENSE_LENGTH];
} XnLicense;

typedef struct XnEnumerationErrors XnEnumerationErrors;

typedef void* XnModuleNodeHandle;

typedef void (XN_CALLBACK_TYPE* XnStateChangedHandler)(XnNodeHandle hNode, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnErrorStateChangedHandler)(XnStatus errorState, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnFreeHandler)(const void* pData);

typedef void (XN_CALLBACK_TYPE* XnContextShuttingDownHandler)(XnContext* pContext, void* pCookie);

typedef void* XnCallbackHandle;

typedef struct XnModuleExportedProductionNodeInterface XnModuleExportedProductionNodeInterface; // Forward Declaration

//---------------------------------------------------------------------------
// 3D Vision Types
//---------------------------------------------------------------------------
typedef XnUInt16 XnDepthPixel;

#define XN_DEPTH_NO_SAMPLE_VALUE    ((XnDepthPixel)0)

typedef struct XnRGB24Pixel
{
    XnUInt8 nRed;
    XnUInt8 nGreen;
    XnUInt8 nBlue;
} XnRGB24Pixel;

typedef struct XnYUV422DoublePixel
{
    XnUInt8 nU;
    XnUInt8 nY1;
    XnUInt8 nV;
    XnUInt8 nY2;
} XnYUV422DoublePixel;

typedef XnUInt8 XnGrayscale8Pixel;

typedef XnUInt16 XnGrayscale16Pixel;

typedef XnGrayscale16Pixel XnIRPixel;

typedef XnUInt16 XnLabel;

//---------------------------------------------------------------------------
// Generators Capabilities
//---------------------------------------------------------------------------
#define XN_CAPABILITY_EXTENDED_SERIALIZATION    "ExtendedSerialization"
#define XN_CAPABILITY_MIRROR                    "Mirror"
#define XN_CAPABILITY_ALTERNATIVE_VIEW_POINT    "AlternativeViewPoint"
#define XN_CAPABILITY_CROPPING                  "Cropping"
#define XN_CAPABILITY_USER_POSITION             "UserPosition"
#define XN_CAPABILITY_SKELETON                  "User::Skeleton"
#define XN_CAPABILITY_POSE_DETECTION            "User::PoseDetection"
#define XN_CAPABILITY_LOCK_AWARE                "LockAware"
#define XN_CAPABILITY_ERROR_STATE               "ErrorState"
#define XN_CAPABILITY_FRAME_SYNC                "FrameSync"
#define XN_CAPABILITY_DEVICE_IDENTIFICATION     "DeviceIdentification"
#define XN_CAPABILITY_BRIGHTNESS                "Brightness"
#define XN_CAPABILITY_CONTRAST                  "Contrast"
#define XN_CAPABILITY_HUE                       "Hue"
#define XN_CAPABILITY_SATURATION                "Saturation"
#define XN_CAPABILITY_SHARPNESS                 "Sharpness"
#define XN_CAPABILITY_GAMMA                     "Gamma"
#define XN_CAPABILITY_COLOR_TEMPERATURE         "ColorTemperature"
#define XN_CAPABILITY_BACKLIGHT_COMPENSATION    "BacklightCompensation"
#define XN_CAPABILITY_GAIN                      "Gain"
#define XN_CAPABILITY_PAN                       "Pan"
#define XN_CAPABILITY_TILT                      "Tilt"
#define XN_CAPABILITY_ROLL                      "Roll"
#define XN_CAPABILITY_ZOOM                      "Zoom"
#define XN_CAPABILITY_EXPOSURE                  "Exposure"
#define XN_CAPABILITY_IRIS                      "Iris"
#define XN_CAPABILITY_FOCUS                     "Focus"
#define XN_CAPABILITY_LOW_LIGHT_COMPENSATION    "LowLightCompensation"
#define XN_CAPABILITY_ANTI_FLICKER              "AntiFlicker"
#define XN_CAPABILITY_HAND_TOUCHING_FOV_EDGE    "Hands::HandTouchingFOVEdge"

// Backwards compatibility - typo was fixed
#define XN_CAPABILITY_ANTI_FILCKER              XN_CAPABILITY_ANTI_FLICKER

// deprecated pragma is only supported in Visual Studio
#if (XN_PLATFORM == XN_PLATFORM_WIN32)
#pragma deprecated("XN_CAPABILITY_ANTI_FILCKER")
#endif

//---------------------------------------------------------------------------
// Generators API Structs
//---------------------------------------------------------------------------

#define XN_QQVGA_X_RES  160
#define XN_QQVGA_Y_RES  120

#define XN_CGA_X_RES    320
#define XN_CGA_Y_RES    200

#define XN_QVGA_X_RES   320
#define XN_QVGA_Y_RES   240

#define XN_VGA_X_RES    640
#define XN_VGA_Y_RES    480

#define XN_SVGA_X_RES   800
#define XN_SVGA_Y_RES   600

#define XN_XGA_X_RES    1024
#define XN_XGA_Y_RES    768

#define XN_720P_X_RES   1280
#define XN_720P_Y_RES   720

#define XN_SXGA_X_RES   1280
#define XN_SXGA_Y_RES   1024

#define XN_UXGA_X_RES   1600
#define XN_UXGA_Y_RES   1200

#define XN_1080P_X_RES  1920
#define XN_1080P_Y_RES  1080

#define XN_QCIF_X_RES   176
#define XN_QCIF_Y_RES   144

#define XN_240P_X_RES   423
#define XN_240P_Y_RES   240

#define XN_CIF_X_RES    352
#define XN_CIF_Y_RES    288

#define XN_WVGA_X_RES   640
#define XN_WVGA_Y_RES   360

#define XN_480P_X_RES   864
#define XN_480P_Y_RES   480

#define XN_576P_X_RES   1024
#define XN_576P_Y_RES   576

#define XN_DV_X_RES     960
#define XN_DV_Y_RES     720

typedef enum XnResolution
{
    XN_RES_CUSTOM = 0,
    XN_RES_QQVGA = 1,
    XN_RES_CGA = 2,
    XN_RES_QVGA = 3,
    XN_RES_VGA = 4,
    XN_RES_SVGA = 5,
    XN_RES_XGA = 6,
    XN_RES_720P = 7,
    XN_RES_SXGA = 8,
    XN_RES_UXGA = 9,
    XN_RES_1080P = 10,
    XN_RES_QCIF = 11,
    XN_RES_240P = 12,
    XN_RES_CIF = 13,
    XN_RES_WVGA = 14,
    XN_RES_480P = 15,
    XN_RES_576P = 16,
    XN_RES_DV = 17,
} XnResolution;

typedef struct XnMapOutputMode
{
    XnUInt32 nXRes;
    XnUInt32 nYRes;
    XnUInt32 nFPS;
} XnMapOutputMode;

typedef enum XnSampleRate
{
    XN_SAMPLE_RATE_8K = 8000,
    XN_SAMPLE_RATE_11K = 11025,
    XN_SAMPLE_RATE_12K = 12000,
    XN_SAMPLE_RATE_16K = 16000,
    XN_SAMPLE_RATE_22K = 22050,
    XN_SAMPLE_RATE_24K = 24000,
    XN_SAMPLE_RATE_32K = 32000,
    XN_SAMPLE_RATE_44K = 44100,
    XN_SAMPLE_RATE_48K = 48000,
} XnSampleRate;

typedef struct XnWaveOutputMode
{
    XnUInt32 nSampleRate;
    XnUInt16 nBitsPerSample;
    XnUInt8 nChannels;
} XnWaveOutputMode;

typedef struct XnVector3D
{
    XnFloat X;
    XnFloat Y;
    XnFloat Z;
} XnVector3D;

typedef XnVector3D XnPoint3D;

typedef struct XnBoundingBox3D
{
    XnPoint3D LeftBottomNear;
    XnPoint3D RightTopFar;
} XnBoundingBox3D;

typedef struct XnCropping
{
    XnBool bEnabled;
    XnUInt16 nXOffset;
    XnUInt16 nYOffset;
    XnUInt16 nXSize;
    XnUInt16 nYSize;
} XnCropping;

typedef struct XnFieldOfView
{
    XnDouble fHFOV;
    XnDouble fVFOV;
} XnFieldOfView;

typedef enum XnPixelFormat
{
    XN_PIXEL_FORMAT_RGB24 = 1,
    XN_PIXEL_FORMAT_YUV422 = 2,
    XN_PIXEL_FORMAT_GRAYSCALE_8_BIT = 3,
    XN_PIXEL_FORMAT_GRAYSCALE_16_BIT = 4,
    XN_PIXEL_FORMAT_MJPEG = 5,
} XnPixelFormat;

typedef struct XnSupportedPixelFormats
{
    XnBool m_bRGB24 : 1;
    XnBool m_bYUV422 : 1;
    XnBool m_bGrayscale8Bit : 1;
    XnBool m_bGrayscale16Bit : 1;
    XnBool m_bMJPEG : 1;
    XnUInt m_nPadding : 3;
    XnUInt m_nReserved : 24;
} XnSupportedPixelFormats;

typedef enum XnPlayerSeekOrigin
{
    XN_PLAYER_SEEK_SET = 0,
    XN_PLAYER_SEEK_CUR = 1,
    XN_PLAYER_SEEK_END = 2,
} XnPlayerSeekOrigin;

typedef enum XnPowerLineFrequency
{
    XN_POWER_LINE_FREQUENCY_OFF = 0,
    XN_POWER_LINE_FREQUENCY_50_HZ = 50,
    XN_POWER_LINE_FREQUENCY_60_HZ = 60,
} XnPowerLineFrequency;

// User
typedef XnUInt32 XnUserID;
typedef XnFloat  XnConfidence;

typedef struct XnMatrix3X3
{
    XnFloat elements[9];
} XnMatrix3X3;

typedef struct XnPlane3D
{
    XnVector3D vNormal;

    XnPoint3D ptPoint;
} XnPlane3D;

typedef struct XnSkeletonJointPosition
{
    XnVector3D      position;

    XnConfidence    fConfidence;
} XnSkeletonJointPosition;

typedef struct XnSkeletonJointOrientation
{
    XnMatrix3X3     orientation;
    XnConfidence    fConfidence;
} XnSkeletonJointOrientation;

typedef struct XnSkeletonJointTransformation
{
    XnSkeletonJointPosition     position;
    XnSkeletonJointOrientation  orientation;
} XnSkeletonJointTransformation;

typedef enum XnSkeletonJoint
{
    XN_SKEL_HEAD            = 1,
    XN_SKEL_NECK            = 2,
    XN_SKEL_TORSO           = 3,
    XN_SKEL_WAIST           = 4,

    XN_SKEL_LEFT_COLLAR     = 5,
    XN_SKEL_LEFT_SHOULDER   = 6,
    XN_SKEL_LEFT_ELBOW      = 7,
    XN_SKEL_LEFT_WRIST      = 8,
    XN_SKEL_LEFT_HAND       = 9,
    XN_SKEL_LEFT_FINGERTIP  =10,

    XN_SKEL_RIGHT_COLLAR    =11,
    XN_SKEL_RIGHT_SHOULDER  =12,
    XN_SKEL_RIGHT_ELBOW     =13,
    XN_SKEL_RIGHT_WRIST     =14,
    XN_SKEL_RIGHT_HAND      =15,
    XN_SKEL_RIGHT_FINGERTIP =16,

    XN_SKEL_LEFT_HIP        =17,
    XN_SKEL_LEFT_KNEE       =18,
    XN_SKEL_LEFT_ANKLE      =19,
    XN_SKEL_LEFT_FOOT       =20,

    XN_SKEL_RIGHT_HIP       =21,
    XN_SKEL_RIGHT_KNEE      =22,
    XN_SKEL_RIGHT_ANKLE     =23,
    XN_SKEL_RIGHT_FOOT      =24 
} XnSkeletonJoint;

typedef enum XnSkeletonProfile
{
    XN_SKEL_PROFILE_NONE        = 1,

    XN_SKEL_PROFILE_ALL         = 2,
    
    XN_SKEL_PROFILE_UPPER       = 3,
    
    XN_SKEL_PROFILE_LOWER       = 4,
    
    XN_SKEL_PROFILE_HEAD_HANDS  = 5,
} XnSkeletonProfile;

typedef enum XnPoseDetectionStatus
{
    XN_POSE_DETECTION_STATUS_OK         = 0,
    XN_POSE_DETECTION_STATUS_NO_USER    = 1,
    XN_POSE_DETECTION_STATUS_TOP_FOV    = 2,
    XN_POSE_DETECTION_STATUS_SIDE_FOV   = 3,
    XN_POSE_DETECTION_STATUS_ERROR      = 4,
    XN_POSE_DETECTION_STATUS_NO_TRACKING = 5
} XnPoseDetectionStatus;


typedef enum XnPoseDetectionState
{
    XN_POSE_DETECTION_STATE_IN_POSE     =0,
    XN_POSE_DETECTION_STATE_OUT_OF_POSE =1,
    XN_POSE_DETECTION_STATE_UNDEFINED   =2
} XnPoseDetectionState;
typedef enum XnCalibrationStatus
{
    XN_CALIBRATION_STATUS_OK            = 0,
    XN_CALIBRATION_STATUS_NO_USER       = 1,
    XN_CALIBRATION_STATUS_ARM           = 2,
    XN_CALIBRATION_STATUS_LEG           = 3,
    XN_CALIBRATION_STATUS_HEAD          = 4,
    XN_CALIBRATION_STATUS_TORSO         = 5,
    XN_CALIBRATION_STATUS_TOP_FOV       = 6,
    XN_CALIBRATION_STATUS_SIDE_FOV      = 7,
    XN_CALIBRATION_STATUS_POSE          = 8,
    XN_CALIBRATION_STATUS_MANUAL_ABORT  = 9,
    XN_CALIBRATION_STATUS_MANUAL_RESET  = 10,
    XN_CALIBRATION_STATUS_TIMEOUT_FAIL = 11
} XnCalibrationStatus;

typedef enum XnDirection
{
    XN_DIRECTION_ILLEGAL    = 0,
    XN_DIRECTION_LEFT       = 1,
    XN_DIRECTION_RIGHT      = 2,
    XN_DIRECTION_UP         = 3,
    XN_DIRECTION_DOWN       = 4,
    XN_DIRECTION_FORWARD    = 5,
    XN_DIRECTION_BACKWARD   = 6,
} XnDirection;

// User
typedef void (XN_CALLBACK_TYPE* XnUserHandler)(XnNodeHandle hNode, XnUserID user, void* pCookie);

// Hands
typedef void (XN_CALLBACK_TYPE* XnHandCreate)(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnHandUpdate)(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnHandDestroy)(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnHandTouchingFOVEdge)(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie);
// Gesture Module
typedef void (XN_CALLBACK_TYPE* XnGestureRecognized)(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie);
typedef void (XN_CALLBACK_TYPE* XnGestureProgress)(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnGestureIntermediateStageCompleted)(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
typedef void (XN_CALLBACK_TYPE* XnGestureReadyForNextIntermediateStage)(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);

// Skeleton
typedef void (XN_CALLBACK_TYPE* XnCalibrationStart)(XnNodeHandle hNode, XnUserID user, void* pCookie);
typedef void (XN_CALLBACK_TYPE* XnCalibrationEnd)(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnCalibrationInProgress)(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
typedef void (XN_CALLBACK_TYPE* XnCalibrationComplete)(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);

// Pose Detection
typedef void (XN_CALLBACK_TYPE* XnPoseDetectionCallback)(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnPoseDetectionInProgress)(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseDetectionError, void* pCookie);

//---------------------------------------------------------------------------
// Recorder Types
//---------------------------------------------------------------------------

typedef enum XnRecordMedium
{
    XN_RECORD_MEDIUM_FILE = 0,
} XnRecordMedium;

typedef XnUInt32 XnCodecID;

#define XN_CODEC_ID(c1, c2, c3, c4) (XnCodecID)((c4 << 24) | (c3 << 16) | (c2 << 8) | c1)

typedef struct XnRecorderOutputStreamInterface
{
    XnStatus (XN_CALLBACK_TYPE* Open)(void* pCookie);

    XnStatus (XN_CALLBACK_TYPE* Write)(void* pCookie, const XnChar* strNodeName, 
        const void* pData, XnUInt32 nSize);

    XnStatus (XN_CALLBACK_TYPE* Seek)(void* pCookie, XnOSSeekType seekType, const XnInt32 nOffset);

    XnUInt32 (XN_CALLBACK_TYPE* Tell)(void* pCookie);

    void (XN_CALLBACK_TYPE* Close)(void* pCookie);

    XnStatus (XN_CALLBACK_TYPE* Seek64)(void* pCookie, XnOSSeekType seekType, const XnInt64 nOffset);

    XnUInt64 (XN_CALLBACK_TYPE* Tell64)(void* pCookie);

} XnRecorderOutputStreamInterface;

typedef struct XnPlayerInputStreamInterface
{
    XnStatus (XN_CALLBACK_TYPE* Open)(void* pCookie);

    XnStatus (XN_CALLBACK_TYPE* Read)(void* pCookie, void* pBuffer, XnUInt32 nSize, XnUInt32* pnBytesRead);

    XnStatus (XN_CALLBACK_TYPE* Seek)(void* pCookie, XnOSSeekType seekType, const XnInt32 nOffset);
    
    XnUInt32 (XN_CALLBACK_TYPE* Tell)(void* pCookie);

    void (XN_CALLBACK_TYPE* Close)(void* pCookie);

    XnStatus (XN_CALLBACK_TYPE* Seek64)(void* pCookie, XnOSSeekType seekType, const XnInt64 nOffset);

    XnUInt64 (XN_CALLBACK_TYPE* Tell64)(void* pCookie);

} XnPlayerInputStreamInterface;

typedef struct XnNodeNotifications
{
    XnStatus (XN_CALLBACK_TYPE* OnNodeAdded)
        (void* pCookie, const XnChar* strNodeName, XnProductionNodeType type,
        XnCodecID compression);

    XnStatus (XN_CALLBACK_TYPE* OnNodeRemoved)
        (void* pCookie, const XnChar* strNodeName);

    XnStatus (XN_CALLBACK_TYPE* OnNodeIntPropChanged)
        (void* pCookie, const XnChar* strNodeName, 
        const XnChar* strPropName, XnUInt64 nValue);

    XnStatus (XN_CALLBACK_TYPE* OnNodeRealPropChanged)
        (void* pCookie, const XnChar* strNodeName, 
        const XnChar* strPropName, XnDouble dValue);

    XnStatus (XN_CALLBACK_TYPE* OnNodeStringPropChanged)
        (void* pCookie, const XnChar* strNodeName, 
        const XnChar* strPropName, const XnChar* strValue);

    XnStatus (XN_CALLBACK_TYPE* OnNodeGeneralPropChanged)
        (void* pCookie, const XnChar* strNodeName, 
        const XnChar* strPropName, XnUInt32 nBufferSize, const void* pBuffer);

    XnStatus (XN_CALLBACK_TYPE* OnNodeStateReady)
        (void* pCookie, const XnChar* strNodeName);

    XnStatus (XN_CALLBACK_TYPE* OnNodeNewData)
        (void* pCookie, const XnChar* strNodeName,
        XnUInt64 nTimeStamp, XnUInt32 nFrame, const void* pData, XnUInt32 nSize);

} XnNodeNotifications;

typedef struct XnUInt32XYPair
{
    XnUInt32 X;
    XnUInt32 Y;
} XnUInt32XYPair;

typedef struct XnOutputMetaData
{
    XnUInt64 nTimestamp;

    XnUInt32 nFrameID;
    
    XnUInt32 nDataSize;

    XnBool bIsNew;

} XnOutputMetaData;

typedef struct XnMapMetaData
{
    XnOutputMetaData* pOutput;

    XnUInt32XYPair Res;
    
    XnUInt32XYPair Offset;
    
    XnUInt32XYPair FullRes;
    
    XnPixelFormat PixelFormat;
    
    XnUInt32 nFPS;
} XnMapMetaData;

typedef struct XnDepthMetaData
{
    XnMapMetaData* pMap;
    
    const XnDepthPixel* pData;
    
    XnDepthPixel nZRes;
} XnDepthMetaData;

typedef struct XnImageMetaData
{
    XnMapMetaData* pMap;
    
    const XnUInt8* pData;
} XnImageMetaData;

typedef struct XnIRMetaData
{
    XnMapMetaData* pMap;
    
    const XnIRPixel* pData;
} XnIRMetaData;

typedef struct XnAudioMetaData
{
    XnOutputMetaData* pOutput;

    XnWaveOutputMode Wave;
    
    const XnUInt8* pData;
} XnAudioMetaData;

typedef struct XnSceneMetaData
{
    XnMapMetaData* pMap;

    const XnLabel* pData;
} XnSceneMetaData;

#if XN_PLATFORM != XN_PLATFORM_ARC
#pragma pack (pop)
#endif

#endif //__XN_TYPES_H__