camtypes.h

Go to the documentation of this file.

/**************************************************************************
 *
 * File: camtypes.h
 *
 *
 * Description: Contains the datatypes, structures and enums that are used the API
 *
 * Copyright (C) 2018 CrossControl AB
 * All rights reserved.
 * Contact: CrossControl AB (info@crosscontrol.com)
 *
**************************************************************************/
#ifndef CAMTYPES_H
#define CAMTYPES_H

#include <string.h>
#include <stdint.h>
#include <sstream>
#include <vector>
#include <string>
#include <sstream>

namespace CrossControl {

enum ServiceID : uint16_t
{
    SOME_IP = 0x433f,                       
    SOME_IP_SD = 0xffff                     
};

enum MethodID : uint16_t
{
    GET_DATA_SHEET = 0x0001,                
    GET_CAM_STATUS = 0x0002,                
    SET_CAM_EXCLUSIVE = 0x0011,             
    ERASE_CAM_EXCLUSIVE = 0x0019,           
    SET_REGION_OF_INTEREST = 0x0101,        
    GET_REGION_OF_INTEREST = 0x0103,        
    GET_REGIONS_OF_INTEREST = 0x0104,       
    ERASE_REGION_OF_INTEREST = 0x0109,      
    GET_VIDEO_FORMAT = 0x0113,              
    SUBSCRIBE_ROI_VIDEO = 0x0131,           
    UNSUBSCRIBE_ROI_VIDEO = 0x0132,         
    SET_CAM_CONTROL = 0x0201,               
    GET_CAM_CONTROL = 0x0203,               
    SET_CAM_REGISTER = 0x0301,              
    SET_CAM_REGISTERS = 0x0302,             
    GET_CAM_REGISTER = 0x0303,              
    GET_CAM_REGISTERS = 0x304,              
    SERVICE_DISCOVERY = 0x8100              
};

enum IPCamStatus
{
    E_OK = 0x00,                            
    E_NOT_OK = 0x01,                        
    E_UNKNOWN_SERVICE = 0x02,               
    E_UNKNOWN_METHOD = 0x03,                
    E_NOT_READY = 0x04,                     
    E_NOT_REACHABLE = 0x05,                 
    E_TIMEOUT = 0x06,                       
    E_WRONG_PROTOCOL_VERSION = 0x07,        
    E_WRONG_INTERFACE_VERSION = 0x08,       
    E_MALFORMED_MESSAGE = 0x09,             
    E_LOCKED_BY_FOREIGN_INSTANCE = 0x20,    
    E_LOCK_EXPIRED = 0x21,                  
    E_NOT_LOCKED = 0x22,                    
    E_INVALID_PS_ENTRY = 0x24,              
    E_INVALID_PS_OPERATION = 0x25,          
    E_INVALID_PS_DATA = 0x26,               
    E_NO_MORE_SPACE = 0x27,                 
    E_INVALID_ROI_INDEX = 0x30,             
    E_INVALID_ROI_NUMBER = 0x31,            
    E_INVALID_VIDEO_FORMAT = 0x32,          
    E_INVALID_HISTOGRAM_FORMAT = 0x33,      
    E_INVALID_CONTROL_INDEX = 0x35,         
    E_INVALID_CONTROL_MODE = 0x36,          
    E_INVALID_CONTROL_VALUE = 0x37,         
    E_INVALID_REGISTER_ADDRESS = 0x38,      
    E_INVALID_REGISTER_VALUE = 0x39,        
    E_INVALID_REGISTER_OPERATION = 0x3a,    
    E_SOCKET_ERR = 0x40,                    
    E_SOCKET_ERR_SEND = 0x41,               
    E_NO_RESPONSE = 0x44                    
};

enum MessageType : uint8_t
{
    REQUEST = 0x00,                         
    REQUEST_NO_RETURN = 0x01,               
    NOTIFICATION = 0x02,                    
    REQUEST_ACK = 0x40,                     
    REQUEST_NO_RETURN_ACK = 0x41,           
    NOTIFICATION_ACK = 0x42,                
    RESPONSE = 0x80,                        
    ERROR = 0x81,                           
    RESPONSE_ACK = 0xc0,                    
    ERROR_ACK = 0xc1                        
};

enum EntryType : uint8_t
{
    FIND_SERVICE = 0,                       
    OFFER_SERVICE = 1,                      
    REQUEST_SERVICE = 2,                    
    FIND_EVENTGROUP = 4,                    
    PUBLISH = 5,                            
    SUBSCRIBE_EVENTGROUP = 6,               
    SUBSCRIBE_EVENTGROUP_ACK = 7            
};

enum OptionType : uint8_t
{
    CONFIGURATION = 1,                      
    IPV4ENDPOINT = 4,                       
    IPV6ENDPOINT = 6,                       
    IPV4MULTICAST = 20,                     
    IPV6MULTICAST = 22                      
};

enum L4Protocol : uint8_t
{
    TCP = 6,                                
    UDP = 17                                
};

enum ColorSpace : uint8_t
{
    GRAYSCALE8 = 0,                         
    YUV411 = 1,                             
    YUV422 = 2,                             
    YUV444 = 3,                             
    RGB8 = 4,                               
    GRAYSCALE16 = 5,                        
    RGB16 = 6,                              
    SIGNED_GRAYSCALE16 = 7,                 
    SIGNED_RBG16 = 8,                       
    RAW8 = 9,                               
    RAW16 = 10,                             
    GRAYSCALE12 = 11,                       
    RAW12 = 12                              
};

enum ControlSupportMode : uint8_t
{
    STAT_NOT_SUPORTED = 0,                  
    STAT_RW_NA_NO = 1,                      
    STAT_RO_NA_NO = 3,                      
    STAT_RO_A_NO = 5,                       
    STAT_RW_A_NO = 7,                       
    STAT_RO_NA_O = 9,                       
    STAT_RW_NA_O = 11,                      
    STAT_RO_A_O = 13,                       
    STAT_RW_A_O = 15                        
};

enum ControlMode : uint8_t
{
    MODE_MANUAL = 2,                        
    MODE_MANUAL_MODIFIED = 3,               
    MODE_AUTO = 4,                          
    MODE_ONE_PUSH = 5                       
};

enum VideoCompression : uint8_t
{
    UNCOMPRESSED = 0,                       
    JPEG = 1,                               
    H264 = 2                                
};

struct sImagerRegister
{
    uint16_t regAddress;                    
    uint16_t regValue;                      
} typedef ImagerRegister;

struct sTimeStamp
{
    uint16_t asExtension802;                
    uint32_t seconds;                       
    uint32_t nanoSeconds;                   
} typedef TimeStamp;

struct sVideoContent
{
    uint8_t roiIndex;                       
    uint16_t nBins;                         
    uint16_t firstBin;                      
    TimeStamp timeStamp;                    
    uint32_t numberOfROIValues;             
    uint8_t roiContent[];                   
} typedef VideoContent;

struct sCamStatus
{
    uint32_t lockedBy;                      
    uint8_t powerStatus;                    
    uint16_t temperature;                   
} typedef CamStatus;

struct sControlMode
{
    ControlSupportMode supportedModes;      
    ControlMode controlMode;                
} typedef ControlStatus;

struct sSignedCtl
{
    ControlStatus controlStatus;            
    int16_t controlValue;                   
} typedef SignedControl;

struct sUnsignedCtl
{
    ControlStatus controlStatus;            
    uint16_t controlValue;                  
} typedef UnsignedControl;

struct sCombinedCtl
{
    ControlStatus controlStatus;            
    uint8_t controlValueA;                  
    uint8_t controlValueB;                  
} typedef CombinedControl;

struct sPixelPosition
{
    uint16_t x;                             
    uint16_t y;                             
} typedef PixelPosition;

struct sRectangle
{
    PixelPosition p1;                       
    PixelPosition p2;                       
} typedef Rectangle;

struct sPixelMap
{
    uint32_t numberOfEntries;               
    PixelPosition pixelPositions[];         
} typedef PixelMap;

struct sImageDimension
{
    uint16_t width;                         
    uint16_t height;                        
} typedef ImageDimension;

struct sImagerCharacteristic
{
    ImageDimension totalSize;               
    ImageDimension usableSize;              
    uint16_t pixelSizeX;                    
    uint16_t pixelSizeY;                    
    uint8_t shutterType;                    
    char sensorIdentifier[32];              
} typedef ImagerCharacteristic;

struct sIntrinsicCamParam
{
    uint8_t distortionModel;                
    double principalPointX;                 
    double principalPointY;                 
    double scaleX;                          
    double scaleY;                          
    double k1;                              
    double k2;                              
    double k3;                              
    double k4;                              
    double k5;                              
    double k6;                              
    double p1;                              
    double p2;                              
} typedef IntrinsicCamParam;

struct sExtrinsicCamParam
{
    double rotationMat[9];                  
    double tVec[3];                         
} typedef ExtrinsicCamParam;

struct sDatasheet
{
    char deviceIdenttification[256];        
    uint32_t standardVersion;               
    ImagerCharacteristic imagerCharacteristic;  
    IntrinsicCamParam intrinsicCamParam;    
    ExtrinsicCamParam extrinsicCamParam;    
    PixelMap defectPixelMap;                
    uint32_t numOfTemperatures;             
    uint32_t numRegionsOfInterest;          
    uint32_t maxLengthOfPersistentEntry;    
} typedef Datasheet;

struct sHistogramFormat
{
    uint8_t histogramEnabled;               
    uint8_t histogramUpdateCycle;           
    uint8_t usedVideoComponent;             
    uint8_t dataType;                       
    uint8_t binSize;                        
    uint16_t numberOfBins;                  
} typedef HistogramFormat;

struct sVideoFormat
{
    uint8_t videoFormatEnabled;             
    uint8_t transmissionMethod;             
    uint16_t transmissionCycle;             
    ImageDimension widthAndHeight;          
    uint32_t frameRate;                     
    uint8_t interlaced;                     
    ColorSpace colorSpace;                  
    uint32_t maxBitrate;                    
    uint8_t videoCompression;               
} typedef VideoFormat;

struct sRegionOfInterest
{
    Rectangle roiSizeAndPosition;           
    VideoFormat videoFormat;                
    HistogramFormat histogramFormat;        
} typedef RegionOfInterest;

struct sSomeIPHeader
{
    uint16_t serviceID;                     
    uint16_t methodID;                      
    uint32_t messageLength;                 
    uint16_t clientID;                      
    uint16_t sessionID;                     
    uint8_t protocolVersion;                
    uint8_t interfaceVersion;               
    uint8_t messageType;                    
    uint8_t returnCode;                     
} typedef SomeIPHeader;

struct sSDEntryA
{
    EntryType type;                         
    uint8_t indexOptions1;                  
    uint8_t indexOptions2;                  
    uint8_t numOptions1;                    
    uint8_t numOptions2;                    
    uint16_t serviceID;                     
    uint16_t instanceID;                    
    uint8_t majorVersion;                   
    uint32_t timeToLive;                    
    uint32_t minorVersion;                  
} typedef SDEntryA;

struct sIPv4Option
{
    std::string ipAddress;                  
    L4Protocol protocol;                    
    uint16_t portNumber;                    
} typedef IPv4Option;


} //Namespace CrossControl
#endif CAMTYPES_H // CAMTYPES_H