OpenNI.h

浏览该文件的文档.

/*****************************************************************************
*                                                                            *
*  OpenNI 2.x Alpha                                                          *
*  Copyright (C) 2012 PrimeSense Ltd.                                        *
*                                                                            *
*  This file is part of OpenNI.                                              *
*                                                                            *
*  Licensed under the Apache License, Version 2.0 (the "License");           *
*  you may not use this file except in compliance with the License.          *
*  You may obtain a copy of the License at                                   *
*                                                                            *
*      http://www.apache.org/licenses/LICENSE-2.0                            *
*                                                                            *
*  Unless required by applicable law or agreed to in writing, software       *
*  distributed under the License is distributed on an "AS IS" BASIS,         *
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
*  See the License for the specific language governing permissions and       *
*  limitations under the License.                                            *
*                                                                            *
*****************************************************************************/
#ifndef OPENNI_H
#define OPENNI_H

#include "OniPlatform.h"
#include "OniProperties.h"
#include "OniEnums.h"

#include "OniCAPI.h"
#include "OniCProperties.h"
#include "OniCTypes.h"

namespace openni
{

typedef uint16_t                DepthPixel;

typedef uint16_t                Grayscale16Pixel;

// structs
typedef struct
{
    int major;
    int minor;
    int maintenance;
    int build;
} Version;

typedef struct
{
    /* Red value of this pixel. */
    uint8_t r;
    /* Green value of this pixel. */
    uint8_t g;
    /* Blue value of this pixel. */
    uint8_t b;
} RGB888Pixel;

typedef struct
{
    uint8_t u;
    uint8_t y1;
    uint8_t v;
    uint8_t y2;
} YUV422DoublePixel;

typedef struct
{
    uint8_t y1;
    uint8_t u;
    uint8_t y2;
    uint8_t v;
} YUYVDoublePixel;

class _NullString
{
public:
    _NullString() {}
    operator const char*() const { return NULL; }
};

static const _NullString ANY_DEVICE;

template<class T>
class Array
{
public:
    Array() : m_data(NULL), m_count(0), m_owner(false) {}

    Array(const T* data, int count) : m_owner(false) { _setData(data, count); }

    ~Array()
    {
        clear();
    }

    int getSize() const { return m_count; }

    const T& operator[](int index) const {return m_data[index];}

    void _setData(const T* data, int count, bool isOwner = false)
    {
        clear();
        m_count = count;
        m_owner = isOwner;
        if (!isOwner)
        {
            m_data = data;
        }
        else
        {
            m_data = new T[count];
            memcpy((void*)m_data, data, count*sizeof(T));
        }
    }

private:
    Array(const Array<T>&);
    Array<T>& operator=(const Array<T>&);

    void clear()
    {
        if (m_owner && m_data != NULL)
            delete []m_data;
        m_owner = false;
        m_data = NULL;
        m_count = 0;
    }

    const T* m_data;
    int m_count;
    bool m_owner;
};

// Forward declaration of all
class SensorInfo;
class VideoStream;
class VideoFrameRef;
class Device;
class OpenNI;
class CameraSettings;
class PlaybackControl;

class VideoMode : private OniVideoMode
{
public:
    VideoMode()
    {}

    VideoMode(const VideoMode& other)
    {
        *this = other;
    }

    VideoMode& operator=(const VideoMode& other)
    {
        setPixelFormat(other.getPixelFormat());
        setResolution(other.getResolutionX(), other.getResolutionY());
        setFps(other.getFps());

        return *this;
    }

    PixelFormat getPixelFormat() const { return (PixelFormat)pixelFormat; }

    int getResolutionX() const { return resolutionX; }

    int getResolutionY() const {return resolutionY;}

    int getFps() const { return fps; }

    void setPixelFormat(PixelFormat format) { this->pixelFormat = (OniPixelFormat)format; }

    void setResolution(int resolutionX, int resolutionY)
    {
        this->resolutionX = resolutionX;
        this->resolutionY = resolutionY;
    }

    void setFps(int fps) { this->fps = fps; }

    friend class SensorInfo;
    friend class VideoStream;
    friend class VideoFrameRef;
};

class SensorInfo
{
public:
    SensorType getSensorType() const { return (SensorType)m_pInfo->sensorType; }

    const Array<VideoMode>& getSupportedVideoModes() const { return m_videoModes; }

private:
    SensorInfo(const SensorInfo&);
    SensorInfo& operator=(const SensorInfo&);

    SensorInfo() : m_pInfo(NULL), m_videoModes(NULL, 0) {}

    SensorInfo(const OniSensorInfo* pInfo) : m_pInfo(NULL), m_videoModes(NULL, 0)
    {
        _setInternal(pInfo);
    }

    void _setInternal(const OniSensorInfo* pInfo)
    {
        m_pInfo = pInfo;
        if (pInfo == NULL)
        {
            m_videoModes._setData(NULL, 0);
        }
        else
        {
            m_videoModes._setData(static_cast<VideoMode*>(pInfo->pSupportedVideoModes), pInfo->numSupportedVideoModes);
        }
    }

    const OniSensorInfo* m_pInfo;
    Array<VideoMode> m_videoModes;

    friend class VideoStream;
    friend class Device;
};

class DeviceInfo : private OniDeviceInfo
{
public:
    const char* getUri() const { return uri; }
    const char* getVendor() const { return vendor; }
    const char* getName() const { return name; }
    uint16_t getUsbVendorId() const { return usbVendorId; }
    uint16_t getUsbProductId() const { return usbProductId; }

    friend class Device;
    friend class OpenNI;
};

class VideoFrameRef
{
public:
    VideoFrameRef()
    {
        m_pFrame = NULL;
    }

    ~VideoFrameRef()
    {
        release();
    }

    VideoFrameRef(const VideoFrameRef& other) : m_pFrame(NULL)
    {
        _setFrame(other.m_pFrame);
    }

    VideoFrameRef& operator=(const VideoFrameRef& other)
    {
        _setFrame(other.m_pFrame);
        return *this;
    }

    inline int getDataSize() const
    {
        return m_pFrame->dataSize;
    }

    inline const void* getData() const
    {
        return m_pFrame->data;
    }

    inline SensorType getSensorType() const
    {
        return (SensorType)m_pFrame->sensorType;
    }

    inline const VideoMode& getVideoMode() const
    {
        return static_cast<const VideoMode&>(m_pFrame->videoMode);
    }

    inline uint64_t getTimestamp() const
    {
        return m_pFrame->timestamp;
    }

    inline int getFrameIndex() const
    {
        return m_pFrame->frameIndex;
    }

    inline int getWidth() const
    {
        return m_pFrame->width;
    }

    inline int getHeight() const
    {
        return m_pFrame->height;
    }

    inline bool getCroppingEnabled() const
    {
        return m_pFrame->croppingEnabled == TRUE;
    }

    inline int getCropOriginX() const
    {
        return m_pFrame->cropOriginX;
    }

    inline int getCropOriginY() const
    {
        return m_pFrame->cropOriginY;
    }

    inline int getStrideInBytes() const
    {
        return m_pFrame->stride;
    }

    inline bool isValid() const
    {
        return m_pFrame != NULL;
    }

    void release()
    {
        if (m_pFrame != NULL)
        {
            oniFrameRelease(m_pFrame);
            m_pFrame = NULL;
        }
    }

    void _setFrame(OniFrame* pFrame)
    {
        setReference(pFrame);
        if (pFrame != NULL)
        {
            oniFrameAddRef(pFrame);
        }
    }

    OniFrame* _getFrame()
    {
        return m_pFrame;
    }

private:
    friend class VideoStream;
    inline void setReference(OniFrame* pFrame)
    {
        // Initial - don't addref. This is the reference from OpenNI
        release();
        m_pFrame = pFrame;
    }

    OniFrame* m_pFrame; // const!!?
};

class VideoStream
{
public:
    class NewFrameListener
    {
    public:
        NewFrameListener() : m_callbackHandle(NULL)
        {
        }

        virtual ~NewFrameListener()
        {
        }

        virtual void onNewFrame(VideoStream&) = 0;

    private:
        friend class VideoStream;

        static void ONI_CALLBACK_TYPE callback(OniStreamHandle streamHandle, void* pCookie)
        {
            NewFrameListener* pListener = (NewFrameListener*)pCookie;
            VideoStream stream;
            stream._setHandle(streamHandle);
            pListener->onNewFrame(stream);
            stream._setHandle(NULL);
        }
        OniCallbackHandle m_callbackHandle;
    };

    class FrameAllocator
    {
    public:
        virtual ~FrameAllocator() {}
        virtual void* allocateFrameBuffer(int size) = 0;
        virtual void freeFrameBuffer(void* data) = 0;

    private:
        friend class VideoStream;

        static void* ONI_CALLBACK_TYPE allocateFrameBufferCallback(int size, void* pCookie)
        {
            FrameAllocator* pThis = (FrameAllocator*)pCookie;
            return pThis->allocateFrameBuffer(size);
        }

        static void ONI_CALLBACK_TYPE freeFrameBufferCallback(void* data, void* pCookie)
        {
            FrameAllocator* pThis = (FrameAllocator*)pCookie;
            pThis->freeFrameBuffer(data);
        }
    };

    VideoStream() : m_stream(NULL), m_sensorInfo(), m_pCameraSettings(NULL), m_isOwner(true)
    {}

    explicit VideoStream(OniStreamHandle handle) : m_stream(NULL), m_sensorInfo(), m_pCameraSettings(NULL), m_isOwner(false)
    {
        _setHandle(handle);
    }

    ~VideoStream()
    {
        destroy();
    }

    bool isValid() const
    {
        return m_stream != NULL;
    }

    inline Status create(const Device& device, SensorType sensorType);

    inline void destroy();

    const SensorInfo& getSensorInfo() const
    {
        return m_sensorInfo;
    }

    ParamsRegistrationMode getSoftwareRegistratorMode(){

        ParamsRegistrationMode mode;
        Status rc = getProperty(STREAM_PROPERTY_SOFTWARE_REGISTRATION, &mode);
        if (rc != STATUS_OK)
        {
            return PARAMS_REGISTRATION_OFF;
        }
        return mode;
    }

    void setSoftwareRegistrator(ParamsRegistrationMode mode){
        setProperty(STREAM_PROPERTY_SOFTWARE_REGISTRATION, (int)mode); 
    }

    Status start()
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        return (Status)oniStreamStart(m_stream);
    }

    void stop()
    {
        if (!isValid())
        {
            return;
        }

        oniStreamStop(m_stream);
    }

    Status readFrame(VideoFrameRef* pFrame)
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        OniFrame* pOniFrame;
        Status rc = (Status)oniStreamReadFrame(m_stream, &pOniFrame);

        pFrame->setReference(pOniFrame);
        return rc;
    }

    Status addNewFrameListener(NewFrameListener* pListener)
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        return (Status)oniStreamRegisterNewFrameCallback(m_stream, pListener->callback, pListener, &pListener->m_callbackHandle);
    }

    void removeNewFrameListener(NewFrameListener* pListener)
    {
        if (!isValid())
        {
            return;
        }

        oniStreamUnregisterNewFrameCallback(m_stream, pListener->m_callbackHandle);
        pListener->m_callbackHandle = NULL;
    }

    Status setFrameBuffersAllocator(FrameAllocator* pAllocator)
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        if (pAllocator == NULL)
        {
            return (Status)oniStreamSetFrameBuffersAllocator(m_stream, NULL, NULL, NULL);
        }
        else
        {
            return (Status)oniStreamSetFrameBuffersAllocator(m_stream, pAllocator->allocateFrameBufferCallback, pAllocator->freeFrameBufferCallback, pAllocator);
        }
    }

    OniStreamHandle _getHandle() const
    {
        return m_stream;
    }

    CameraSettings* getCameraSettings() {return m_pCameraSettings;}

    Status getProperty(int propertyId, void* data, int* dataSize) const
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        return (Status)oniStreamGetProperty(m_stream, propertyId, data, dataSize);
    }

    Status setProperty(int propertyId, const void* data, int dataSize)
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        return (Status)oniStreamSetProperty(m_stream, propertyId, data, dataSize);
    }

    VideoMode getVideoMode() const
    {
        VideoMode videoMode;
        getProperty<OniVideoMode>(STREAM_PROPERTY_VIDEO_MODE, static_cast<OniVideoMode*>(&videoMode));
        return videoMode;
    }

    Status setVideoMode(const VideoMode& videoMode)
    {
        return setProperty<OniVideoMode>(STREAM_PROPERTY_VIDEO_MODE, static_cast<const OniVideoMode&>(videoMode));
    }

    int getMaxPixelValue() const
    {
        int maxValue;
        Status rc = getProperty<int>(STREAM_PROPERTY_MAX_VALUE, &maxValue);
        if (rc != STATUS_OK)
        {
            return 0;
        }
        return maxValue;
    }

    int getMinPixelValue() const
    {
        int minValue;
        Status rc = getProperty<int>(STREAM_PROPERTY_MIN_VALUE, &minValue);
        if (rc != STATUS_OK)
        {
            return 0;
        }
        return minValue;
    }

    bool isCroppingSupported() const
    {
        return isPropertySupported(STREAM_PROPERTY_CROPPING);
    }

    bool getCropping(int* pOriginX, int* pOriginY, int* pWidth, int* pHeight) const
    {
        OniCropping cropping;
        bool enabled = false;

        Status rc = getProperty<OniCropping>(STREAM_PROPERTY_CROPPING, &cropping);

        if (rc == STATUS_OK)
        {
            *pOriginX = cropping.originX;
            *pOriginY = cropping.originY;
            *pWidth = cropping.width;
            *pHeight = cropping.height;
            enabled = (cropping.enabled == TRUE);
        }

        return enabled;
    }

    Status setCropping(int originX, int originY, int width, int height)
    {
        OniCropping cropping;
        cropping.enabled = true;
        cropping.originX = originX;
        cropping.originY = originY;
        cropping.width = width;
        cropping.height = height;
        return setProperty<OniCropping>(STREAM_PROPERTY_CROPPING, cropping);
    }

    Status resetCropping()
    {
        OniCropping cropping;
        cropping.enabled = false;
        return setProperty<OniCropping>(STREAM_PROPERTY_CROPPING, cropping);
    }

    bool getMirroringEnabled() const
    {
        OniBool enabled;
        Status rc = getProperty<OniBool>(STREAM_PROPERTY_MIRRORING, &enabled);
        if (rc != STATUS_OK)
        {
            return false;
        }
        return enabled == TRUE;
    }

    Status setMirroringEnabled(bool isEnabled)
    {
        return setProperty<OniBool>(STREAM_PROPERTY_MIRRORING, isEnabled ? TRUE : FALSE);
    }

    float getHorizontalFieldOfView() const
    {
        float horizontal = 0;
        getProperty<float>(STREAM_PROPERTY_HORIZONTAL_FOV, &horizontal);
        return horizontal;
    }

    float getVerticalFieldOfView() const
    {
        float vertical = 0;
        getProperty<float>(STREAM_PROPERTY_VERTICAL_FOV, &vertical);
        return vertical;
    }

    template <class T>
    Status setProperty(int propertyId, const T& value)
    {
        return setProperty(propertyId, &value, sizeof(T));
    }

    template <class T>
    Status getProperty(int propertyId, T* value) const
    {
        int size = sizeof(T);
        return getProperty(propertyId, value, &size);
    }

    bool isPropertySupported(int propertyId) const
    {
        if (!isValid())
        {
            return false;
        }

        return oniStreamIsPropertySupported(m_stream, propertyId) == TRUE;
    }

    Status invoke(int commandId, void* data, int dataSize)
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }

        return (Status)oniStreamInvoke(m_stream, commandId, data, dataSize);
    }

    template <class T>
    Status invoke(int commandId, T& value)
    {
        return invoke(commandId, &value, sizeof(T));
    }

    bool isCommandSupported(int commandId) const
    {
        if (!isValid())
        {
            return false;
        }

        return (Status)oniStreamIsCommandSupported(m_stream, commandId) == TRUE;
    }

    void filterSpeckles(void*  buf,   int newVal, int maxSpeckleSize, int maxDiff){
        oniStreamfilter(m_stream,  buf,  newVal,  maxSpeckleSize,  maxDiff);
    }

private:
    friend class Device;

    void _setHandle(OniStreamHandle stream)
    {
        m_sensorInfo._setInternal(NULL);
        m_stream = stream;

        if (stream != NULL)
        {
            m_sensorInfo._setInternal(oniStreamGetSensorInfo(m_stream));
        }
    }

private:
    VideoStream(const VideoStream& other);
    VideoStream& operator=(const VideoStream& other);

    OniStreamHandle m_stream;
    SensorInfo m_sensorInfo;
    CameraSettings* m_pCameraSettings;
    bool m_isOwner;
};

class Device
{
public:
    Device() : m_pPlaybackControl(NULL), m_device(NULL), m_isOwner(true)
    {
        clearSensors();
    }

    explicit Device(OniDeviceHandle handle) : m_pPlaybackControl(NULL), m_device(NULL), m_isOwner(false)
    {
        _setHandle(handle);
    }

    ~Device()
    {
        if (m_device != NULL)
        {
            close();
        }
    }

    inline Status open(const char* uri);

    inline void close();

    const DeviceInfo& getDeviceInfo() const
    {
        return m_deviceInfo;
    }

    bool hasSensor(SensorType sensorType)
    {
        int i;
        for (i = 0; (i < ONI_MAX_SENSORS) && (m_aSensorInfo[i].m_pInfo != NULL); ++i)
        {
            if (m_aSensorInfo[i].getSensorType() == sensorType)
            {
                return true;
            }
        }

        if (i == ONI_MAX_SENSORS)
        {
            return false;
        }

        const OniSensorInfo* pInfo = oniDeviceGetSensorInfo(m_device, (OniSensorType)sensorType);

        if (pInfo == NULL)
        {
            return false;
        }

        m_aSensorInfo[i]._setInternal(pInfo);

        return true;
    }

    const SensorInfo* getSensorInfo(SensorType sensorType)
    {
        int i;
        for (i = 0; (i < ONI_MAX_SENSORS) && (m_aSensorInfo[i].m_pInfo != NULL); ++i)
        {
            if (m_aSensorInfo[i].getSensorType() == sensorType)
            {
                return &m_aSensorInfo[i];
            }
        }

        // not found. check to see we have additional space
        if (i == ONI_MAX_SENSORS)
        {
            return NULL;
        }

        const OniSensorInfo* pInfo = oniDeviceGetSensorInfo(m_device, (OniSensorType)sensorType);
        if (pInfo == NULL)
        {
            return NULL;
        }

        m_aSensorInfo[i]._setInternal(pInfo);
        return &m_aSensorInfo[i];
    }

    OniDeviceHandle _getHandle() const
    {
        return m_device;
    }

    PlaybackControl* getPlaybackControl() {return m_pPlaybackControl;}

    Status getProperty(int propertyId, void* data, int* dataSize) const
    {
        return (Status)oniDeviceGetProperty(m_device, propertyId, data, dataSize);
    }

    Status setProperty(int propertyId, const void* data, int dataSize)
    {
        return (Status)oniDeviceSetProperty(m_device, propertyId, data, dataSize);
    }
    
    void setGain(int gain) {
        oniDeviceSetProperty(m_device, OBEXTENSION_ID_IR_GAIN, &gain, sizeof(gain));
    }

    int getGain() {
        int value = 0;
        int size = sizeof(value);
        oniDeviceGetProperty(m_device, openni::OBEXTENSION_ID_IR_GAIN, (uint16_t *)&value, &size);
        return value;
    }
    bool isImageRegistrationModeSupported(ImageRegistrationMode mode) const
    {
        return (oniDeviceIsImageRegistrationModeSupported(m_device, (OniImageRegistrationMode)mode) == TRUE);
    }

    ImageRegistrationMode getImageRegistrationMode() const
    {
        ImageRegistrationMode mode;
        Status rc = getProperty<ImageRegistrationMode>(DEVICE_PROPERTY_IMAGE_REGISTRATION, &mode);
        if (rc != STATUS_OK)
        {
            return IMAGE_REGISTRATION_OFF;
        }
        return mode;
    }

    Status setImageRegistrationMode(ImageRegistrationMode mode)
    {
        return setProperty<ImageRegistrationMode>(DEVICE_PROPERTY_IMAGE_REGISTRATION, mode);
    }

    bool isValid() const
    {
        return m_device != NULL;
    }

    bool isFile() const
    {
        return isPropertySupported(DEVICE_PROPERTY_PLAYBACK_SPEED) &&
            isPropertySupported(DEVICE_PROPERTY_PLAYBACK_REPEAT_ENABLED) &&
            isCommandSupported(DEVICE_COMMAND_SEEK);
    }

    Status setDepthColorSyncEnabled(bool isEnabled)
    {
        Status rc = STATUS_OK;

        if (isEnabled)
        {
            rc = (Status)oniDeviceEnableDepthColorSync(m_device);
        }
        else
        {
            oniDeviceDisableDepthColorSync(m_device);
        }

        return rc;
    }

    bool getDepthColorSyncEnabled()
    {
        return oniDeviceGetDepthColorSyncEnabled(m_device) == TRUE;
    }

    template <class T>
    Status setProperty(int propertyId, const T& value)
    {
        return setProperty(propertyId, &value, sizeof(T));
    }

    template <class T>
    Status getProperty(int propertyId, T* value) const
    {
        int size = sizeof(T);
        return getProperty(propertyId, value, &size);
    }

    bool isPropertySupported(int propertyId) const
    {
        return oniDeviceIsPropertySupported(m_device, propertyId) == TRUE;
    }

    Status invoke(int commandId, void* data, int dataSize)
    {
        return (Status)oniDeviceInvoke(m_device, commandId, data, dataSize);
    }

    template <class T>
    Status invoke(int propertyId, T& value)
    {
        return invoke(propertyId, &value, sizeof(T));
    }

    bool isCommandSupported(int commandId) const
    {
        return oniDeviceIsCommandSupported(m_device, commandId) == TRUE;
    }

    inline Status _openEx(const char* uri, const char* mode);

private:
    Device(const Device&);
    Device& operator=(const Device&);

    void clearSensors()
    {
        for (int i = 0; i < ONI_MAX_SENSORS; ++i)
        {
            m_aSensorInfo[i]._setInternal(NULL);
        }
    }

    inline Status _setHandle(OniDeviceHandle deviceHandle);

private:
    PlaybackControl* m_pPlaybackControl;

    OniDeviceHandle m_device;
    DeviceInfo m_deviceInfo;
    SensorInfo m_aSensorInfo[ONI_MAX_SENSORS];

    bool m_isOwner;
};

class PlaybackControl
{
public:

    ~PlaybackControl()
    {
        detach();
    }

    float getSpeed() const
    {
        if (!isValid())
        {
            return 0.0f;
        }
        float speed;
        Status rc = m_pDevice->getProperty<float>(DEVICE_PROPERTY_PLAYBACK_SPEED, &speed);
        if (rc != STATUS_OK)
        {
            return 1.0f;
        }
        return speed;
    }
    Status setSpeed(float speed)
    {
        if (!isValid())
        {
            return STATUS_NO_DEVICE;
        }
        return m_pDevice->setProperty<float>(DEVICE_PROPERTY_PLAYBACK_SPEED, speed);
    }

    bool getRepeatEnabled() const
    {
        if (!isValid())
        {
            return false;
        }

        OniBool repeat;
        Status rc = m_pDevice->getProperty<OniBool>(DEVICE_PROPERTY_PLAYBACK_REPEAT_ENABLED, &repeat);
        if (rc != STATUS_OK)
        {
            return false;
        }

        return repeat == TRUE;
    }

    Status setRepeatEnabled(bool repeat)
    {
        if (!isValid())
        {
            return STATUS_NO_DEVICE;
        }

        return m_pDevice->setProperty<OniBool>(DEVICE_PROPERTY_PLAYBACK_REPEAT_ENABLED, repeat ? TRUE : FALSE);
    }

    Status seek(const VideoStream& stream, int frameIndex)
    {
        if (!isValid())
        {
            return STATUS_NO_DEVICE;
        }
        OniSeek seek;
        seek.frameIndex = frameIndex;
        seek.stream = stream._getHandle();
        return m_pDevice->invoke(DEVICE_COMMAND_SEEK, seek);
    }

    int getNumberOfFrames(const VideoStream& stream) const
    {
        int numOfFrames = -1;
        Status rc = stream.getProperty<int>(STREAM_PROPERTY_NUMBER_OF_FRAMES, &numOfFrames);
        if (rc != STATUS_OK)
        {
            return 0;
        }
        return numOfFrames;
    }

    bool isValid() const
    {
        return m_pDevice != NULL;
    }
private:
    Status attach(Device* device)
    {
        if (!device->isValid() || !device->isFile())
        {
            return STATUS_ERROR;
        }

        detach();
        m_pDevice = device;

        return STATUS_OK;
    }
    void detach()
    {
        m_pDevice = NULL;
    }

    friend class Device;
    PlaybackControl(Device* pDevice) : m_pDevice(NULL)
    {
        if (pDevice != NULL)
        {
            attach(pDevice);
        }
    }

    Device* m_pDevice;
};

class CameraSettings
{
public:
    // setters
    Status setAutoExposureEnabled(bool enabled)
    {
        return setProperty(STREAM_PROPERTY_AUTO_EXPOSURE, enabled ? TRUE : FALSE);
    }
    Status setAutoWhiteBalanceEnabled(bool enabled)
    {
        return setProperty(STREAM_PROPERTY_AUTO_WHITE_BALANCE, enabled ? TRUE : FALSE);
    }

    bool getAutoExposureEnabled() const
    {
        OniBool enabled = FALSE;

        Status rc = getProperty(STREAM_PROPERTY_AUTO_EXPOSURE, &enabled);
        return rc == STATUS_OK && enabled == TRUE;
    }
    bool getAutoWhiteBalanceEnabled() const
    {
        OniBool enabled = FALSE;

        Status rc = getProperty(STREAM_PROPERTY_AUTO_WHITE_BALANCE, &enabled);
        return rc == STATUS_OK && enabled == TRUE;
    }

    Status setGain(int gain)
    {
        return setProperty(STREAM_PROPERTY_GAIN, gain);
    }
    Status setExposure(int exposure)
    {
        return setProperty(STREAM_PROPERTY_EXPOSURE, exposure);
    }
    int getGain()
    {
        int gain;
        Status rc = getProperty(STREAM_PROPERTY_GAIN, &gain);
        if (rc != STATUS_OK)
        {
            return 100;
        }
        return gain;
    }
    int getExposure()
    {
        int exposure;
        Status rc = getProperty(STREAM_PROPERTY_EXPOSURE, &exposure);
        if (rc != STATUS_OK)
        {
            return 0;
        }
        return exposure;
    }

    bool isValid() const {return m_pStream != NULL;}
private:
    template <class T>
    Status getProperty(int propertyId, T* value) const
    {
        if (!isValid()) return STATUS_NOT_SUPPORTED;

        return m_pStream->getProperty<T>(propertyId, value);
    }
    template <class T>
    Status setProperty(int propertyId, const T& value)
    {
        if (!isValid()) return STATUS_NOT_SUPPORTED;

        return m_pStream->setProperty<T>(propertyId, value);
    }

    friend class VideoStream;
    CameraSettings(VideoStream* pStream)
    {
        m_pStream = pStream;
    }

    VideoStream* m_pStream;
};


class OpenNI
{
public:

    class DeviceConnectedListener
    {
    public:
        DeviceConnectedListener()
        {
            m_deviceConnectedCallbacks.deviceConnected = deviceConnectedCallback;
            m_deviceConnectedCallbacks.deviceDisconnected = NULL;
            m_deviceConnectedCallbacks.deviceStateChanged = NULL;
            m_deviceConnectedCallbacksHandle = NULL;
        }
        
        virtual ~DeviceConnectedListener()
        {
        }
        
        virtual void onDeviceConnected(const DeviceInfo*) = 0;
    private:
        static void ONI_CALLBACK_TYPE deviceConnectedCallback(const OniDeviceInfo* pInfo, void* pCookie)
        {
            DeviceConnectedListener* pListener = (DeviceConnectedListener*)pCookie;
            pListener->onDeviceConnected(static_cast<const DeviceInfo*>(pInfo));
        }

        friend class OpenNI;
        OniDeviceCallbacks m_deviceConnectedCallbacks;
        OniCallbackHandle m_deviceConnectedCallbacksHandle;

    };
    class DeviceDisconnectedListener
    {
    public:
        DeviceDisconnectedListener()
        {
            m_deviceDisconnectedCallbacks.deviceConnected = NULL;
            m_deviceDisconnectedCallbacks.deviceDisconnected = deviceDisconnectedCallback;
            m_deviceDisconnectedCallbacks.deviceStateChanged = NULL;
            m_deviceDisconnectedCallbacksHandle = NULL;
        }
        
        virtual ~DeviceDisconnectedListener()
        {
        }
        
        virtual void onDeviceDisconnected(const DeviceInfo*) = 0;
    private:
        static void ONI_CALLBACK_TYPE deviceDisconnectedCallback(const OniDeviceInfo* pInfo, void* pCookie)
        {
            DeviceDisconnectedListener* pListener = (DeviceDisconnectedListener*)pCookie;
            pListener->onDeviceDisconnected(static_cast<const DeviceInfo*>(pInfo));
        }

        friend class OpenNI;
        OniDeviceCallbacks m_deviceDisconnectedCallbacks;
        OniCallbackHandle m_deviceDisconnectedCallbacksHandle;
    };
    class DeviceStateChangedListener
    {
    public:
        DeviceStateChangedListener()
        {
            m_deviceStateChangedCallbacks.deviceConnected = NULL;
            m_deviceStateChangedCallbacks.deviceDisconnected = NULL;
            m_deviceStateChangedCallbacks.deviceStateChanged = deviceStateChangedCallback;
            m_deviceStateChangedCallbacksHandle = NULL;
        }
        
        virtual ~DeviceStateChangedListener()
        {
        }
        
        virtual void onDeviceStateChanged(const DeviceInfo*, DeviceState) = 0;
    private:
        static void ONI_CALLBACK_TYPE deviceStateChangedCallback(const OniDeviceInfo* pInfo, OniDeviceState state, void* pCookie)
        {
            DeviceStateChangedListener* pListener = (DeviceStateChangedListener*)pCookie;
            pListener->onDeviceStateChanged(static_cast<const DeviceInfo*>(pInfo), DeviceState(state));
        }

        friend class OpenNI;
        OniDeviceCallbacks m_deviceStateChangedCallbacks;
        OniCallbackHandle m_deviceStateChangedCallbacksHandle;
    };

    static Status initialize()
    {
        return (Status)oniInitialize(ONI_API_VERSION); // provide version of API, to make sure proper struct sizes are used
    }
    
    static void shutdown()
    {
        oniShutdown();
    }

    static Version getVersion()
    {
        OniVersion oniVersion = oniGetVersion();
        Version version;
        version.major = oniVersion.major;
        version.minor = oniVersion.minor;
        version.maintenance = oniVersion.maintenance;
        version.build = oniVersion.build;
        return version;
    }

    static const char* getExtendedError()
    {
        return oniGetExtendedError();
    }

    static void enumerateDevices(Array<DeviceInfo>* deviceInfoList)
    {
        OniDeviceInfo* m_pDeviceInfos;
        int m_deviceInfoCount;
        oniGetDeviceList(&m_pDeviceInfos, &m_deviceInfoCount);
        deviceInfoList->_setData((DeviceInfo*)m_pDeviceInfos, m_deviceInfoCount, true);
        oniReleaseDeviceList(m_pDeviceInfos);
    }

    static Status waitForAnyStream(VideoStream** pStreams, int streamCount, int* pReadyStreamIndex, int timeout = TIMEOUT_FOREVER)
    {
        static const int ONI_MAX_STREAMS = 50;
        OniStreamHandle streams[ONI_MAX_STREAMS];

        if (streamCount > ONI_MAX_STREAMS)
        {
            printf("Too many streams for wait: %d > %d\n", streamCount, ONI_MAX_STREAMS);
            return STATUS_BAD_PARAMETER;
        }

        *pReadyStreamIndex = -1;
        for (int i = 0; i < streamCount; ++i)
        {
            if (pStreams[i] != NULL)
            {
                streams[i] = pStreams[i]->_getHandle();
            }
            else
            {
                streams[i] = NULL;
            }
        }
        Status rc = (Status)oniWaitForAnyStream(streams, streamCount, pReadyStreamIndex, timeout);

        return rc;
    }

    static Status addDeviceConnectedListener(DeviceConnectedListener* pListener)
    {
        if (pListener->m_deviceConnectedCallbacksHandle != NULL)
        {
            return STATUS_ERROR;
        }
        return (Status)oniRegisterDeviceCallbacks(&pListener->m_deviceConnectedCallbacks, pListener, &pListener->m_deviceConnectedCallbacksHandle);
    }
    static Status addDeviceDisconnectedListener(DeviceDisconnectedListener* pListener)
    {
        if (pListener->m_deviceDisconnectedCallbacksHandle != NULL)
        {
            return STATUS_ERROR;
        }
        return (Status)oniRegisterDeviceCallbacks(&pListener->m_deviceDisconnectedCallbacks, pListener, &pListener->m_deviceDisconnectedCallbacksHandle);
    }
    static Status addDeviceStateChangedListener(DeviceStateChangedListener* pListener)
    {
        if (pListener->m_deviceStateChangedCallbacksHandle != NULL)
        {
            return STATUS_ERROR;
        }
        return (Status)oniRegisterDeviceCallbacks(&pListener->m_deviceStateChangedCallbacks, pListener, &pListener->m_deviceStateChangedCallbacksHandle);
    }
    static void removeDeviceConnectedListener(DeviceConnectedListener* pListener)
    {
        oniUnregisterDeviceCallbacks(pListener->m_deviceConnectedCallbacksHandle);
        pListener->m_deviceConnectedCallbacksHandle = NULL;
    }
    static void removeDeviceDisconnectedListener(DeviceDisconnectedListener* pListener)
    {
        oniUnregisterDeviceCallbacks(pListener->m_deviceDisconnectedCallbacksHandle);
        pListener->m_deviceDisconnectedCallbacksHandle = NULL;
    }
    static void removeDeviceStateChangedListener(DeviceStateChangedListener* pListener)
    {
        oniUnregisterDeviceCallbacks(pListener->m_deviceStateChangedCallbacksHandle);
        pListener->m_deviceStateChangedCallbacksHandle = NULL;
    }

    static Status setLogOutputFolder(const char *strLogOutputFolder)
    {
        return (Status)oniSetLogOutputFolder(strLogOutputFolder);
    }

    static Status getLogFileName(char *strFileName, int nBufferSize)
    {
        return (Status)oniGetLogFileName(strFileName, nBufferSize);
    }

    static Status setLogMinSeverity(int nMinSeverity)
    {
        return(Status) oniSetLogMinSeverity(nMinSeverity);
    }
    
    static Status setLogConsoleOutput(bool bConsoleOutput)
    {
        return (Status)oniSetLogConsoleOutput(bConsoleOutput);
    }

    static Status setLogFileOutput(bool bFileOutput)
    {
        return (Status)oniSetLogFileOutput(bFileOutput);
    }

    #if ONI_PLATFORM == ONI_PLATFORM_ANDROID_ARM

    static Status setLogAndroidOutput(bool bAndroidOutput)
    {
        return (Status)oniSetLogAndroidOutput(bAndroidOutput);
    }
    #endif
    
private:
    OpenNI()
    {
    }
};

class CoordinateConverter
{
public:
    static Status convertWorldToDepth(const VideoStream& depthStream, float worldX, float worldY, float worldZ, int* pDepthX, int* pDepthY, DepthPixel* pDepthZ)
    {
        float depthX, depthY, depthZ;
        Status rc = (Status)oniCoordinateConverterWorldToDepth(depthStream._getHandle(), worldX, worldY, worldZ, &depthX, &depthY, &depthZ);
        *pDepthX = (int)depthX;
        *pDepthY = (int)depthY;
        *pDepthZ = (DepthPixel)depthZ;
        return rc;
    }

    static Status convertWorldToDepth(const VideoStream& depthStream, float worldX, float worldY, float worldZ, float* pDepthX, float* pDepthY, float* pDepthZ)
    {
        return (Status)oniCoordinateConverterWorldToDepth(depthStream._getHandle(), worldX, worldY, worldZ, pDepthX, pDepthY, pDepthZ);
    }

    static Status convertDepthToWorld(const VideoStream& depthStream, int depthX, int depthY, DepthPixel depthZ, float* pWorldX, float* pWorldY, float* pWorldZ)
    {
        return (Status)oniCoordinateConverterDepthToWorld(depthStream._getHandle(), float(depthX), float(depthY), float(depthZ), pWorldX, pWorldY, pWorldZ);
    }

    static Status convertDepthToWorld(const VideoStream& depthStream, float depthX, float depthY, float depthZ, float* pWorldX, float* pWorldY, float* pWorldZ)
    {
        return (Status)oniCoordinateConverterDepthToWorld(depthStream._getHandle(), depthX, depthY, depthZ, pWorldX, pWorldY, pWorldZ);
    }

    static Status convertDepthToColor(const VideoStream& depthStream, const VideoStream& colorStream, int depthX, int depthY, DepthPixel depthZ, int* pColorX, int* pColorY)
    {
        return (Status)oniCoordinateConverterDepthToColor(depthStream._getHandle(), colorStream._getHandle(), depthX, depthY, depthZ, pColorX, pColorY);
    }

    static Status convertC2DCoordinateByIntrinsic(const VideoStream& depthStream,  int colorX, int colorY, DepthPixel depthZ, int* pDepthX, int* pDepthY)
    {
        return (Status)oniCoordinateConverterC2D(depthStream._getHandle(),  colorX, colorY, depthZ, pDepthX,  pDepthY);
    }
    static Status convertD2CCoordinateByIntrinsic(const VideoStream& depthStream,  int depthX, int depthY, DepthPixel depthZ, int* pColorX, int* pColorY)
    {
        return (Status)oniCoordinateConverterD2C(depthStream._getHandle(), depthX, depthY, depthZ, pColorX, pColorY);
    }
};

class Recorder
{
public:
    Recorder() : m_recorder(NULL)
    {
    }

    ~Recorder()
    {
        destroy();
    }

    Status create(const char* fileName)
    {
        if (!isValid())
        {
            return (Status)oniCreateRecorder(fileName, &m_recorder);
        }
        return STATUS_ERROR;
    }

    bool isValid() const
    {
        return NULL != getHandle();
    }

    Status attach(VideoStream& stream, bool allowLossyCompression = false)
    {
        if (!isValid() || !stream.isValid())
        {
            return STATUS_ERROR;
        }
        return (Status)oniRecorderAttachStream(
                m_recorder,
                stream._getHandle(),
                allowLossyCompression);
    }

    Status start()
    {
        if (!isValid())
        {
            return STATUS_ERROR;
        }
        return (Status)oniRecorderStart(m_recorder);
    }

    void stop()
    {
        if (isValid())
        {
            oniRecorderStop(m_recorder);
        }
    }

    void destroy()
    {
        if (isValid())
        {
            oniRecorderDestroy(&m_recorder);
        }
    }

private:
    Recorder(const Recorder&);
    Recorder& operator=(const Recorder&);

    OniRecorderHandle getHandle() const
    {
        return m_recorder;
    }


    OniRecorderHandle m_recorder;
};

// Implemetation
Status VideoStream::create(const Device& device, SensorType sensorType)
{
    OniStreamHandle streamHandle;
    Status rc = (Status)oniDeviceCreateStream(device._getHandle(), (OniSensorType)sensorType, &streamHandle);
    if (rc != STATUS_OK)
    {
        return rc;
    }

    m_isOwner = true;
    _setHandle(streamHandle);

    if (isPropertySupported(STREAM_PROPERTY_AUTO_WHITE_BALANCE) && isPropertySupported(STREAM_PROPERTY_AUTO_EXPOSURE))
    {
        m_pCameraSettings = new CameraSettings(this);
    }

    return STATUS_OK;
}

void VideoStream::destroy()
{
    if (!isValid())
    {
        return;
    }

    if (m_pCameraSettings != NULL)
    {
        delete m_pCameraSettings;
        m_pCameraSettings = NULL;
    }

    if (m_stream != NULL)
    {
        if(m_isOwner)
            oniStreamDestroy(m_stream);
        m_stream = NULL;
    }
}

Status Device::open(const char* uri)
{
    //If we are not the owners, we stick with our own device
    if(!m_isOwner)
    {
        if(isValid()){
            return STATUS_OK;
        }else{
            return STATUS_OUT_OF_FLOW;
        }
    }

    OniDeviceHandle deviceHandle;
    Status rc = (Status)oniDeviceOpen(uri, &deviceHandle);
    if (rc != STATUS_OK)
    {
        return rc;
    }

    _setHandle(deviceHandle);

    return STATUS_OK;
}

Status Device::_openEx(const char* uri, const char* mode)
{
    //If we are not the owners, we stick with our own device
    if(!m_isOwner)
    {
        if(isValid()){
            return STATUS_OK;
        }else{
            return STATUS_OUT_OF_FLOW;
        }
    }

    OniDeviceHandle deviceHandle;
    Status rc = (Status)oniDeviceOpenEx(uri, mode, &deviceHandle);
    if (rc != STATUS_OK)
    {
        return rc;
    }

    _setHandle(deviceHandle);

    return STATUS_OK;
}

Status Device::_setHandle(OniDeviceHandle deviceHandle)
{
    if (m_device == NULL)
    {
        m_device = deviceHandle;

        clearSensors();

        oniDeviceGetInfo(m_device, &m_deviceInfo);

        if (isFile())
        {
            m_pPlaybackControl = new PlaybackControl(this);
        }

        // Read deviceInfo
        return STATUS_OK;
    }

    return STATUS_OUT_OF_FLOW;
}

void Device::close()
{
    if (m_pPlaybackControl != NULL)
    {
        delete m_pPlaybackControl;
        m_pPlaybackControl = NULL;
    }

    if (m_device != NULL)
    {
        if(m_isOwner)
        {
            oniDeviceClose(m_device);
        }

        m_device = NULL;
    }
}

}

#endif // OPENNI_H