camera_plugin.h

// Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/

#ifndef NX_CAMERA_PLUGIN_H
#define NX_CAMERA_PLUGIN_H

#include <cstring>

#include <stdint.h>

#include <plugins/plugin_api.h>

#include "camera_plugin_types.h"


namespace nxcip
{
    // TODO: Change to signed int64_t.
    typedef unsigned long long int UsecUTCTimestamp;
    static const UsecUTCTimestamp INVALID_TIMESTAMP_VALUE = (UsecUTCTimestamp)-1LL;

    static const int MAX_TEXT_LEN = 1024;

    //Error codes. Interface implementation MUST use these error codes when appropriate

    static const int NX_NO_ERROR = 0;
    static const int NX_NOT_AUTHORIZED = -1;
    static const int NX_INVALID_ENCODER_NUMBER = -2;
    static const int NX_UNKNOWN_PORT_NAME = -3;
    static const int NX_UNSUPPORTED_CODEC = -8;
    static const int NX_UNSUPPORTED_RESOLUTION = -9;
    static const int NX_UNDEFINED_BEHAVOUR = -20;
    static const int NX_NOT_IMPLEMENTED = -21;
    static const int NX_NETWORK_ERROR = -22;
    static const int NX_MORE_DATA = -23;
    static const int NX_NO_DATA = -24;
    static const int NX_IO_ERROR = -25;
    static const int NX_TRY_AGAIN = -26;
    static const int NX_INTERRUPTED = -27;
    static const int NX_PARAM_READ_ONLY = -40;
    static const int NX_UNKNOWN_PARAMETER = -41;
    static const int NX_INVALID_PARAM_VALUE = -42;
    static const int NX_OTHER_ERROR = -100;

    class BaseCameraManager;

    // {0D06134F-16D0-41c8-9752-A33E81FE9C75}
    static const nxpl::NX_GUID IID_CameraDiscoveryManager = { { 0x0d, 0x06, 0x13, 0x4f, 0x16, 0xd0, 0x41, 0xc8, 0x97, 0x52, 0xa3, 0x3e, 0x81, 0xfe, 0x9c, 0x75 } };

    // {0D06134F-16D0-41c8-9752-A33E81FE9C74}
    static const nxpl::NX_GUID IID_CameraDiscoveryManager2 = { { 0x0d, 0x06, 0x13, 0x4f, 0x16, 0xd0, 0x41, 0xc8, 0x97, 0x52, 0xa3, 0x3e, 0x81, 0xfe, 0x9c, 0x74 } };

    // {FEA0452D-8493-4FF3-83E9-72D5BF75A9DE}
    static const nxpl::NX_GUID IID_CameraDiscoveryManager3 = { { 0xFE, 0xA0, 0x45, 0x2D, 0x84, 0x93, 0x4F, 0xF3, 0x83, 0xE9, 0x72, 0xD5, 0xBF, 0x75, 0xA9, 0xDE } };

    struct CameraInfo
    {
        char modelName[256] = {};
        char firmware[256] = {};
        char uid[256] = {};
        char url[MAX_TEXT_LEN] = {};
        char auxiliaryData[256] = {};
        char defaultLogin[256] = {};
        char defaultPassword[256] = {};

        CameraInfo() = default;

        CameraInfo(const CameraInfo& value)
        {
            strncpy(modelName, value.modelName, sizeof(modelName) - 1);
            modelName[sizeof(modelName) - 1] = '\0';

            strncpy(firmware, value.firmware, sizeof(firmware) - 1);
            firmware[sizeof(firmware) - 1] = '\0';

            strncpy(uid, value.uid, sizeof(uid) - 1);
            uid[sizeof(uid) - 1] = '\0';

            strncpy(url, value.url, sizeof(url) - 1);
            url[sizeof(url) - 1] = '\0';

            strncpy(auxiliaryData, value.auxiliaryData, sizeof(auxiliaryData) - 1);
            auxiliaryData[sizeof(auxiliaryData) - 1] = '\0';

            strncpy(defaultLogin, value.defaultLogin, sizeof(defaultLogin) - 1);
            defaultLogin[sizeof(defaultLogin) - 1] = '\0';

            strncpy(defaultPassword, value.defaultPassword, sizeof(defaultPassword) - 1);
            defaultPassword[sizeof(defaultPassword) - 1] = '\0';
        }
    };

    struct CameraInfo2: public CameraInfo
    {
        CameraInfo2(): CameraInfo()
        {
            groupId[0] = 0;
            groupName[0] = 0;
        }

        CameraInfo2(const CameraInfo& value):
            CameraInfo(value)
        {
            groupId[0] = 0;
            groupName[0] = 0;
        }

        CameraInfo2(const CameraInfo2& value):
            CameraInfo(value)
        {
            strncpy(groupId, value.groupId, sizeof(groupId) - 1);
            strncpy(groupName, value.groupName, sizeof(groupName) - 1);
        }

        char groupId[256];
        char groupName[256];
    };

    static const int CAMERA_INFO_ARRAY_SIZE = 256;
    static const int MAX_MODEL_NAME_SIZE = 256;


    class CameraDiscoveryManager: public nxpl::PluginInterface
    {
    public:
        virtual ~CameraDiscoveryManager() {}


        virtual void getVendorName( char* buf ) const = 0;


        virtual int findCameras( CameraInfo* cameras, const char* serverURL ) = 0;

        virtual int checkHostAddress( CameraInfo* cameras, const char* address, const char* login, const char* password ) = 0;

        virtual int fromMDNSData(
            const char* discoveryAddress,
            const unsigned char* mdnsResponsePacket,
            int mdnsResponsePacketSize,
            CameraInfo* cameraInfo ) = 0;

        virtual int fromUpnpData( const char* upnpXMLData, int upnpXMLDataSize, CameraInfo* cameraInfo ) = 0;


        virtual BaseCameraManager* createCameraManager( const CameraInfo& info ) = 0;


        virtual int getReservedModelList( char** modelList, int* count ) = 0;
    };

    class CameraDiscoveryManager2: public CameraDiscoveryManager
    {
    public:
        CameraDiscoveryManager2() = default;

        virtual int checkHostAddress2(nxcip::CameraInfo2* cameras, const char* address, const char* login, const char* password) = 0;
        virtual int findCameras2(CameraInfo2* cameras, const char* serverURL) = 0;
    };

    class CameraDiscoveryManager3 : public CameraDiscoveryManager2
    {
    public:
        enum Capability
        {
            noCapability = 0,
            findLocalResources = 1 //< CameraDiscovery can find local resources without IP.
        };

        CameraDiscoveryManager3() = default;
        virtual int getCapabilities() const = 0;
    };

    struct Resolution
    {
        int width;
        int height;

        Resolution( int _width = 0, int _height = 0 )
        :
            width( _width ),
            height( _height )
        {
        }
    };

    struct ResolutionInfo
    {
        Resolution resolution;
        float maxFps;

        ResolutionInfo()
        :
            maxFps( 0 )
        {
        }
    };

    class StreamReader;

    // {528FD641-52BB-4f8b-B279-6C21FEF5A2BB}
    static const nxpl::NX_GUID IID_CameraMediaEncoder = { { 0x52, 0x8f, 0xd6, 0x41, 0x52, 0xbb, 0x4f, 0x8b, 0xb2, 0x79, 0x6c, 0x21, 0xfe, 0xf5, 0xa2, 0xbb } };

    static const int MAX_RESOLUTION_LIST_SIZE = 64;

    class CameraMediaEncoder
    :
        public nxpl::PluginInterface
    {
    public:
        virtual ~CameraMediaEncoder() {}


        virtual int getMediaUrl( char* urlBuf ) const = 0;


        virtual int getResolutionList( ResolutionInfo* infoList, int* infoListCount ) const = 0;


        virtual int getMaxBitrate( int* maxBitrate ) const = 0;


        virtual int setResolution( const Resolution& resolution ) = 0;

        virtual int setFps( const float& fps, float* selectedFps ) = 0;

        virtual int setBitrate( int bitrateKbps, int* selectedBitrateKbps ) = 0;
    };

    struct AudioFormat
    {
        enum SampleType
        {
            stNone = -1,
            stU8,   
            stS16,  
            stS32,  
            stFLT, 
            stDBL, 
            stU8P, 
            stS16P, 
            stS32P, 
            stFLTP, 
            stDBLP, 
            stS64, 
            stS64P, 
        };

        enum ByteOrderType
        {
            boLittleEndian,
            boBigEndian
        };

        CompressionType compressionType;
        int sampleRate;
        int bitrate;
        ByteOrderType byteOrder;
        int channels;
        SampleType sampleFmt;
        int channelLayout;
        int blockAlign;
        int bitsPerCodedSample;

        AudioFormat()
        :
            compressionType(AV_CODEC_ID_NONE),
            sampleRate(0),
            bitrate(0),
            byteOrder(boLittleEndian),
            channels(0),
            sampleFmt(stU8),
            channelLayout(0),
            blockAlign(0),
            bitsPerCodedSample(0)
        {
        }
    };

    // {9A1BDA18-563C-42de-8E23-B9244FD00658}
    static const nxpl::NX_GUID IID_CameraMediaEncoder2 = { { 0x9a, 0x1b, 0xda, 0x18, 0x56, 0x3c, 0x42, 0xde, 0x8e, 0x23, 0xb9, 0x24, 0x4f, 0xd0, 0x6, 0x58 } };

    class CameraMediaEncoder2: public CameraMediaEncoder
    {
    public:
        virtual ~CameraMediaEncoder2() override {}


        virtual StreamReader* getLiveStreamReader() = 0;
        virtual int getAudioFormat( AudioFormat* audioFormat ) const = 0;
    };

#ifndef __GNUC__
#pragma pack(push, 1)
#define PACKED
#else
#define PACKED __attribute__((__packed__))
#endif

    struct PACKED LiveStreamConfig
    {
        enum LiveStreamFlags
        {
            LIVE_STREAM_FLAG_AUDIO_ENABLED = 0x1
        };

        int32_t reserved_head;      
        int32_t flags;              
        int32_t codec;              
        int32_t width;
        int32_t height;
        float framerate;
        int32_t bitrateKbps;
        int16_t quality;
        int16_t gopLength;
        uint8_t reserved_tail[96];  
    };
#ifndef __GNUC__
#pragma pack(pop)
#endif
#undef PACKED

    // {D1C7F082-B6F9-45F3-82D6-3CFE3EAE0260}
    static const nxpl::NX_GUID IID_CameraMediaEncoder3 = { { 0xd1, 0xc7, 0xf0, 0x82, 0xb6, 0xf9, 0x45, 0xf3, 0x82, 0xd6, 0x3c, 0xfe, 0x3e, 0xae, 0x2, 0x60 } };

    class CameraMediaEncoder3: public CameraMediaEncoder2
    {
    public:

        virtual int getConfiguredLiveStreamReader(LiveStreamConfig * config, StreamReader ** reader) = 0;


        virtual int getVideoFormat(CompressionType * codec, PixelFormat * pixelFormat) const = 0;
    };

    // {9807EA20-FA37-4EA7-BF07-9AC61511E1DF}
    static const nxpl::NX_GUID IID_CameraMediaEncoder4 = { { 0x98, 0x07, 0xEA ,0x20, 0xFA, 0x37, 0x4E, 0xA7, 0xBF, 0x07, 0x9A, 0xC6 ,0x15 ,0x11 ,0xE1, 0xDF } };
    class CameraMediaEncoder4: public CameraMediaEncoder3
    {
    public:
        virtual int setMediaUrl(const char url[nxcip::MAX_TEXT_LEN]) = 0;
    };

    // {95d69238-7a07-462f-9364-971dd58b315e}
    static const nxpl::NX_GUID IID_CameraMediaEncoder5 = { { 0x95, 0xd6, 0x92 ,0x38, 0x7a, 0x07, 0x46, 0x2f, 0x93, 0x64, 0x97, 0x1d ,0xd5 ,0x8b ,0x31, 0x5e } };
    class CameraMediaEncoder5: public CameraMediaEncoder4
    {
    public:
        virtual const char* audioExtradata() const = 0;

        virtual int audioExtradataSize() const = 0;
    };

    class CameraPtzManager;
    class CameraMotionDataProvider;
    class CameraRelayIOManager;
    class DtsArchiveReader;

    // {B7AA2FE8-7592-4459-A52F-B05E8E089AFE}
    static const nxpl::NX_GUID IID_BaseCameraManager = { { 0xb7, 0xaa, 0x2f, 0xe8, 0x75, 0x92, 0x44, 0x59, 0xa5, 0x2f, 0xb0, 0x5e, 0x8e, 0x8, 0x9a, 0xfe } };


    class BaseCameraManager
    :
        public nxpl::PluginInterface
    {
    public:
        virtual ~BaseCameraManager() {}


        virtual int getEncoderCount( int* encoderCount ) const = 0;


        virtual int getEncoder( int encoderIndex, CameraMediaEncoder** encoderPtr ) = 0;


        virtual int getCameraInfo( CameraInfo* info ) const = 0;

        enum CameraCapability
        {
            hardwareMotionCapability            = 0x0001,     
            relayInputCapability                = 0x0002,     
            relayOutputCapability               = 0x0004,     
            ptzCapability                       = 0x0008,     
            audioCapability                     = 0x0010,     
            shareFpsCapability                  = 0x0020,     
            sharePixelsCapability               = 0x0040,     
            shareIpCapability                   = 0x0080,     
            dtsArchiveCapability                = 0x0100,     
            nativeMediaStreamCapability         = 0x0200,     
            primaryStreamSoftMotionCapability   = 0x0400,     
            cameraParamsPersistentCapability    = 0x0800,     
            searchByMotionMaskCapability        = 0x1000,     
            motionRegionCapability              = 0x2000,     
            needIFrameDetectionCapability       = 0x4000,     
            relativeTimestampCapability         = 0x8000,     
            customMediaUrlCapability            = 0x10000,    
            cameraTimeCapability                = 0x20000,    
            fixedQualityCapability              = 0x40000,    
            MulticastStreamCapability           = 0x80000,    
            ServerBoundCapability               = 0x100000,   
            dontAutoOpenCamera                  = 0x200000,   
            noAnalytics                         = 0x400000,   
            noVideo                             = 0x800000,   

            ioDeviceCapability                  = 0x1000000
        };


        virtual int getCameraCapabilities( unsigned int* capabilitiesMask ) const = 0;

        virtual void setCredentials( const char* username, const char* password ) = 0;


        virtual int setAudioEnabled( int audioEnabled ) = 0;


        virtual CameraPtzManager* getPtzManager() const = 0;

        virtual CameraMotionDataProvider* getCameraMotionDataProvider() const = 0;

        virtual CameraRelayIOManager* getCameraRelayIOManager() const = 0;


        virtual void getLastErrorString( char* errorString ) const = 0;
    };

    // {A2017C29-CE9E-4829-87BE-9287598A1358}
    static const nxpl::NX_GUID IID_Picture = { { 0xa2, 0x01, 0x7c, 0x29, 0xce, 0x9e, 0x48, 0x29, 0x87, 0xbe, 0x92, 0x87, 0x59, 0x8a, 0x13, 0x58 } };

    class Picture
    :
        public nxpl::PluginInterface
    {
    public:
        virtual ~Picture() {}

        virtual PixelFormat pixelFormat() const = 0;
        virtual int planeCount() const = 0;
        virtual int width() const = 0;
        virtual int height() const = 0;
        virtual int xStride( int planeNumber ) const = 0;
        virtual const void* scanLine( int planeNumber, int lineNumber ) const = 0;
        virtual void* scanLine( int planeNumber, int lineNumber ) = 0;
        virtual void* data() = 0;
        virtual const void* data() const = 0;
    };

    // {8006CC9F-7BDD-4a4c-8920-AC5546D4924A}
    static const nxpl::NX_GUID IID_TimePeriods = { { 0x80, 0x06, 0xcc, 0x9f, 0x7b, 0xdd, 0x4a, 0x4c, 0x89, 0x20, 0xac, 0x55, 0x46, 0xd4, 0x92, 0x4a } };

    class TimePeriods
    :
        public nxpl::PluginInterface
    {
    public:
        virtual void goToBeginning() = 0;
        virtual bool next() = 0;
        virtual bool atEnd() const = 0;
        virtual bool get( UsecUTCTimestamp* start, UsecUTCTimestamp* end ) const = 0;
    };

    struct ArchiveSearchOptions
    {
    public:
        Picture* motionMask;
        UsecUTCTimestamp startTime;
        UsecUTCTimestamp endTime;
        unsigned long long periodDetailLevel;

        bool keepSmallChunks;

        int limit;

        bool descSortOrder;

        ArchiveSearchOptions()
        :
            motionMask( 0 ),
            startTime( INVALID_TIMESTAMP_VALUE ),
            endTime( INVALID_TIMESTAMP_VALUE ),
            periodDetailLevel(0),
            keepSmallChunks(0),
            limit(0),
            descSortOrder(false)
        {
        }
    };

    // {1181F23B-071C-4608-89E3-648E1A735B54}
    static const nxpl::NX_GUID IID_BaseCameraManager2 = { { 0x11, 0x81, 0xf2, 0x3b, 0x07, 0x1c, 0x46, 0x08, 0x89, 0xe3, 0x64, 0x8e, 0x1a, 0x73, 0x5b, 0x54 } };

    class BaseCameraManager2
    :
        public BaseCameraManager
    {
    public:
        enum CameraCapability2
        {
            searchByMotionMaskCapability = 0x1000,  
            motionRegionCapability = 0x2000         
        };

        virtual ~BaseCameraManager2() {}


        virtual int createDtsArchiveReader( DtsArchiveReader** dtsArchiveReader ) const = 0;

        virtual int find( ArchiveSearchOptions* searchOptions, TimePeriods** timePeriods ) const = 0;

        virtual int setMotionMask( Picture* motionMask ) = 0;
    };

    // {840DEECD-2F9B-4859-9081-9592D17177F8}
    static const nxpl::NX_GUID IID_BaseCameraManager3 = { { 0x84, 0x0d, 0xee, 0xcd, 0x2f, 0x9b, 0x48, 0x59, 0x90, 0x81, 0x95, 0x92, 0xd1, 0x71, 0x77, 0xf8 } };


    class BaseCameraManager3
    :
        public BaseCameraManager2
    {
    public:
        enum CameraCapability3
        {
            cameraParamsPersistentCapability   = 0x0800,    
        };


        virtual const char* getParametersDescriptionXML() const = 0;

        virtual int getParamValue( const char* paramName, char* valueBuf, int* valueBufSize ) const = 0;

        virtual int setParamValue( const char* paramName, const char* value ) = 0;
    };

    // {8BAB5BC7-BEFC-4629-921F-8390A29D8A16}
    static const nxpl::NX_GUID IID_CameraPTZManager = { { 0x8b, 0xab, 0x5b, 0xc7, 0xbe, 0xfc, 0x46, 0x29, 0x92, 0x1f, 0x83, 0x90, 0xa2, 0x9d, 0x8a, 0x16 } };


    class CameraPtzManager
    :
        public nxpl::PluginInterface
    {
    public:
        virtual ~CameraPtzManager() {}

        enum Capability
        {
            ContinuousPanCapability             = 0x00000001,   
            ContinuousTiltCapability            = 0x00000002,   
            ContinuousZoomCapability            = 0x00000004,   

            AbsolutePanCapability               = 0x00000010,   
            AbsoluteTiltCapability              = 0x00000020,   
            AbsoluteZoomCapability              = 0x00000040,   

            FlipPtzCapability                   = 0x00000100,   
            LimitsPtzCapability                 = 0x00000200,   

            DevicePositioningPtzCapability      = 0x00001000,   
            LogicalPositioningPtzCapability     = 0x00002000,   

            ContinuousPtzCapabilities           = ContinuousPanCapability | ContinuousTiltCapability | ContinuousZoomCapability,
            AbsolutePtzCapabilities             = AbsolutePanCapability | AbsoluteTiltCapability | AbsoluteZoomCapability,
        };

        enum CoordinateSpace
        {
            DevicePtzCoordinateSpace,    
            LogicalPtzCoordinateSpace    
        };

        enum Orientation
        {
            Horizontal = 0x1,
            Vertical = 0x2
        };

        struct Limits {
            double minPan;
            double maxPan;
            double minTilt;
            double maxTilt;
            double minFov;
            double maxFov;
        };

        virtual int getCapabilities() const = 0;


        virtual int continuousMove( double panSpeed, double tiltSpeed, double zoomSpeed ) = 0;


        virtual int absoluteMove( CoordinateSpace space, double pan, double tilt, double zoom, double speed ) = 0;


        virtual int getPosition( CoordinateSpace space, double *pan, double *tilt, double *zoom ) = 0;


        virtual int getLimits( CoordinateSpace space, Limits *limits ) = 0;


        virtual int getFlip( int *flip ) = 0;
    };

    enum DataPacketType
    {
        dptAudio,
        dptVideo,

        dptEmpty,
        dptUnknown,
        dptData,
    };

    // {763C93DC-A77D-41ff-8071-B64C4D3AFCFF}
    static const nxpl::NX_GUID IID_MediaDataPacket = { { 0x76, 0x3c, 0x93, 0xdc, 0xa7, 0x7d, 0x41, 0xff, 0x80, 0x71, 0xb6, 0x4c, 0x4d, 0x3a, 0xfc, 0xff } };
    static const unsigned int MEDIA_DATA_BUFFER_ALIGNMENT = 64;
    static const unsigned int MEDIA_PACKET_BUFFER_PADDING_SIZE = 64;


    class MediaDataPacket
    :
        public nxpl::PluginInterface
    {
    public:
        enum Flags
        {
            fKeyPacket          = 0x01,
            fReverseStream      = 0x02,
            fReverseBlockStart  = 0x04,
            DEPRECATED_fLowQuality = 0x08,
            fStreamReset        = 0x10
        };

        virtual UsecUTCTimestamp timestamp() const = 0;
        virtual DataPacketType type() const = 0;

        virtual const void* data() const = 0;

        virtual unsigned int dataSize() const = 0;
        virtual unsigned int channelNumber() const = 0;

        virtual CompressionType codecType() const = 0;

        virtual unsigned int flags() const = 0;

        virtual unsigned int cSeq() const = 0;
    };

    // {65E9548D-0BA6-48CB-A217-AE6AE270CE7D}
    static const nxpl::NX_GUID IID_MediaDataPacket2 = { { 0x65, 0xe9, 0x54, 0x8d, 0x0b, 0xa6, 0x48, 0xcb, 0xa2, 0x17, 0xae, 0x6a, 0xe2, 0x70, 0xce, 0x7d } };

    class MediaDataPacket2: public MediaDataPacket
    {
    public:
        virtual const char* extradata() const = 0;

        virtual int extradataSize() const = 0;
    };

    // {A3F5D1BA-5A74-42BD-8890-A1C6E0197C04}
    static const nxpl::NX_GUID IID_Encryptable = { { 0xa3, 0xf5, 0xd1, 0xba, 0x5a, 0x74, 0x42, 0xbd, 0x88, 0x90, 0xa1, 0xc6, 0xe0, 0x19, 0x7c, 0x4  } };

    class Encryptable
    {
    public:
        virtual const uint8_t* encryptionData() const = 0;
        virtual int encryptionDataSize() const = 0;
    };

    static const unsigned int DEFAULT_MOTION_DATA_PICTURE_WIDTH = 44;
    static const unsigned int DEFAULT_MOTION_DATA_PICTURE_HEIGHT = 32;

    // {A85D884B-F05E-4fff-8B5A-E36570E73067}
    static const nxpl::NX_GUID IID_VideoDataPacket = { { 0xa8, 0x5d, 0x88, 0x4b, 0xf0, 0x5e, 0x4f, 0xff, 0x8b, 0x5a, 0xe3, 0x65, 0x70, 0xe7, 0x30, 0x67 } };

    class VideoDataPacket
    :
        public MediaDataPacket
    {
    public:

        virtual Picture* getMotionData() const = 0;
    };

    // {AFE4EEDA-3770-42c3-8381-EE3B55522551}
    static const nxpl::NX_GUID IID_StreamReader = { { 0xaf, 0xe4, 0xee, 0xda, 0x37, 0x70, 0x42, 0xc3, 0x83, 0x81, 0xee, 0x3b, 0x55, 0x52, 0x25, 0x51 } };


    class StreamReader
    :
        public nxpl::PluginInterface
    {
    public:

        virtual int getNextData( MediaDataPacket** packet ) = 0;

        virtual void interrupt() = 0;
    };

    enum MediaStreamQuality
    {
        msqDefault = 0,

        msqHigh,
        msqLow
    };

    // {CEB97832-E931-4965-9B18-A8A1557107D7}
    static const nxpl::NX_GUID IID_DtsArchiveReader = { { 0xce, 0xb9, 0x78, 0x32, 0xe9, 0x31, 0x49, 0x65, 0x9b, 0x18, 0xa8, 0xa1, 0x55, 0x71, 0x7, 0xd7 } };


    class DtsArchiveReader
    :
        public nxpl::PluginInterface
    {
    public:
        enum Capabilities
        {

            reverseGopModeCapability        = 0x01,

            skipFramesCapability            = 0x02,
            motionDataCapability            = 0x04
        };

        virtual unsigned int getCapabilities() const = 0;


        virtual int open() = 0;

        virtual StreamReader* getStreamReader() = 0;

        virtual UsecUTCTimestamp startTime() const = 0;

        virtual UsecUTCTimestamp endTime() const = 0;

        virtual int seek(
            unsigned int cSeq,
            UsecUTCTimestamp timestamp,
            bool findKeyFrame,
            UsecUTCTimestamp* selectedPosition ) = 0;

        virtual int setReverseMode(
            unsigned int cSeq,
            bool isReverse,
            UsecUTCTimestamp timestamp,
            UsecUTCTimestamp* selectedPosition ) = 0;
        virtual bool isReverseModeEnabled() const = 0;

        virtual int setMotionDataEnabled( bool motionPresent ) = 0;

        virtual int setQuality(
            MediaStreamQuality quality,
            bool waitForKeyFrame ) = 0;

        virtual int playRange(
            unsigned int cSeq,
            UsecUTCTimestamp start,
            UsecUTCTimestamp endTimeHint,
            unsigned int step ) = 0;


        virtual void getLastErrorString( char* errorString ) const = 0;
    };

    // {C6F06A48-8E3A-4690-8B21-CAC4A955D7ED}
    static const nxpl::NX_GUID IID_CameraMotionDataProvider = { { 0xc6, 0xf0, 0x6a, 0x48, 0x8e, 0x3a, 0x46, 0x90, 0x8b, 0x21, 0xca, 0xc4, 0xa9, 0x55, 0xd7, 0xed } };

    class CameraMotionDataProvider
    :
        public nxpl::PluginInterface
    {
    public:
        //TODO for future use
    };

    class CameraInputEventHandler;

    // {872F473F-72CF-4397-81E6-C06D42E97113}
    static const nxpl::NX_GUID IID_CameraRelayIOManager = { { 0x87, 0x2f, 0x47, 0x3f, 0x72, 0xcf, 0x43, 0x97, 0x81, 0xe6, 0xc0, 0x6d, 0x42, 0xe9, 0x71, 0x13 } };

    static const int MAX_ID_LEN = 64;
    static const int MAX_RELAY_PORT_COUNT = 32;


    class CameraRelayIOManager
    :
        public nxpl::PluginInterface
    {
    public:

        virtual int getRelayOutputList( char** idList, int* idNum ) const = 0;


        virtual int getInputPortList( char** idList, int* idNum ) const = 0;


        virtual int setRelayOutputState(
            const char* outputId,
            int activate,
            unsigned int autoResetTimeoutMS ) = 0;


        virtual int startInputPortMonitoring() = 0;


        virtual void stopInputPortMonitoring() = 0;


        virtual void registerEventHandler( CameraInputEventHandler* handler ) = 0;


        virtual void unregisterEventHandler( CameraInputEventHandler* handler ) = 0;


        virtual void getLastErrorString( char* errorString ) const = 0;
    };

    // {CC1E749F-2EC6-4b73-BEC9-8F2AE9B7FCCE}
    static const nxpl::NX_GUID IID_CameraInputEventHandler = { { 0xcc, 0x1e, 0x74, 0x9f, 0x2e, 0xc6, 0x4b, 0x73, 0xbe, 0xc9, 0x8f, 0x2a, 0xe9, 0xb7, 0xfc, 0xce } };

    class CameraInputEventHandler
    :
        public nxpl::PluginInterface
    {
    public:
        virtual ~CameraInputEventHandler() {}


        virtual void inputPortStateChanged(
            CameraRelayIOManager* source,
            const char* inputPortID,
            int newState,
            unsigned long int timestamp ) = 0;
    };
}

#endif  //NX_CAMERA_PLUGIN_H