/*************************************************************************************** * * IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. * * By downloading, copying, installing or using the software you agree to this license. * If you do not agree to this license, do not download, install, * copy or use the software. * * Copyright (C) 2014-2024, Happytimesoft Corporation, all rights reserved. * * Redistribution and use in binary forms, with or without modification, are permitted. * * 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 ONVIF_COMM_H #define ONVIF_COMM_H /***************************************************************************************/ #define ONVIF_TOKEN_LEN 100 #define ONVIF_NAME_LEN 100 #define ONVIF_URI_LEN 300 #define ONVIF_SCOPE_LEN 128 #define MAX_PTZ_PRESETS 100 #define MAX_DNS_SERVER 2 #define MAX_SEARCHDOMAIN 4 #define MAX_NTP_SERVER 2 #define MAX_SERVER_PORT 4 #define MAX_GATEWAY 2 #define MAX_RES_NUMS 32 #define MAX_SCOPE_NUMS 100 #define MAX_USERS 10 #define MAX_IP_ADDRS 4 /* Floating point precision */ #define FPP 0.01 #define ACCESS_CTRL_MAX_LIMIT 10 #define DOOR_CTRL_MAX_LIMIT 10 #define CREDENTIAL_MAX_LIMIT 10 #define ACCESSRULES_MAX_LIMIT 10 #define SCHEDULE_MAX_LIMIT 10 /***************************************************************************************/ typedef enum { ONVIF_OK = 0, ONVIF_ERR_ConnFailure = -1, // Connection failed ONVIF_ERR_MallocFailure = -2, // Failed to allocate memory ONVIF_ERR_NotSupportHttps = -3, // The device requires an HTTPS connection, but the onvif client library does not support it (the HTTPS compilation macro is not enabled) ONVIF_ERR_RecvTimeout = -4, // Message receiving timeout ONVIF_ERR_InvalidContentType = -5, // Device response message content is invalid ONVIF_ERR_NullContent = -6, // Device response message has no content ONVIF_ERR_ParseFailed = -7, // Parsing the message failed ONVIF_ERR_HandleFailed = -8, // Message handling failed ONVIF_ERR_HttpResponseError = -9, // The device responded with an error message } ONVIF_RET; typedef enum { AuthMethod_HttpDigest = 0, // Http digest auth method AuthMethod_UsernameToken = 1 // Username Token auth method } onvif_AuthMethod; /***************************************************************************************/ typedef enum { CapabilityCategory_Invalid = -1, CapabilityCategory_All = 0, CapabilityCategory_Analytics = 1, CapabilityCategory_Device = 2, CapabilityCategory_Events = 3, CapabilityCategory_Imaging = 4, CapabilityCategory_Media = 5, CapabilityCategory_PTZ = 6, CapabilityCategory_Recording = 7, CapabilityCategory_Search = 8, CapabilityCategory_Replay = 9, CapabilityCategory_AccessControl = 10, CapabilityCategory_DoorControl = 11, CapabilityCategory_DeviceIO = 12, CapabilityCategory_Media2 = 13, CapabilityCategory_Thermal = 14, CapabilityCategory_Credential = 15, CapabilityCategory_AccessRules = 16, CapabilityCategory_Schedule = 17, CapabilityCategory_Receiver = 18, CapabilityCategory_Provisioning = 19, } onvif_CapabilityCategory; typedef enum { FactoryDefaultType_Hard = 0, // Indicates that a hard factory default is requested FactoryDefaultType_Soft = 1 // Indicates that a soft factory default is requested } onvif_FactoryDefaultType; typedef enum { SystemLogType_System = 0, // Indicates that a system log is requested SystemLogType_Access = 1 // Indicates that a access log is requested } onvif_SystemLogType; typedef enum { VideoEncoding_Unknown = -1, VideoEncoding_JPEG = 0, VideoEncoding_MPEG4 = 1, VideoEncoding_H264 = 2 } onvif_VideoEncoding; typedef enum { AudioEncoding_Unknown = -1, AudioEncoding_G711 = 0, AudioEncoding_G726 = 1, AudioEncoding_AAC = 2 } onvif_AudioEncoding; typedef enum H264Profile { H264Profile_Baseline = 0, H264Profile_Main = 1, H264Profile_Extended = 2, H264Profile_High = 3 } onvif_H264Profile; typedef enum { Mpeg4Profile_SP = 0, Mpeg4Profile_ASP = 1 } onvif_Mpeg4Profile; typedef enum { UserLevel_Administrator = 0, UserLevel_Operator = 1, UserLevel_User = 2, UserLevel_Anonymous = 3, UserLevel_Extended = 4 } onvif_UserLevel; typedef enum { IPAddressFilterType_Allow = 0, IPAddressFilterType_Deny = 1 } onvif_IPAddressFilterType; typedef enum MoveStatus { MoveStatus_IDLE = 0, MoveStatus_MOVING = 1, MoveStatus_UNKNOWN = 2 } onvif_MoveStatus; // OSD type typedef enum { OSDType_Text = 0, OSDType_Image = 1, OSDType_Extended =2 } onvif_OSDType; // OSD position type typedef enum { OSDPosType_UpperLeft = 0, OSDPosType_UpperRight = 1, OSDPosType_LowerLeft = 2, OSDPosType_LowerRight = 3, OSDPosType_Custom = 4 } onvif_OSDPosType; typedef enum { OSDTextType_Plain, // The Plain type means the OSD is shown as a text string which defined in the "PlainText" item OSDTextType_Date, // The Date type means the OSD is shown as a date, format of which should be present in the "DateFormat" item OSDTextType_Time, // The Time type means the OSD is shown as a time, format of which should be present in the "TimeFormat" item OSDTextType_DateAndTime, // The DateAndTime type means the OSD is shown as date and time, format of which should be present in the "DateFormat" and the "TimeFormat" item } onvif_OSDTextType; // BacklightCompensation mode typedef enum { BacklightCompensationMode_OFF = 0, // Backlight compensation is disabled BacklightCompensationMode_ON = 1 // Backlight compensation is enabled } onvif_BacklightCompensationMode; // Exposure mode typedef enum { ExposureMode_AUTO = 0, ExposureMode_MANUAL = 1 } onvif_ExposureMode; // Exposure Priority typedef enum { ExposurePriority_LowNoise = 0, ExposurePriority_FrameRate = 1 } onvif_ExposurePriority; // AutoFocus Mode typedef enum { AutoFocusMode_AUTO = 0, AutoFocusMode_MANUAL = 1 } onvif_AutoFocusMode; typedef enum { WideDynamicMode_OFF = 0, WideDynamicMode_ON = 1 } onvif_WideDynamicMode; typedef enum { IrCutFilterMode_ON = 0, IrCutFilterMode_OFF = 1, IrCutFilterMode_AUTO = 2 } onvif_IrCutFilterMode; typedef enum WhiteBalanceMode { WhiteBalanceMode_AUTO = 0, WhiteBalanceMode_MANUAL = 1 } onvif_WhiteBalanceMode; typedef enum onvif_EFlipMode { EFlipMode_OFF = 0, EFlipMode_ON = 1, EFlipMode_Extended = 2 } onvif_EFlipMode; typedef enum { ReverseMode_OFF = 0, ReverseMode_ON = 1, ReverseMode_AUTO = 2, ReverseMode_Extended = 3 } onvif_ReverseMode; typedef enum { DiscoveryMode_Discoverable = 0, DiscoveryMode_NonDiscoverable = 1 } onvif_DiscoveryMode; typedef enum { SetDateTimeType_Manual = 0, // Indicates that the date and time are set manually SetDateTimeType_NTP = 1 // Indicates that the date and time are set through NTP } onvif_SetDateTimeType; typedef enum { StreamType_Invalid = -1, StreamType_RTP_Unicast = 0, StreamType_RTP_Multicast = 1 } onvif_StreamType; typedef enum { TransportProtocol_Invalid = -1, TransportProtocol_UDP = 0, TransportProtocol_TCP = 1, TransportProtocol_RTSP = 2, TransportProtocol_HTTP = 3 } onvif_TransportProtocol; typedef enum { TrackType_Invalid = -1, TrackType_Video = 0, TrackType_Audio = 1, TrackType_Metadata = 2, TrackType_Extended = 3 } onvif_TrackType; typedef enum { DynamicDNSType_NoUpdate = 0, DynamicDNSType_ClientUpdates = 1, DynamicDNSType_ServerUpdates = 2 } onvif_DynamicDNSType; typedef enum { PropertyOperation_Invalid = -1, PropertyOperation_Initialized = 0, PropertyOperation_Deleted = 1, PropertyOperation_Changed = 2 } onvif_PropertyOperation; typedef enum { RecordingStatus_Initiated = 0, RecordingStatus_Recording = 1, RecordingStatus_Stopped = 2, RecordingStatus_Removing = 3, RecordingStatus_Removed = 4, RecordingStatus_Unknown = 5 } onvif_RecordingStatus; typedef enum { SearchState_Queued = 0, // The search is queued and not yet started. SearchState_Searching = 1, // The search is underway and not yet completed SearchState_Completed = 2, // The search has been completed and no new results will be found SearchState_Unknown = 3 // The state of the search is unknown. (This is not a valid response from GetSearchState.) } onvif_SearchState; typedef enum { RotateMode_OFF = 0, // Enable the Rotate feature. Degree of rotation is specified Degree parameter RotateMode_ON = 1, // Disable the Rotate feature RotateMode_AUTO = 2 // Rotate feature is automatically activated by the device } onvif_RotateMode; typedef enum { ScopeDefinition_Fixed = 0, ScopeDefinition_Configurable = 1 } onvif_ScopeDefinition; // The physical state of a Door typedef enum { DoorPhysicalState_Unknown = 0, // Value is currently unknown (possibly due to initialization or monitors not giving a conclusive result) DoorPhysicalState_Open = 1, // Door is open DoorPhysicalState_Closed = 2, // Door is closed DoorPhysicalState_Fault = 3 // Door monitor fault is detected } onvif_DoorPhysicalState; // The physical state of a Lock (including Double Lock) typedef enum { LockPhysicalState_Unknown = 0, // Value is currently not known LockPhysicalState_Locked = 1, // Lock is activated LockPhysicalState_Unlocked = 2, // Lock is not activated LockPhysicalState_Fault = 3 // Lock fault is detected } onvif_LockPhysicalState; // Describes the state of a Door with regard to alarms typedef enum { DoorAlarmState_Normal = 0, // No alarm DoorAlarmState_DoorForcedOpen = 1, // Door is forced open DoorAlarmState_DoorOpenTooLong = 2 // Door is held open too long } onvif_DoorAlarmState; // Describes the state of a Tamper detector typedef enum { DoorTamperState_Unknown = 0, // Value is currently not known DoorTamperState_NotInTamper = 1, // No tampering is detected DoorTamperState_TamperDetected = 2 // Tampering is detected } onvif_DoorTamperState; // Describes the state of a Door fault typedef enum { DoorFaultState_Unknown = 0, // Fault state is unknown DoorFaultState_NotInFault = 1, // No fault is detected DoorFaultState_FaultDetected = 2 // Fault is detected } onvif_DoorFaultState; // DoorMode parameters describe current Door mode from a logical perspective typedef enum { DoorMode_Unknown = 0, // The Door is in an Unknown state DoorMode_Locked = 1, // The Door is in a Locked state. In this mode the device shall provide momentary access using the AccessDoor method if supported by the Door instance DoorMode_Unlocked = 2, // The Door is in an Unlocked (Permanent Access) state. Alarms related to door timing operations such as open too long or forced are masked in this mode DoorMode_Accessed = 3, // The Door is in an Accessed state (momentary/temporary access). Alarms related to timing operations such as "door forced" are masked in this mode DoorMode_Blocked = 4, // The Door is in a Blocked state (Door is locked, and AccessDoor requests are ignored, i.e., it is not possible for door to go to Accessed state) DoorMode_LockedDown = 5, // The Door is in a LockedDown state (Door is locked) until released using the LockDownReleaseDoor command. AccessDoor, LockDoor, UnlockDoor, BlockDoor and // LockOpenDoor requests are ignored, i.e., it is not possible for door to go to Accessed, Locked, Unlocked, Blocked or LockedOpen state DoorMode_LockedOpen = 6, // The Door is in a LockedOpen state (Door is unlocked) until released using the LockOpenReleaseDoor command. AccessDoor, LockDoor, UnlockDoor, BlockDoor and // LockDownDoor requests are ignored, i.e., it is not possible for door to go to Accessed, Locked, Unlocked, Blocked or LockedDown state DoorMode_DoubleLocked = 7 // The Door is in a Double Locked state - for doors with multiple locks. If the door does not have any DoubleLock, this shall be treated as a normal Locked mode. // When changing to an Unlocked mode from the DoubleLocked mode, the door may first go to Locked state before unlocking } onvif_DoorMode; typedef enum { RelayMode_Monostable = 0, // After setting the state, the relay returns to its idle state after the specified time RelayMode_Bistable = 1, // After setting the state, the relay remains in this state } onvif_RelayMode; typedef enum { RelayIdleState_closed = 0, // means that the relay is closed when the relay state is set to 'inactive' through the trigger command and open when the state is set to 'active' through the same command RelayIdleState_open = 1, // means that the relay is open when the relay state is set to 'inactive' through the trigger command and closed when the state is set to 'active' through the same command } onvif_RelayIdleState; typedef enum { RelayLogicalState_active = 0, // RelayLogicalState_inactive = 1, // } onvif_RelayLogicalState; typedef enum { DigitalIdleState_closed = 0, DigitalIdleState_open = 1, } onvif_DigitalIdleState; typedef enum { ParityBit_None = 0, ParityBit_Even = 1, ParityBit_Odd = 2, ParityBit_Mark = 3, ParityBit_Space = 4, ParityBit_Extended = 5 } onvif_ParityBit; typedef enum { SerialPortType_RS232 = 0, SerialPortType_RS422HalfDuplex = 1, SerialPortType_RS422FullDuplex = 2, SerialPortType_RS485HalfDuplex = 3, SerialPortType_RS485FullDuplex = 4, SerialPortType_Generic = 5 } onvif_SerialPortType; typedef enum { PTZPresetTourOperation_Start = 0, PTZPresetTourOperation_Stop = 1, PTZPresetTourOperation_Pause = 2, PTZPresetTourOperation_Extended = 3 } onvif_PTZPresetTourOperation; typedef enum { PTZPresetTourState_Idle = 0, PTZPresetTourState_Touring = 1, PTZPresetTourState_Paused = 2, PTZPresetTourState_Extended = 3 } onvif_PTZPresetTourState; typedef enum { PTZPresetTourDirection_Forward = 0, PTZPresetTourDirection_Backward = 1, PTZPresetTourDirection_Extended = 2 } onvif_PTZPresetTourDirection; typedef enum { Dot11AuthAndMangementSuite_None = 0, Dot11AuthAndMangementSuite_Dot1X = 1, Dot11AuthAndMangementSuite_PSK = 2, Dot11AuthAndMangementSuite_Extended = 3 } onvif_Dot11AuthAndMangementSuite; typedef enum { Dot11Cipher_CCMP = 0, Dot11Cipher_TKIP = 1, Dot11Cipher_Any = 2, Dot11Cipher_Extended = 3 } onvif_Dot11Cipher; typedef enum { Dot11SignalStrength_None = 0, Dot11SignalStrength_VeryBad = 1, Dot11SignalStrength_Bad = 2, Dot11SignalStrength_Good = 3, Dot11SignalStrength_VeryGood = 4, Dot11SignalStrength_Extended = 5 } onvif_Dot11SignalStrength; typedef enum { Dot11StationMode_Ad_hoc = 0, Dot11StationMode_Infrastructure = 1, Dot11StationMode_Extended = 2 } onvif_Dot11StationMode; typedef enum { Dot11SecurityMode_None = 0, Dot11SecurityMode_WEP = 1, Dot11SecurityMode_PSK = 2, Dot11SecurityMode_Dot1X = 3, Dot11SecurityMode_Extended = 4 } onvif_Dot11SecurityMode; typedef enum { ReceiverMode_AutoConnect = 0, // The receiver connects on demand, as required by consumers of the media streams ReceiverMode_AlwaysConnect = 1, // The receiver attempts to maintain a persistent connection to the configured endpoint ReceiverMode_NeverConnect = 2, // The receiver does not attempt to connect ReceiverMode_Unknown = 3 // This case should never happen } onvif_ReceiverMode; typedef enum { ReceiverState_NotConnected = 0, // The receiver is not connected ReceiverState_Connecting = 1, // The receiver is attempting to connect ReceiverState_Connected = 2, // The receiver is connected ReceiverState_Unknown = 3 // This case should never happen } onvif_ReceiverState; typedef enum { PanDirection_Left = 0, // Move left in relation to the video source image PanDirection_Right = 1 // Move right in relation to the video source image } onvif_PanDirection; typedef enum { TiltDirection_Up = 0, // Move up in relation to the video source image TiltDirection_Down = 1 // Move down in relation to the video source image } onvif_TiltDirection; typedef enum { ZoomDirection_Wide = 0, // Move video source lens toward a wider field of view ZoomDirection_Telephoto = 1 // Move video source lens toward a narrower field of view } onvif_ZoomDirection; typedef enum { RollDirection_Clockwise = 0, // Move clockwise in relation to the video source image RollDirection_Counterclockwise = 1, // Move counterclockwise in relation to the video source image RollDirection_Auto = 2 // Automatically level the device in relation to the video source image } onvif_RollDirection; typedef enum { FocusDirection_Near = 0, // Move to focus on close objects FocusDirection_Far = 1, // Move to focus on distant objects FocusDirection_Auto = 2 // Automatically focus for the sharpest video source image } onvif_FocusDirection; /***************************************************************************************/ typedef struct { char Code[128]; char Subcode[128]; char Reason[256]; } onvif_Fault; typedef struct { int https; // https connection int port; // onvif port char host[128]; // ip of xaddrs char url[128]; // /onvif/device_service } onvif_XAddr; typedef struct { int Major; // required int Minor; // required } onvif_Version; typedef struct { float Min; // required float Max; // required } onvif_FloatRange; typedef struct { uint32 spaceFlag : 1; // Indicates whether the field space is valid uint32 reserved : 31; float x; // required float y; // required char space[256]; // optional } onvif_Vector; typedef struct { uint32 sizeItems; int Items[10]; // optional } onvif_IntList; typedef struct { int sizeItems; float Items[10]; // optional } onvif_FloatList; typedef struct { int sizeItems; onvif_ParityBit Items[10]; // optional } onvif_ParityBitList; /* device capabilities */ typedef struct { // network capabilities uint32 IPFilter : 1; // Indicates support for IP filtering uint32 ZeroConfiguration : 1; // Indicates support for zeroconf uint32 IPVersion6 : 1; // Indicates support for IPv6 uint32 DynDNS : 1; // Indicates support for dynamic DNS configuration uint32 Dot11Configuration : 1; // Indicates support for IEEE 802.11 configuration uint32 HostnameFromDHCP : 1; // Indicates support for retrieval of hostname from DHCP uint32 DHCPv6 : 1; // Indicates support for Stateful IPv6 DHCP // system capabilities uint32 DiscoveryResolve : 1; // Indicates support for WS Discovery resolve requests uint32 DiscoveryBye : 1; // Indicates support for WS-Discovery Bye uint32 RemoteDiscovery : 1; // Indicates support for remote discovery uint32 SystemBackup : 1; // Indicates support for system backup through MTOM uint32 SystemLogging : 1; // Indicates support for retrieval of system logging through MTOM uint32 FirmwareUpgrade : 1; // Indicates support for firmware upgrade through MTOM uint32 HttpFirmwareUpgrade : 1; // Indicates support for system backup through MTOM uint32 HttpSystemBackup : 1; // Indicates support for system backup through HTTP uint32 HttpSystemLogging : 1; // Indicates support for retrieval of system logging through HTTP uint32 HttpSupportInformation : 1; // Indicates support for retrieving support information through HTTP uint32 StorageConfiguration: 1; // Indicates support for storage configuration interfaces uint32 DiscoveryNotSupported : 1; // Indicates no support for network discovery uint32 NetworkConfigNotSupported : 1; // Indicates no support for network configuration uint32 UserConfigNotSupported : 1; // Indicates no support for user configuration // scurity capabilities uint32 TLS10 : 1; // Indicates support for TLS 1.0 uint32 TLS11 : 1; // Indicates support for TLS 1.1 uint32 TLS12 : 1; // Indicates support for TLS 1.2 uint32 OnboardKeyGeneration: 1; // Indicates support for onboard key generation uint32 AccessPolicyConfig : 1; // Indicates support for access policy configuration uint32 DefaultAccessPolicy : 1; // Indicates support for the ONVIF default access policy uint32 Dot1X : 1; // Indicates support for IEEE 802.1X configuration uint32 RemoteUserHandling : 1; // Indicates support for remote user configuration. Used when accessing another device uint32 X509Token : 1; // Indicates support for WS-Security X.509 token uint32 SAMLToken : 1; // Indicates support for WS-Security SAML token uint32 KerberosToken : 1; // Indicates support for WS-Security Kerberos token uint32 UsernameToken : 1; // Indicates support for WS-Security Username token uint32 HttpDigest : 1; // Indicates support for WS over HTTP digest authenticated communication layer uint32 RELToken : 1; // Indicates support for WS-Security REL token uint32 JsonWebToken : 1; // Indicates support for JWT-based authentication with WS-Security Binary Security token uint32 Auxiliary : 1; // Auxiliary commaond uint32 Reserved : 27; // IO int InputConnectors; // optional, Number of input connectors int RelayOutputs; // optional, Number of relay outputs int Dot1XConfigurations; // Indicates the maximum number of Dot1X configurations supported by the device int NTP; // Maximum number of NTP servers supported by the devices SetNTP command int SupportedEAPMethods; // EAP Methods supported by the device. // The int values refer to the IANA EAP Registry int MaxUsers; // The maximum number of users that the device supports int MaxUserNameLength; // Maximum number of characters supported for the username by CreateUsers int MaxPasswordLength; // Maximum number of characters supported for the password by CreateUsers and SetUser char SecurityPolicies[100]; // Indicates which security policies are supported. // Options are: ModifyPassword (to be extended with: PasswordComplexity, PasswordHistory, AuthFailureWarning) char HashingAlgorithms[32]; // Supported hashing algorithms as part of HTTP and RTSP Digest authentication.Example: MD5,SHA-256 int MaxStorageConfigurations; // Indicates maximum number of storage configurations supported int GeoLocationEntries; // If present signals support for geo location. The value signals the supported number of entries char AutoGeo[256]; // List of supported automatic GeoLocation adjustment supported by the device. Valid items are defined by tds:AutoGeoMode // Location:Automatic adjustment of the device location // Heading:Automatic adjustment of the device orientation relative to the compass also called yaw // Leveling:Automatic adjustment of the deviation from the horizon also called pitch and roll char StorageTypesSupported[256]; // Enumerates the supported StorageTypes, see tds:StorageType: // NFS,CIFS,CDMI,FTP char Addons[256]; // List of supported Addons by the device // misc capabilities char AuxiliaryCommands[256]; // Lists of commands supported by SendAuxiliaryCommand uint32 sizeSupportedVersions; // number of Supported Versions onvif_Version SupportedVersions[10]; // Supported Versions onvif_Version Version; // required onvif_XAddr XAddr; } onvif_DevicesCapabilities; /* media capabilities */ typedef struct { uint32 SnapshotUri : 1; // Indicates if GetSnapshotUri is supported uint32 Rotation : 1; // Indicates whether or not Rotation feature is supported uint32 VideoSourceMode : 1; // Indicates the support for changing video source mode uint32 OSD : 1; // Indicates if OSD is supported uint32 TemporaryOSDText : 1; // Indicates if TemporaryOSDText is supported uint32 EXICompression : 1; // Indicates the support for the Efficient XML Interchange (EXI) binary XML format uint32 RTPMulticast : 1; // Indicates support for RTP multicast uint32 RTP_TCP : 1; // Indicates support for RTP over TCP uint32 RTP_RTSP_TCP : 1; // Indicates support for RTP/RTSP/TCP uint32 NonAggregateControl : 1; // Indicates support for non aggregate RTSP control uint32 NoRTSPStreaming : 1; // Indicates the device does not support live media streaming via RTSP uint32 support : 1; // Indication if the device supports media service uint32 reserved : 20; int MaximumNumberOfProfiles; // Maximum number of profiles supported onvif_Version Version; // required onvif_XAddr XAddr; } onvif_MediaCapabilities; /* PTZ capabilities */ typedef struct { uint32 EFlip : 1; // Indicates whether or not EFlip is supported uint32 Reverse : 1; // Indicates whether or not reversing of PT control direction is supported uint32 GetCompatibleConfigurations : 1; // Indicates support for the GetCompatibleConfigurations command uint32 MoveStatus : 1; // Indicates that the PTZVector includes MoveStatus information uint32 StatusPosition : 1; // Indicates that the PTZVector includes Position information uint32 support : 1; // Indication if the device supports ptz service uint32 reserved : 26; char MoveAndTrack[64]; // Indication of the methods of MoveAndTrack that are supported, acceptable values are defined in tt:MoveAndTrackMethod // PresetToken // GeoLocation // PTZVector // ObjectID onvif_Version Version; // required onvif_XAddr XAddr; } onvif_PTZCapabilities; /* event capabilities */ typedef struct { uint32 WSSubscriptionPolicySupport : 1; // Indicates that the WS Subscription policy is supported uint32 WSPullPointSupport : 1; // Indicates that the WS Pull Point is supported uint32 WSPausableSubscriptionManagerInterfaceSupport : 1; // Indicates that the WS Pausable Subscription Manager Interface is supported uint32 PersistentNotificationStorage : 1; // Indication if the device supports persistent notification storage uint32 MetadataOverMQTT : 1; // Indicates that metadata streaming over MQTT is supported uint32 support : 1; // Indication if the device supports events service uint32 reserved : 26; int MaxNotificationProducers; // Maximum number of supported notification producers as defined by WS-BaseNotification int MaxPullPoints; // Maximum supported number of notification pull points char EventBrokerProtocols[100]; // A space separated list of supported event broker protocols as defined by the tev:EventBrokerProtocol datatype // mqtt // mqtts // ws // wss int MaxEventBrokers; // Maxiumum number of event broker configurations that can be added to the device onvif_Version Version; // required onvif_XAddr XAddr; } onvif_EventCapabilities; /* image capabilities */ typedef struct { uint32 ImageStabilization : 1; // Indicates whether or not Image Stabilization feature is supported uint32 Presets : 1; // Indicates whether or not Presets feature is supported uint32 AdaptablePreset : 1; // Indicates whether or not imaging preset settings can be updated uint32 support : 1; // Indication if the device supports image service uint32 reserved : 28; onvif_Version Version; // required onvif_XAddr XAddr; } onvif_ImagingCapabilities; /* analytics capabilities*/ typedef struct { uint32 RuleSupport : 1; // Indication that the device supports the rules interface and the rules syntax uint32 AnalyticsModuleSupport : 1; // Indication that the device supports the scene analytics module interface uint32 CellBasedSceneDescriptionSupported : 1; // Indication that the device produces the cell based scene description uint32 RuleOptionsSupported: 1; // Indication that the device supports the GetRuleOptions operation on the rules interface uint32 AnalyticsModuleOptionsSupported : 1; // Indication that the device supports the GetAnalyticsModuleOptions operation on the analytics interface uint32 SupportedMetadata : 1; // Indication that the device supports the GetSupportedMetadata operation uint32 support : 1; // Indication if the device supports Analytics service uint32 reserved : 25; char ImageSendingType[100]; // Indication what kinds of method that the device support for sending image // Embedded, LocalStorage, RemoteStorage onvif_Version Version; // required onvif_XAddr XAddr; } onvif_AnalyticsCapabilities; /* recording capabilities */ typedef struct { uint32 ReceiverSource : 1; uint32 MediaProfileSource : 1; uint32 DynamicRecordings : 1; // Indication if the device supports dynamic creation and deletion of recordings uint32 DynamicTracks : 1; // Indication if the device supports dynamic creation and deletion of tracks uint32 Options : 1; // Indication if the device supports the GetRecordingOptions command uint32 MetadataRecording : 1; // Indication if the device supports recording metadata uint32 EventRecording : 1; // Indication that the device supports event triggered recording uint32 JPEG : 1; // Indication if supports JPEG encoding uint32 MPEG4 : 1; // Indication if supports MPEG4 encoding uint32 H264 : 1; // Indication if supports H264 encoding uint32 H265 : 1; // Indication if supports H265 encoding uint32 G711 : 1; // Indication if supports G711 encoding uint32 G726 : 1; // Indication if supports G726 encoding uint32 AAC : 1; // Indication if supports AAC encoding uint32 SupportedTargetFormatsFlag : 1; // Indicates whether the field SupportedTargetFormats is valid uint32 EncryptionEntryLimitFlag : 1; // Indicates whether the field EncryptionEntryLimit is valid uint32 SupportedEncryptionModesFlag : 1; // Indicates whether the field SupportedEncryptionModes is valid uint32 support : 1; // Indication if the device supports recording service uint32 reserved : 14; uint32 MaxStringLength; float MaxRate; // optional, Maximum supported bit rate for all tracks of a recording in kBit/s float MaxTotalRate; // optional, Maximum supported bit rate for all recordings in kBit/s. int MaxRecordings; // optional, Maximum number of recordings supported. int MaxRecordingJobs; // optional, Maximum total number of supported recording jobs by the device char SupportedExportFileFormats[100]; // optional, Indication that the device supports ExportRecordedData command for the listed export file formats. // The list shall return at least one export file format value. The value of 'ONVIF' refers to // ONVIF Export File Format specification int BeforeEventLimit; // optional, If present a device shall support configuring before event durations up to the given value int AfterEventLimit; // optional, If present a device shall support configuring after event durations up to the given value char SupportedTargetFormats[32]; // optional, List of formats supported by the device for recording to an external target. See tt:TargetFormat for a list of definitions // MP4 - MP4 files with all tracks in a single file // CMAF - CMAF compliant MP4 files with 1 track per file int EncryptionEntryLimit; // optional, Number of encryption entries supported per recording. // By specifying multiple encryption entries per recording, // different tracks can be encrypted with different configurations char SupportedEncryptionModes[32]; // optional, Indicates supported encryption modes. See tt:EncryptionMode for a list of definitions. // CENC - AES-CTR mode full sample and video NAL Subsample encryption, defined in ISO/IEC 23001-7 // CBCS - AES-CBC mode partial video NAL pattern encryption, defined in ISO/IEC 23001-7 onvif_Version Version; // required onvif_XAddr XAddr; } onvif_RecordingCapabilities; /* search capabilities */ typedef struct { uint32 MetadataSearch : 1; uint32 GeneralStartEvents : 1; // Indicates support for general virtual property events in the FindEvents method uint32 support : 1; // Indication if the device supports search service uint32 reserved : 29; onvif_Version Version; // required onvif_XAddr XAddr; } onvif_SearchCapabilities; /* replay capabilities */ typedef struct { uint32 ReversePlayback : 1; // Indicator that the Device supports reverse playback as defined in the ONVIF Streaming Specification uint32 RTP_RTSP_TCP : 1; // Indicates support for RTP/RTSP/TCP uint32 support : 1; // Indication if the device supports replay service uint32 reserved : 29; onvif_FloatRange SessionTimeoutRange; // The minimum and maximum valid values supported as session timeout in seconds char RTSPWebSocketUri[256]; // If playback streaming over WebSocket is supported, this shall return the RTSP WebSocket URI onvif_Version Version; // required onvif_XAddr XAddr; } onvif_ReplayCapabilities; /* accesscontrol capabilities */ typedef struct { uint32 support : 1; // Indication if the device supports accesscontrol service uint32 ClientSuppliedTokenSupported : 1; // Indicates that the client is allowed to supply the token when creating access points and areas // To enable the use of the commands SetAccessPoint and SetArea, the value must be set to true uint32 AccessPointManagementSupported : 1; // Indicates that the client can perform CRUD operations (create, read, update and delete) on access points uint32 AreaManagementSupported : 1; // Indicates that the client can perform CRUD operations (create, read, update and delete) on areas uint32 reserved : 28; int MaxLimit; // The maximum number of entries returned by a single GetList request. // The device shall never return more than this number of entities in a single response int MaxAccessPoints; // Indicates the maximum number of access points supported by the device int MaxAreas; // Indicates the maximum number of areas supported by the device onvif_Version Version; // required onvif_XAddr XAddr; } onvif_AccessControlCapabilities; /* doorcontrol capabilities */ typedef struct { uint32 support : 1; // Indication if the device supports doorcontrol service uint32 ClientSuppliedTokenSupported : 1; // Indicates that the client is allowed to supply the token when creating doors. // To enable the use of the command SetDoor, the value must be set to true uint32 DoorManagementSupported : 1; // Indicates that the client can perform CRUD operations (create, read, update and delete) on doors. // To enable the use of the commands GetDoors, GetDoorList, CreateDoor, ModifyDoor // and DeleteDoor, the value must be set to true uint32 reserved : 29; int MaxLimit; // The maximum number of entries returned by a single GetList or Get request. // The device shall never return more than this number of entities in a single response int MaxDoors; // Indicates the maximum number of doors supported by the device onvif_Version Version; // required onvif_XAddr XAddr; } onvif_DoorControlCapabilities; typedef struct { uint32 VideoSourcesFlag : 1; // Indicates whether the field VideoSources is valid uint32 VideoOutputsFlag : 1; // Indicates whether the field VideoSources is valid uint32 AudioSourcesFlag : 1; // Indicates whether the field VideoSources is valid uint32 AudioOutputsFlag : 1; // Indicates whether the field VideoSources is valid uint32 RelayOutputsFlag : 1; // Indicates whether the field VideoSources is valid uint32 SerialPortsFlag : 1; // Indicates whether the field VideoSources is valid uint32 DigitalInputsFlag : 1; // Indicates whether the field VideoSources is valid uint32 DigitalInputOptionsFlag : 1; // Indicates whether the field VideoSources is valid uint32 support : 1; // Indication if the device supports deviceIO service uint32 reserved : 23; int VideoSources; // optional, Number of video sources (defaults to none) int VideoOutputs; // optional, Number of video outputs (defaults to none) int AudioSources; // optional, Number of audio sources (defaults to none) int AudioOutputs; // optional, Number of audio outputs (defaults to none) int RelayOutputs; // optional, Number of relay outputs (defaults to none) int SerialPorts; // optional, Number of serial ports (defaults to none) int DigitalInputs; // optional, Number of digital inputs (defaults to none) BOOL DigitalInputOptions; // optional, Indicates support for DigitalInput configuration of the idle state (defaults to false) onvif_Version Version; // required onvif_XAddr XAddr; } onvif_DeviceIOCapabilities; typedef struct { uint32 MaximumNumberOfProfilesFlag : 1; // Indicates whether the field MaximumNumberOfProfiles is valid uint32 ConfigurationsSupportedFlag : 1; // Indicates whether the field ConfigurationsSupported is valid uint32 Reserved : 30; int MaximumNumberOfProfiles; // optional, Maximum number of profiles supported char ConfigurationsSupported[256]; // optional, Enumerates the configurations supported } onvif_ProfileCapabilities; typedef struct { uint32 RTSPStreaming : 1; // Indicates support for live media streaming via RTSP uint32 RTPMulticast : 1; // Indicates support for RTP multicast uint32 RTP_RTSP_TCP : 1; // Indicates support for RTP/RTSP/TCP uint32 NonAggregateControl : 1; // Indicates support for non aggregate RTSP control uint32 AutoStartMulticast : 1; // Indicates support for non-RTSP controlled multicast streaming uint32 SecureRTSPStreaming : 1; // Indicates support for live media streaming via RTSPS and SRTP uint32 Reserved : 26; char RTSPWebSocketUri[256]; // optional, If streaming over websocket supported, RTSP websocket URI is provided. // The scheme and IP part shall match the one used in the request (e.g. the GetServices request) } onvif_StreamingCapabilities; typedef struct { uint32 TKIP : 1; // required uint32 ScanAvailableNetworks : 1; // required uint32 MultipleConfiguration : 1; // required uint32 AdHocStationMode : 1; // required uint32 WEP : 1; // required uint32 Reserved : 27; } onvif_Dot11Capabilities; typedef struct { uint32 SnapshotUri : 1; // Indicates if GetSnapshotUri is supported uint32 Rotation : 1; // Indicates whether or not Rotation feature is supported uint32 VideoSourceMode : 1; // Indicates the support for changing video source mode uint32 OSD : 1; // Indicates if OSD is supported uint32 TemporaryOSDText : 1; // Indicates if TemporaryOSDText is supported uint32 Mask : 1; // Indicates if Masking is supported, Indicates support for mask configuration uint32 SourceMask : 1; // Indicates if SourceMask is supported // Indicates that privacy masks are only supported at the video source level // and not the video source configuration level. If this is true any addition, // deletion or change of a privacy mask done for one video source configuration // will automatically be applied by the device to a corresponding privacy mask // for all other video source configuration associated with the same video source. uint32 support : 1; // Indication if the device supports media service2 uint32 Reserved : 24; onvif_ProfileCapabilities ProfileCapabilities; // required, Media profile capabilities onvif_StreamingCapabilities StreamingCapabilities; // required, Streaming capabilities onvif_Version Version; // required onvif_XAddr XAddr; } onvif_MediaCapabilities2; typedef struct { uint32 Radiometry : 1; // Indicates whether or not radiometric thermal measurements are supported by the thermal devic uint32 support : 1; // Indication if the device supports thermal service uint32 Reserved : 30; onvif_Version Version; // required onvif_XAddr XAddr; } onvif_ThermalCapabilities; typedef struct { uint32 sizeSupportedExemptionType; // sequence of elements char SupportedExemptionType[10][32]; // optional, A list of exemptions that the device supports. Supported exemptions starting with the // prefix pt: are reserved to define PACS specific exemption types and these reserved // exemption types shall all share "pt:" syntax // pt:ExemptFromAuthentication Supports ExemptedFromAuthentication } onvif_CredentialCapabilitiesExtension; typedef struct { uint32 ExtensionFlag : 1; uint32 CredentialValiditySupported : 1; // required, Indicates that the device supports credential validity uint32 CredentialAccessProfileValiditySupported: 1;// required, Indicates that the device supports validity on the association // between a credential and an access profile uint32 ValiditySupportsTimeValue : 1; // required, Indicates that the device supports both date and time value for validity. // If set to false, then the time value is ignored uint32 ResetAntipassbackSupported : 1; // required, Indicates the device supports resetting of anti-passback violations // and notifying on anti-passback violations uint32 ClientSuppliedTokenSupported: 1; // Indicates that the client is allowed to supply the token when creating credentials. // To enable the use of the command SetCredential, the value must be set to true uint32 support : 1; // Indication if the device supports credential service uint32 Reserved : 25; uint32 sizeSupportedIdentifierType; // sequence of elements char SupportedIdentifierType[10][32]; // required, A list of identifier types that the device supports. Supported identifiers starting with // the prefix pt: are reserved to define PACS specific identifier types and these reserved // identifier types shall all share the "pt:" syntax // pt:Card Supports Card identifier type // pt:PIN Supports PIN identifier type // pt:Fingerprint Supports Fingerprint biometric identifier type // pt:Face Supports Face biometric identifier type // pt:Iris Supports Iris biometric identifier type // pt:Vein Supports Vein biometric identifier type // pt:Palm Supports Palm biometric identifier type // pt:Retina Supports Retina biometric identifier type uint32 MaxLimit; // required, The maximum number of entries returned by a single request. // The device shall never return more than this number of entities in a single response uint32 MaxCredentials; // required, The maximum number of credential supported by the device uint32 MaxAccessProfilesPerCredential; // required, The maximum number of access profiles for a credential char DefaultCredentialSuspensionDuration[20]; // The default time period that the credential will temporary be suspended (e.g. by using the wrong PIN a predetermined number of times). // The time period is defined as an [ISO 8601] duration string (e.g. PT5M). uint32 MaxWhitelistedItems; // optional, The maximum number of whitelisted credential identifiers supported by the device uint32 MaxBlacklistedItems; // optional, The maximum number of blacklisted credential identifiers supported by the device onvif_CredentialCapabilitiesExtension Extension; // optional onvif_Version Version; // required onvif_XAddr XAddr; } onvif_CredentialCapabilities; typedef struct { uint32 MultipleSchedulesPerAccessPointSupported: 1;// required, Indicates whether or not several access policies can refer to the same access point in // an access profile uint32 ClientSuppliedTokenSupported : 1; // Indicates that the client is allowed to supply the token when creating access profiles. // To enable the use of the command SetAccessProfile, the value must be set to true uint32 support : 1; // Indication if the device supports access rules service uint32 Reserved : 29; uint32 MaxLimit; // required, The maximum number of entries returned by a single GetList or Get // request. The device shall never return more than this number of entities in a single response uint32 MaxAccessProfiles; // required, Indicates the maximum number of access profiles supported by the device uint32 MaxAccessPoliciesPerAccessProfile; // required, Indicates the maximum number of access policies per access profile supported by the device onvif_Version Version; // required onvif_XAddr XAddr; } onvif_AccessRulesCapabilities; typedef struct { uint32 ExtendedRecurrenceSupported : 1; // required, If this capability is supported, then all iCalendar recurrence types shall be supported by the device uint32 SpecialDaysSupported : 1; // required, If this capability is supported, then the device shall support special days uint32 StateReportingSupported : 1; // required, If this capability is set to true, the device shall implement the GetScheduleState command, // and shall notify subscribing clients whenever schedules become active or inactive uint32 ClientSuppliedTokenSupported : 1; // Indicates that the client is allowed to supply the token when creating schedules and special day groups. // To enable the use of the commands SetSchedule and SetSpecialDayGroup, the value must be set to true uint32 support : 1; // Indication if the device supports schedule service uint32 Reserved : 27; uint32 MaxLimit; // required, uint32 MaxSchedules; // required, uint32 MaxTimePeriodsPerDay; // required, uint32 MaxSpecialDayGroups; // required, uint32 MaxDaysInSpecialDayGroup; // required, uint32 MaxSpecialDaysSchedules; // required, onvif_Version Version; // required onvif_XAddr XAddr; } onvif_ScheduleCapabilities; typedef struct { uint32 RTP_USCOREMulticast : 1; // required, Indicates that the device can receive RTP multicast streams uint32 RTP_USCORETCP : 1; // required, Indicates that the device can receive RTP/TCP streams uint32 RTP_USCORERTSP_USCORETCP : 1; // required, Indicates that the device can receive RTP/RTSP/TCP streams uint32 support : 1; // Indication if the device supports receiver service uint32 Reserved : 28; int SupportedReceivers; // required, The maximum number of receivers supported by the device int MaximumRTSPURILength; // required, The maximum allowed length for RTSP URIs (Minimum and default value is 128 octet) onvif_Version Version; // required onvif_XAddr XAddr; } onvif_ReceiverCapabilities; typedef struct { uint32 MaximumPanMovesFlag : 1; // Indicates whether the field MaximumPanMoves is valid uint32 MaximumTiltMovesFlag : 1; // Indicates whether the field MaximumTiltMoves is valid uint32 MaximumZoomMovesFlag : 1; // Indicates whether the field MaximumZoomMoves is valid uint32 MaximumRollMovesFlag : 1; // Indicates whether the field MaximumRollMoves is valid uint32 AutoLevelFlag : 1; // Indicates whether the field AutoLevel is valid uint32 MaximumFocusMovesFlag : 1; // Indicates whether the field MaximumFocusMoves is valid uint32 AutoFocusFlag : 1; // Indicates whether the field AutoFocus is valid uint32 Reserved : 25; char VideoSourceToken[ONVIF_TOKEN_LEN]; // required, Unique identifier of a video source int MaximumPanMoves; // optional, Lifetime limit of pan moves for this video source. Presence of this attribute indicates support of pan move int MaximumTiltMoves; // optional, Lifetime limit of tilt moves for this video source. Presence of this attribute indicates support of tilt move int MaximumZoomMoves; // optional, Lifetime limit of zoom moves for this video source. Presence of this attribute indicates support of zoom move int MaximumRollMoves; // optional, Lifetime limit of roll moves for this video source. Presence of this attribute indicates support of roll move BOOL AutoLevel; // optional, Indicates "auto" as a valid enum for Direction in RollMove int MaximumFocusMoves; // optional, Lifetime limit of focus moves for this video source. Presence of this attribute indicates support of focus move BOOL AutoFocus; // optional, Indicates "auto" as a valid enum for Direction in FocusMove } onvif_SourceCapabilities; typedef struct { uint32 support : 1; // Indication if the device supports provisioning service uint32 Reserved : 31; int DefaultTimeout; // external, Maximum time before stopping movement after a move operation uint32 sizeSource; // sequence of elements onvif_SourceCapabilities Source[4]; // optional, Capabilities per video source onvif_Version Version; // required onvif_XAddr XAddr; } onvif_ProvisioningCapabilities; typedef struct { onvif_DevicesCapabilities device; // The capabilities for the device service is returned in the Capabilities element onvif_EventCapabilities events; // The capabilities for the event service is returned in the Capabilities element onvif_Dot11Capabilities dot11; // The capabilities for the dot11 onvif_MediaCapabilities media; // The capabilities for the media service is returned in the Capabilities element onvif_MediaCapabilities2 media2; // The capabilities for the media service2 is returned in the Capabilities element onvif_ImagingCapabilities image; // The capabilities for the imaging service is returned in the Capabilities element onvif_PTZCapabilities ptz; // The capabilities for the PTZ service is returned in the Capabilities element onvif_AnalyticsCapabilities analytics; // The capabilities for the analytics service is returned in the Capabilities element onvif_RecordingCapabilities recording; // The capabilities for the recording service is returned in the Capabilities element onvif_SearchCapabilities search; // The capabilities for the search service is returned in the Capabilities element onvif_ReplayCapabilities replay; // The capabilities for the replay service is returned in the Capabilities element onvif_AccessControlCapabilities accesscontrol; // The capabilities for the accesscontrol service is returned in the Capabilities element onvif_DoorControlCapabilities doorcontrol; // The capabilities for the doorcontrol service is returned in the Capabilities element onvif_DeviceIOCapabilities deviceIO; // The capabilities for the deviceIO service is returned in the Capabilities element onvif_ThermalCapabilities thermal; // The capabilities for the thermal service is returned in the Capabilities element onvif_CredentialCapabilities credential; // The capabilities for the credential service is returned in the Capabilities element onvif_AccessRulesCapabilities accessrules; // The capabilities for the access rules service is returned in the Capabilities element onvif_ScheduleCapabilities schedule; // The capabilities for the schedule service is returned in the Capabilities element onvif_ReceiverCapabilities receiver; // The capabilities for the receiver service is returned in the Capabilities element onvif_ProvisioningCapabilities provisioning; // The capabilities for the provisioning service is returned in the Capabilities element } onvif_Capabilities; typedef struct { char Manufacturer[64]; // required, The manufactor of the device char Model[64]; // required, The device model char FirmwareVersion[64]; // required, The firmware version in the device char SerialNumber[64]; // required, The serial number of the device char HardwareId[64]; // required, The hardware ID of the device } onvif_DeviceInformation; typedef struct { int Width; // required int Height; // required } onvif_VideoResolution; typedef struct { int Min; // required int Max; // required } onvif_IntRange; typedef struct { int x; // required int y; // required int width; // required int height; // required } onvif_IntRectangle; typedef struct { float bottom; // required float top; // required float right; // required float left; // required } onvif_Rectangle; typedef struct { uint32 LevelFlag : 1; // Indicates whether the field Level is valid uint32 Reserved : 31; onvif_BacklightCompensationMode Mode; // required, Backlight compensation mode (on/off) float Level; // optional, Optional level parameter (unit unspecified) } onvif_BacklightCompensation; typedef struct { uint32 PriorityFlag : 1; // Indicates whether the field Priority is valid uint32 MinExposureTimeFlag : 1; // Indicates whether the field MinExposureTime is valid uint32 MaxExposureTimeFlag : 1; // Indicates whether the field MaxExposureTime is valid uint32 MinGainFlag : 1; // Indicates whether the field MinGain is valid uint32 MaxGainFlag : 1; // Indicates whether the field MaxGain is valid uint32 MinIrisFlag : 1; // Indicates whether the field MinIris is valid uint32 MaxIrisFlag : 1; // Indicates whether the field MaxIris is valid uint32 ExposureTimeFlag : 1; // Indicates whether the field ExposureTime is valid uint32 GainFlag : 1; // Indicates whether the field Gain is valid uint32 IrisFlag : 1; // Indicates whether the field Iris is valid uint32 Reserved : 22; onvif_ExposureMode Mode; // required, Auto - Enabled the exposure algorithm on the device; Manual - Disabled exposure algorithm on the device onvif_ExposurePriority Priority; // optional, The exposure priority mode (low noise/framerate) onvif_Rectangle Window; // required, float MinExposureTime; // optional, Minimum value of exposure time range allowed to be used by the algorithm float MaxExposureTime; // optional, Maximum value of exposure time range allowed to be used by the algorithm float MinGain; // optional, Minimum value of the sensor gain range that is allowed to be used by the algorithm float MaxGain; // optional, Maximum value of the sensor gain range that is allowed to be used by the algorithm float MinIris; // optional, Minimum value of the iris range allowed to be used by the algorithm float MaxIris; // optional, Maximum value of the iris range allowed to be used by the algorithm float ExposureTime; // optional, The fixed exposure time used by the image sensor float Gain; // optional, The fixed gain used by the image sensor (dB) float Iris; // optional, The fixed attenuation of input light affected by the iris (dB). 0dB maps to a fully opened iris } onvif_Exposure; typedef struct { uint32 DefaultSpeedFlag : 1; // Indicates whether the field DefaultSpeed is valid uint32 NearLimitFlag : 1; // Indicates whether the field NearLimit is valid uint32 FarLimitFlag : 1; // Indicates whether the field FarLimit is valid uint32 Reserved : 29; onvif_AutoFocusMode AutoFocusMode; // required, Mode of auto fucus float DefaultSpeed; // optional, float NearLimit; // optional, Parameter to set autofocus near limit (unit: meter) float FarLimit; // optional, Parameter to set autofocus far limit (unit: meter) } onvif_FocusConfiguration; typedef struct { uint32 LevelFlag : 1; // Indicates whether the field Level is valid uint32 Reserved : 31; onvif_WideDynamicMode Mode; // required, Wide dynamic range mode (on/off), 0-OFF, 1-ON float Level; // optional, Optional level parameter (unit unspecified) } onvif_WideDynamicRange; typedef struct { uint32 CrGainFlag : 1; // Indicates whether the field CrGain is valid uint32 CbGainFlag : 1; // Indicates whether the field CbGain is valid uint32 Reserved : 30; onvif_WhiteBalanceMode Mode; // required, 'AUTO' or 'MANUAL' float CrGain; // optional, Rgain (unitless) float CbGain; // optional, Bgain (unitless) } onvif_WhiteBalance; typedef struct { uint32 BacklightCompensationFlag : 1; // Indicates whether the field BacklightCompensation is valid uint32 BrightnessFlag : 1; // Indicates whether the field Brightness is valid uint32 ColorSaturationFlag : 1; // Indicates whether the field ColorSaturation is valid uint32 ContrastFlag : 1; // Indicates whether the field Contrast is valid uint32 ExposureFlag : 1; // Indicates whether the field Exposure is valid uint32 FocusFlag : 1; // Indicates whether the field Focus is valid uint32 IrCutFilterFlag : 1; // Indicates whether the field IrCutFilter is valid uint32 SharpnessFlag : 1; // Indicates whether the field Sharpness is valid uint32 WideDynamicRangeFlag : 1; // Indicates whether the field WideDynamicRange is valid uint32 WhiteBalanceFlag : 1; // Indicates whether the field WhiteBalance is valid uint32 Reserved : 22; onvif_BacklightCompensation BacklightCompensation; // optional, Enabled/disabled BLC mode (on/off) float Brightness; // optional, Image brightness (unit unspecified) float ColorSaturation; // optional, Color saturation of the image (unit unspecified) float Contrast; // optional, Contrast of the image (unit unspecified) onvif_Exposure Exposure; // optional, Exposure mode of the device onvif_FocusConfiguration Focus; // optional, Focus configuration onvif_IrCutFilterMode IrCutFilter; // optional, Infrared Cutoff Filter settings float Sharpness; // optional, Sharpness of the Video image onvif_WideDynamicRange WideDynamicRange; // optional, WDR settings onvif_WhiteBalance WhiteBalance; // optional, White balance settings } onvif_ImagingSettings; typedef struct { uint32 Mode_ON : 1; // Indicates whether mode ON is valid uint32 Mode_OFF : 1; // Indicates whether mode OFF is valid uint32 LevelFlag : 1; // Indicates whether the field LevelFlag is valid uint32 Reserved : 29; onvif_FloatRange Level; // optional, Level range of BacklightCompensation } onvif_BacklightCompensationOptions; typedef struct { uint32 Mode_AUTO : 1; // Indicates whether mode AUTO is valid uint32 Mode_MANUAL : 1; // Indicates whether mode Manual is valid uint32 Priority_LowNoise : 1; // Indicates whether Priority LowNoise is valid uint32 Priority_FrameRate : 1; // Indicates whether Priority FrameRate is valid uint32 MinExposureTimeFlag : 1; // Indicates whether the field MinExposureTime is valid uint32 MaxExposureTimeFlag : 1; // Indicates whether the field MaxExposureTime is valid uint32 MinGainFlag : 1; // Indicates whether the field MinGain is valid uint32 MaxGainFlag : 1; // Indicates whether the field MaxGain is valid uint32 MinIrisFlag : 1; // Indicates whether the field MinIris is valid uint32 MaxIrisFlag : 1; // Indicates whether the field MaxIris is valid uint32 ExposureTimeFlag : 1; // Indicates whether the field ExposureTime is valid uint32 GainFlag : 1; // Indicates whether the field Gain is valid uint32 IrisFlag : 1; // Indicates whether the field Iris is valid uint32 Reserved : 19; onvif_FloatRange MinExposureTime; // optional, Valid range of the Minimum ExposureTime onvif_FloatRange MaxExposureTime; // optional, Valid range of the Maximum ExposureTime onvif_FloatRange MinGain; // optional, Valid range of the Minimum Gain onvif_FloatRange MaxGain; // optional, Valid range of the Maximum Gain onvif_FloatRange MinIris; // optional, Valid range of the Minimum Iris onvif_FloatRange MaxIris; // optional, Valid range of the Maximum Iris onvif_FloatRange ExposureTime; // optional, Valid range of the ExposureTime onvif_FloatRange Gain; // optional, Valid range of the Gain onvif_FloatRange Iris; // optional, Valid range of the Iris } onvif_ExposureOptions; typedef struct { uint32 AutoFocusModes_AUTO : 1; // Indicates whether mode aUTO is valid uint32 AutoFocusModes_MANUAL : 1; // Indicates whether mode Manual is valid uint32 DefaultSpeedFlag : 1; // Indicates whether the field DefaultSpeed is valid uint32 NearLimitFlag : 1; // Indicates whether the field NearLimit is valid uint32 FarLimitFlag : 1; // Indicates whether the field FarLimit is valid uint32 Reserved : 27; onvif_FloatRange DefaultSpeed; // optional, Valid range of DefaultSpeed onvif_FloatRange NearLimit; // optional, Valid range of NearLimit onvif_FloatRange FarLimit; // optional, Valid range of FarLimit } onvif_FocusOptions; typedef struct { uint32 Mode_ON : 1; // Indicates whether mode ON is valid uint32 Mode_OFF : 1; // Indicates whether mode OFF is valid uint32 LevelFlag : 1; // Indicates whether the field Level is valid uint32 Reserved : 29; onvif_FloatRange Level; // optional, Valid range of Level } onvif_WideDynamicRangeOptions; typedef struct { uint32 Mode_AUTO : 1; // Indicates whether mode AUDO is valid uint32 Mode_MANUAL : 1; // Indicates whether mode Manual is valid uint32 YrGainFlag : 1; // Indicates whether the field CrGain is valid uint32 YbGainFlag : 1; // Indicates whether the field CbGain is valid uint32 Reserved : 28; onvif_FloatRange YrGain; // optional, Valid range of YrGain onvif_FloatRange YbGain; // optional, Valid range of YbGain } onvif_WhiteBalanceOptions; typedef struct { uint32 IrCutFilterMode_ON : 1; // Indicates whether IrCutFilter mode ON is valid uint32 IrCutFilterMode_OFF : 1; // Indicates whether IrCutFilter mode OFF is valid uint32 IrCutFilterMode_AUTO : 1; // Indicates whether IrCutFilter mode AUTO is valid uint32 BacklightCompensationFlag : 1; // Indicates whether the field BacklightCompensation is valid uint32 BrightnessFlag : 1; // Indicates whether the field Brightness is valid uint32 ColorSaturationFlag : 1; // Indicates whether the field ColorSaturation is valid uint32 ContrastFlag : 1; // Indicates whether the field Contrast is valid uint32 ExposureFlag : 1; // Indicates whether the field Exposure is valid uint32 FocusFlag : 1; // Indicates whether the field Focus is valid uint32 SharpnessFlag : 1; // Indicates whether the field Sharpness is valid uint32 WideDynamicRangeFlag : 1; // Indicates whether the field WideDynamicRange is valid uint32 WhiteBalanceFlag : 1; // Indicates whether the field WhiteBalance is valid uint32 Reserved : 20; onvif_BacklightCompensationOptions BacklightCompensation; // optional, Valid range of Backlight Compensation onvif_FloatRange Brightness; // optional, Valid range of Brightness onvif_FloatRange ColorSaturation; // optional, alid range of Color Saturation onvif_FloatRange Contrast; // optional, Valid range of Contrast onvif_ExposureOptions Exposure; // optional, Valid range of Exposure onvif_FocusOptions Focus; // optional, Valid range of Focus onvif_FloatRange Sharpness; // optional, Valid range of Sharpness onvif_WideDynamicRangeOptions WideDynamicRange; // optional, Valid range of WideDynamicRange onvif_WhiteBalanceOptions WhiteBalance; // optional, Valid range of WhiteBalance } onvif_ImagingOptions; typedef struct { uint32 ErrorFlag : 1; // Indicates whether the field Error is valid uint32 Reserved : 31; float Position; // required, Status of focus position onvif_MoveStatus MoveStatus; // required, Status of focus MoveStatus char Error[100]; // optional, Error status of focus } onvif_FocusStatus; typedef struct { uint32 FocusStatusFlag : 1; // Indicates whether the field FocusStatus is valid uint32 Reserved : 31; onvif_FocusStatus FocusStatus; // optional, Status of focus } onvif_ImagingStatus; typedef struct { uint32 SpeedFlag : 1; uint32 Reserved : 31; onvif_FloatRange Position; // required, Valid ranges of the position onvif_FloatRange Speed; // optional, Valid ranges of the speed } onvif_AbsoluteFocusOptions; typedef struct { uint32 SpeedFlag : 1; uint32 Reserved : 31; onvif_FloatRange Distance; // required, valid ranges of the distance onvif_FloatRange Speed; // optional, Valid ranges of the speed } onvif_RelativeFocusOptions20; typedef struct { onvif_FloatRange Speed; // required, Valid ranges of the speed } onvif_ContinuousFocusOptions; typedef struct { uint32 AbsoluteFlag : 1; uint32 RelativeFlag : 1; uint32 ContinuousFlag : 1; uint32 Reserved : 29; onvif_AbsoluteFocusOptions Absolute; // optional, Valid ranges for the absolute control onvif_RelativeFocusOptions20 Relative; // optional, Valid ranges for the relative control onvif_ContinuousFocusOptions Continuous; // optional, Valid ranges for the continuous control } onvif_MoveOptions20; typedef struct { uint32 SpeedFlag : 1; // Indicates whether the field Speed is valid uint32 Reserved : 31; float Position; // required, Position parameter for the absolute focus control float Speed; // optional, Speed parameter for the absolute focus control } onvif_AbsoluteFocus; typedef struct { uint32 SpeedFlag : 1; // Indicates whether the field Speed is valid uint32 Reserved : 31; float Distance; // required, Distance parameter for the relative focus control float Speed; // optional, Speed parameter for the relative focus control } onvif_RelativeFocus; typedef struct { float Speed; // required, Speed parameter for the Continuous focus control } onvif_ContinuousFocus; typedef struct { uint32 AbsoluteFlag : 1; // Indicates whether the field Absolute is valid uint32 RelativeFlag : 1; // Indicates whether the field Relative is valid uint32 ContinuousFlag : 1; // Indicates whether the field Continuous is valid uint32 Reserved : 29; onvif_AbsoluteFocus Absolute; // optional, Parameters for the absolute focus control onvif_RelativeFocus Relative; // optional, Parameters for the relative focus control onvif_ContinuousFocus Continuous; // optional, Parameter for the continuous focus control } onvif_FocusMove; typedef struct { char Name[ONVIF_NAME_LEN]; // required, Human readable name of the Imaging Preset char token[ONVIF_TOKEN_LEN]; // required, Unique identifier of this Imaging Preset char type[64]; // required, Indicates Imaging Preset Type. Use ImagingPresetType // Describes standard Imaging Preset types, // used to facilitate Multi-language support and client display. // "Custom" Type shall be used when Imaging Preset Name does not // match any of the types included in the standard classification // Custom // ClearWeather // Cloudy // Fog // Rain // Snowing // Snow // WDR // Shade // Night // Indoor // Fluorescent // Incandescent // Sodium(Natrium) // Sunrise(Horizon) // Sunset(Rear) // ExtremeHot // ExtremeCold // Underwater // CloseUp // Motion // FlickerFree50 // FlickerFree60 } onvif_ImagingPreset; typedef struct _ImagingPresetList { struct _ImagingPresetList * next; onvif_ImagingPreset Preset; } ImagingPresetList; typedef struct { uint32 PasswordFlag : 1; // Indicates whether the field Password is valid uint32 Reserved : 31; char Username[ONVIF_NAME_LEN]; // required char Password[ONVIF_NAME_LEN]; // optional onvif_UserLevel UserLevel; // required } onvif_User; typedef struct { uint32 PasswordFlag : 1; // Indicates whether the field Password is valid uint32 Reserved : 31; char Username[ONVIF_NAME_LEN]; // required char Password[ONVIF_NAME_LEN]; // optional BOOL UseDerivedPassword; // required } onvif_RemoteUser; typedef struct { char Address[100]; // required int PrefixLength; // required } onvif_PrefixedIPAddress; typedef struct { onvif_IPAddressFilterType Type; // required onvif_PrefixedIPAddress IPv4Address[20]; // optional onvif_PrefixedIPAddress IPv6Address[20]; // optional } onvif_IPAddressFilter; typedef struct { uint32 ImagingSettingsFlag : 1; // Indicates whether the field ImagingSettings is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required float Framerate; // required, Frame rate in frames per second onvif_VideoResolution Resolution; // required, Horizontal and vertical resolution onvif_ImagingSettings ImagingSettings; // optional } onvif_VideoSource; typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Enabled : 1; //optional, Indication of whether this mode is active. If active this value is true. In case of non-indication, it means as false. // The value of true shall be had by only one video source mode uint32 Reboot : 1; // required, After setting the mode if a device starts to reboot this value is true. If a device change the mode without rebooting this value is false. // If true, configured parameters may not be guaranteed by the device after rebooting uint32 Reserved : 29; float MaxFramerate; // required, Max frame rate in frames per second for this video source mode char Encodings[32]; // required, Indication which encodings are supported for this video source. char Description[128]; // optional, Informative description of this video source mode. This field should be described in English char token[ONVIF_TOKEN_LEN]; // required, Indicate token for video source mode onvif_VideoResolution MaxResolution; // required, Max horizontal and vertical resolution for this video source mode } onvif_VideoSourceMode; typedef struct { uint32 DegreeFlag : 1; // Indicates whether the field Degree is valid uint32 Reserved : 31; onvif_RotateMode Mode; // required, Parameter to enable/disable Rotation feature int Degree; // optional, Optional parameter to configure how much degree of clockwise rotation of image for On mode. Omitting this parameter for On mode means 180 degree rotation } onvif_Rotate; typedef struct { uint32 RotateFlag : 1; // Indicates whether the field Rotate is valid uint32 Reserved : 31; onvif_Rotate Rotate; // optional, Optional element to configure rotation of captured image } onvif_VideoSourceConfigurationExtension; typedef struct { uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 Reserved : 31; char Name[ONVIF_NAME_LEN]; // required, User readable name. Length up to 64 characters int UseCount; // required, Number of internal references currently using this configuration. This parameter is read-only and cannot be changed by a set request char token[ONVIF_TOKEN_LEN]; // required, Token that uniquely refernces this configuration. Length up to 64 characters char SourceToken[ONVIF_TOKEN_LEN]; // required, Reference to the physical input onvif_IntRectangle Bounds; // required, Rectangle specifying the Video capturing area. The capturing area shall not be larger than the whole Video source area onvif_VideoSourceConfigurationExtension Extension; // optional } onvif_VideoSourceConfiguration; typedef struct { onvif_IntRange XRange; // required onvif_IntRange YRange; // required onvif_IntRange WidthRange; // required onvif_IntRange HeightRange; // required } onvif_IntRectangleRange; typedef struct { uint32 RotateMode_OFF : 1; // Indicates whether the mode RotateMode_OFF is valid uint32 RotateMode_ON : 1; // Indicates whether the mode RotateMode_ON is valid uint32 RotateMode_AUTO : 1; // Indicates whether the mode RotateMode_AUTO is valid uint32 Reboot : 1; // Signals if a device requires a reboot after changing the rotation. // If a device can handle rotation changes without rebooting this value shall be set to false. uint32 Reserved : 28; uint32 sizeDegreeList; int DegreeList[10]; // optional, List of supported degree value for rotation } onvif_RotateOptions; typedef struct { uint32 RotateFlag : 1; // Indicates whether the field Rotate is valid uint32 Reserved : 31; onvif_RotateOptions Rotate; // optional, Options of parameters for Rotation feature } onvif_VideoSourceConfigurationOptionsExtension; typedef struct { uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 MaximumNumberOfProfilesFlag : 1; // Indicates whether the field MaximumNumberOfProfiles is valid uint32 Reserved : 30; onvif_IntRectangleRange BoundsRange; // required uint32 sizeVideoSourceTokensAvailable; char VideoSourceTokensAvailable[10][ONVIF_TOKEN_LEN]; // required onvif_VideoSourceConfigurationOptionsExtension Extension; // optional int MaximumNumberOfProfiles; // optional, Maximum number of profiles } onvif_VideoSourceConfigurationOptions; typedef struct { uint32 ConstantBitRateFlag : 1; // Indicates whether the field ConstantBitRate is valid uint32 Reserved : 31; int FrameRateLimit; // required, Maximum output framerate in fps. If an EncodingInterval is provided the resulting encoded framerate will be reduced by the given factor int EncodingInterval; // required, Interval at which images are encoded and transmitted. (A value of 1 means that every frame is encoded, a value of 2 means that every 2nd frame is encoded ...) int BitrateLimit; // required, the maximum output bitrate in kbps BOOL ConstantBitRate; // optional, Enforce constant bitrate } onvif_VideoRateControl; typedef struct { int GovLength; // required, Determines the interval in which the I-Frames will be coded. An entry of 1 indicates I-Frames are continuously generated. // An entry of 2 indicates that every 2nd image is an I-Frame, and 3 only every 3rd frame, etc. The frames in between are coded as P or B Frames. onvif_Mpeg4Profile Mpeg4Profile; // required, the Mpeg4 profile, either simple profile (SP) or advanced simple profile (ASP) } onvif_Mpeg4Configuration; typedef struct { int GovLength; // required, Group of Video frames length. Determines typically the interval in which the I-Frames will be coded. An entry of 1 indicates I-Frames are continuously generated. // An entry of 2 indicates that every 2nd image is an I-Frame, and 3 only every 3rd frame, etc. The frames in between are coded as P or B Frames onvif_H264Profile H264Profile; // required, the H.264 profile, either baseline, main, extended or high } onvif_H264Configuration; typedef struct { char IPv4Address[32]; // required, The multicast address int Port; // required, The RTP mutlicast destination port. A device may support RTCP. In this case the port value shall be even to allow the corresponding RTCP stream to be mapped // to the next higher (odd) destination port number as defined in the RTSP specification int TTL; // required, In case of IPv6 the TTL value is assumed as the hop limit. Note that for IPV6 and administratively scoped IPv4 multicast the primary use for hop limit / TTL is // to prevent packets from (endlessly) circulating and not limiting scope. In these cases the address contains the scope BOOL AutoStart; // required, Read only property signalling that streaming is persistant. Use the methods StartMulticastStreaming and StopMulticastStreaming to switch its state } onvif_MulticastConfiguration; typedef struct { uint32 RateControlFlag : 1; // Indicates whether the field RateControl is valid uint32 MPEG4Flag : 1; // Indicates whether the field MPEG4 is valid uint32 H264Flag : 1; // Indicates whether the field H264 is valid uint32 Reserved : 29; char Name[ONVIF_NAME_LEN]; // required, User readable name. Length up to 64 characters int UseCount; // required, Number of internal references currently using this configuration. This parameter is read-only and cannot be changed by a set request char token[ONVIF_TOKEN_LEN]; // required, Token that uniquely refernces this configuration. Length up to 64 characters onvif_VideoEncoding Encoding; // required, Used video codec, either Jpeg, H.264 or Mpeg4 onvif_VideoResolution Resolution; // required, Configured video resolution int Quality; // required, Relative value for the video quantizers and the quality of the video. A high value within supported quality range means higher quality onvif_VideoRateControl RateControl; // optional, Optional element to configure rate control related parameters onvif_Mpeg4Configuration MPEG4; // optional, Optional element to configure Mpeg4 related parameters onvif_H264Configuration H264; // optional, Optional element to configure H.264 related parameters onvif_MulticastConfiguration Multicast; // required, Defines the multicast settings that could be used for video streaming int SessionTimeout; // required, The rtsp session timeout for the related video stream, unit is second } onvif_VideoEncoderConfiguration; typedef struct { char token[ONVIF_TOKEN_LEN]; // required int Channels; // required, number of available audio channels. (1: mono, 2: stereo) } onvif_AudioSource; typedef struct { char Name[ONVIF_NAME_LEN]; // required, User readable name. Length up to 64 characters int UseCount; // required, Number of internal references currently using this configuration. This parameter is read-only and cannot be changed by a set request char token[ONVIF_TOKEN_LEN]; // required, Token that uniquely refernces this configuration. Length up to 64 characters char SourceToken[ONVIF_TOKEN_LEN]; // required, Token of the Audio Source the configuration applies to } onvif_AudioSourceConfiguration; typedef struct { char Name[ONVIF_NAME_LEN]; // required, User readable name. Length up to 64 characters int UseCount; // required, Number of internal references currently using this configuration. This parameter is read-only and cannot be changed by a set request char token[ONVIF_TOKEN_LEN]; // required, Token that uniquely refernces this configuration. Length up to 64 characters onvif_AudioEncoding Encoding; // required, Audio codec used for encoding the audio input (either G.711, G.726 or AAC) int Bitrate; // required, The output bitrate in kbps int SampleRate; // required, The output sample rate in kHz onvif_MulticastConfiguration Multicast; // required, Defines the multicast settings that could be used for video streaming int SessionTimeout; // required, The rtsp session timeout for the related audio stream, unit is second } onvif_AudioEncoderConfiguration; typedef struct { onvif_AudioEncoding Encoding; // required, The enoding used for audio data (either G.711, G.726 or AAC) onvif_IntList BitrateList; // required, List of supported bitrates in kbps for the specified Encoding onvif_IntList SampleRateList; // required, List of supported Sample Rates in kHz for the specified Encoding } onvif_AudioEncoderConfigurationOption; typedef struct { uint32 sizeOptions; // required, valid Options numbers onvif_AudioEncoderConfigurationOption Options[3]; // optional, list of supported AudioEncoderConfigurations } onvif_AudioEncoderConfigurationOptions; typedef struct { onvif_VideoResolution ResolutionsAvailable[MAX_RES_NUMS]; // required, List of supported image sizes onvif_IntRange FrameRateRange; // required, Supported frame rate in fps (frames per second) onvif_IntRange EncodingIntervalRange; // required, Supported encoding interval range. The encoding interval corresponds to the number of frames devided by the encoded frames. An encoding interval value of "1" means that all frames are encoded } onvif_JpegOptions; typedef struct { uint32 Mpeg4Profile_SP : 1; // required, Indicates whether the SP profile is valid uint32 Mpeg4Profile_ASP : 1; // required, Indicates whether the ASP profile is valid uint32 Reserverd : 30; onvif_VideoResolution ResolutionsAvailable[MAX_RES_NUMS]; // required, List of supported image sizes onvif_IntRange GovLengthRange; // required, Supported group of Video frames length. This value typically corresponds to the I-Frame distance onvif_IntRange FrameRateRange; // required, Supported frame rate in fps (frames per second) onvif_IntRange EncodingIntervalRange; // required, Supported encoding interval range. The encoding interval corresponds to the number of frames devided by the encoded frames. An encoding interval value of "1" means that all frames are encoded } onvif_Mpeg4Options; typedef struct { uint32 H264Profile_Baseline : 1; // required, Indicates whether the Baseline profile is valid uint32 H264Profile_Main : 1; // required, Indicates whether the Main profile is valid uint32 H264Profile_Extended : 1; // required, Indicates whether the Extended profile is valid uint32 H264Profile_High : 1; // required, Indicates whether the High profile is valid uint32 Reserverd : 28; onvif_VideoResolution ResolutionsAvailable[MAX_RES_NUMS]; // required, List of supported image sizes onvif_IntRange GovLengthRange; // required, Supported group of Video frames length. This value typically corresponds to the I-Frame distance onvif_IntRange FrameRateRange; // required, Supported frame rate in fps (frames per second) onvif_IntRange EncodingIntervalRange; // required, Supported encoding interval range. The encoding interval corresponds to the number of frames devided by the encoded frames. An encoding interval value of "1" means that all frames are encoded } onvif_H264Options; typedef struct { onvif_JpegOptions JpegOptions; // required onvif_IntRange BitrateRange; // required } onvif_JpegOptions2; typedef struct { onvif_Mpeg4Options Mpeg4Options; // required onvif_IntRange BitrateRange; // required } onvif_Mpeg4Options2; typedef struct { onvif_H264Options H264Options; // required onvif_IntRange BitrateRange; // required } onvif_H264Options2; typedef struct { uint32 JPEGFlag : 1; // Indicates whether the field JPEG is valid uint32 MPEG4Flag : 1; // Indicates whether the field MPEG4 is valid uint32 H264Flag : 1; // Indicates whether the field H264 is valid uint32 Reserved : 29; onvif_JpegOptions2 JPEG; // optional onvif_Mpeg4Options2 MPEG4; // optional onvif_H264Options2 H264; // optional } onvif_VideoEncoderOptionsExtension; typedef struct { uint32 JPEGFlag : 1; // Indicates whether the field JPEG is valid uint32 MPEG4Flag : 1; // Indicates whether the field MPEG4 is valid uint32 H264Flag : 1; // Indicates whether the field H264 is valid uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 Reserved : 28; onvif_IntRange QualityRange; // required, Range of the quality values. A high value means higher quality onvif_JpegOptions JPEG; // optional, Optional JPEG encoder settings ranges onvif_Mpeg4Options MPEG4; // optional, Optional MPEG-4 encoder settings ranges onvif_H264Options H264; // optional, Optional H.264 encoder settings ranges onvif_VideoEncoderOptionsExtension Extension; // optional } onvif_VideoEncoderConfigurationOptions; typedef struct { BOOL Status; // required, True if the metadata stream shall contain the PTZ status (IDLE, MOVING or UNKNOWN) BOOL Position; // required, True if the metadata stream shall contain the PTZ position } onvif_PTZFilter; typedef struct { char Dialect[1024]; // Dialect char TopicExpression[256]; // TopicExpression } onvif_EventSubscription; typedef struct { uint32 PanTiltStatusSupported : 1; // required, True if the device is able to stream pan or tilt status information uint32 ZoomStatusSupported : 1; // required, True if the device is able to stream zoom status inforamtion uint32 PanTiltPositionSupported : 1; // optional, True if the device is able to stream the pan or tilt position uint32 ZoomPositionSupported : 1; // optional, True if the device is able to stream zoom position information uint32 Reserved : 28; } onvif_PTZStatusFilterOptions; typedef struct { uint32 sizeCompressionType; // sequence of elements char CompressionType[4][32]; // optional, List of supported metadata compression type. Its options shall be chosen from tt:MetadataCompressionType } onvif_MetadataConfigurationOptionsExtension; typedef struct { uint32 GeoLocation : 1; // Optional, True if the device is able to stream the Geo Located positions of each target uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 Reserved : 30; onvif_PTZStatusFilterOptions PTZStatusFilterOptions;// required, This message contains the metadata configuration options. If a metadata configuration is specified, // the options shall concern that particular configuration. If a media profile is specified, the options shall be compatible with that media profile. // If no tokens are specified, the options shall be considered generic for the device onvif_MetadataConfigurationOptionsExtension Extension; // Optional } onvif_MetadataConfigurationOptions; typedef struct { uint32 PosFlag : 1; // Indicates whether the field Pos is valid uint32 Reserved : 31; onvif_OSDPosType Type; // required, For OSD position type onvif_Vector Pos; // Optional, when Type is Custom, this field is valid } onvif_OSDPosConfiguration; typedef struct { uint32 ColorspaceFlag : 1; // Indicates whether the field Colorspace is valid uint32 TransparentFlag : 1; // Indicates whether the field Transparent is valid uint32 Reserved : 30; float X; // required, float Y; // required, float Z; // required, int Transparent; // Optional, The value range of "Transparent" could be defined by vendors only should follow this rule: the minimum value means non-transparent and the maximum value maens fully transparent char Colorspace[256]; // Optional, support the following colorspace // http://www.onvif.org/ver10/colorspace/YCbCr // http://www.onvif.org/ver10/colorspace/CIELUV // http://www.onvif.org/ver10/colorspace/CIELAB // http://www.onvif.org/ver10/colorspace/HSV } onvif_OSDColor; typedef struct { uint32 DateFormatFlag : 1; // Indicates whether the field DateFormat is valid uint32 TimeFormatFlag : 1; // Indicates whether the field TimeFormat is valid uint32 FontSizeFlag : 1; // Indicates whether the field FontSize is valid uint32 FontColorFlag : 1; // Indicates whether the field FontColor is valid uint32 BackgroundColorFlag : 1; // Indicates whether the field BackgroundColor is valid uint32 PlainTextFlag : 1; // Indicates whether the field PlainText is valid uint32 Reserved : 26; onvif_OSDTextType Type; // required, char DateFormat[64]; // Optional, List of supported OSD date formats. This element shall be present when the value of Type field has Date or DateAndTime. The following DateFormat are defined: /* M/d/yyyy - e.g. 3/6/2013 MM/dd/yyyy - e.g. 03/06/2013 dd/MM/yyyy - e.g. 06/03/2013 yyyy/MM/dd - e.g. 2013/03/06 yyyy-MM-dd - e.g. 2013-06-03 dddd, MMMM dd, yyyy - e.g. Wednesday, March 06, 2013 MMMM dd, yyyy - e.g. March 06, 2013 dd MMMM, yyyy - e.g. 06 March, 2013 */ char TimeFormat[64]; // Optional, List of supported OSD time formats. This element shall be present when the value of Type field has Time or DateAndTime. The following TimeFormat are defined: /* h:mm:ss tt - e.g. 2:14:21 PM hh:mm:ss tt - e.g. 02:14:21 PM H:mm:ss - e.g. 14:14:21 HH:mm:ss - e.g. 14:14:21 */ int FontSize; // Optional, Font size of the text in pt onvif_OSDColor FontColor; // Optional, Font color of the text onvif_OSDColor BackgroundColor; // Optional, Background color of the text char PlainText[256]; // Optional, The content of text to be displayed } onvif_OSDTextConfiguration; typedef struct { char ImgPath[256]; // required, The URI of the image which to be displayed } onvif_OSDImgConfiguration; typedef struct { uint32 TextStringFlag : 1; // Indicates whether the field TextString is valid uint32 ImageFlag : 1; // Indicates whether the field Image is valid uint32 Reserved : 30; char token[ONVIF_TOKEN_LEN]; // required, OSD config token char VideoSourceConfigurationToken[ONVIF_TOKEN_LEN]; // required, Reference to the video source configuration onvif_OSDType Type; // required, Type of OSD onvif_OSDPosConfiguration Position; // required, Position configuration of OSD onvif_OSDTextConfiguration TextString; // Optional, Text configuration of OSD. It shall be present when the value of Type field is Text onvif_OSDImgConfiguration Image; // Optional, Image configuration of OSD. It shall be present when the value of Type field is Image } onvif_OSDConfiguration; typedef struct { uint32 ImageFlag : 1; // Indicates whether the field Image is valid uint32 PlainTextFlag : 1; // Indicates whether the field PlainText is valid uint32 DateFlag : 1; // Indicates whether the field Date is valid uint32 TimeFlag : 1; // Indicates whether the field Time is valid uint32 DateAndTimeFlag : 1; // Indicates whether the field DateAndTime is valid uint32 Reserved : 27; int Total; // required int Image; // optional int PlainText; // optional int Date; // optional int Time; // optional int DateAndTime; // optional } onvif_MaximumNumberOfOSDs; typedef struct { uint32 ColorspaceFlag : 1; // Indicates whether the field Colorspace is valid uint32 LikelihoodFlag : 1; // Indicates whether the field Likelihood is valid uint32 Reserved : 30; float X; // required, float Y; // required, float Z; // required, char Colorspace[128]; // optional, The following values are acceptable for Colourspace attribute // http://www.onvif.org/ver10/colorspace/YCbCr - YCbCr // http://www.onvif.org/ver10/colorspace/RGB - RGB float Likelihood; // optional, Likelihood that the color is correct } onvif_Color; typedef struct { onvif_FloatRange X; // required onvif_FloatRange Y; // required onvif_FloatRange Z; // required char Colorspace[128]; // required, The following values are acceptable for Colourspace attribute // http://www.onvif.org/ver10/colorspace/YCbCr // http://www.onvif.org/ver10/colorspace/CIELUV // http://www.onvif.org/ver10/colorspace/CIELAB // http://www.onvif.org/ver10/colorspace/HSV } onvif_ColorspaceRange; typedef struct { uint32 sizeColorList; onvif_Color ColorList[10]; // optional, List the supported color uint32 sizeColorspaceRange; onvif_ColorspaceRange ColorspaceRange[10]; // optional, Define the rang of color supported } onvif_ColorOptions; typedef struct { uint32 ColorFlag : 1; // Indicates whether the field Color is valid uint32 TransparentFlag : 1; // Indicates whether the field Transparent is valid uint32 Reserved : 30; onvif_ColorOptions Color; // optional, Optional list of supported colors onvif_IntRange Transparent; // optional, Range of the transparent level. Larger means more tranparent } onvif_OSDColorOptions; typedef struct { uint32 OSDTextType_Plain : 1; // Indicates whether support OSD text type plain uint32 OSDTextType_Date : 1; // Indicates whether support OSD text type date uint32 OSDTextType_Time : 1; // Indicates whether support OSD text type time uint32 OSDTextType_DateAndTime : 1; // Indicates whether support OSD text type dateandtime uint32 FontSizeRangeFlag : 1; // Indicates whether the field FontSizeRange is valid uint32 FontColorFlag : 1; // Indicates whether the field FontColor is valid uint32 BackgroundColorFlag : 1; // Indicates whether the field BackgroundColor is valid uint32 Reserved : 25; onvif_IntRange FontSizeRange; // optional, range of the font size value uint32 DateFormatSize; char DateFormat[10][64]; // optional, List of supported date format uint32 TimeFormatSize; char TimeFormat[10][64]; // optional, List of supported time format onvif_OSDColorOptions FontColor; // optional, List of supported font color onvif_OSDColorOptions BackgroundColor; // optional, List of supported background color } onvif_OSDTextOptions; typedef struct { uint32 ImagePathSize; char ImagePath[10][256]; // required, List of avaiable uris of image } onvif_OSDImgOptions; typedef struct { uint32 OSDType_Text : 1; // Indicates whether support OSD text type uint32 OSDType_Image : 1; // Indicates whether support OSD image type uint32 OSDType_Extended : 1; // Indicates whether support OSD extended type uint32 OSDPosType_UpperLeft : 1; // Indicates whether support OSD position UpperLeft type uint32 OSDPosType_UpperRight : 1; // Indicates whether support OSD position UpperRight type uint32 OSDPosType_LowerLeft : 1; // Indicates whether support OSD position LowerLeft type uint32 OSDPosType_LowerRight : 1; // Indicates whether support OSD position LowerRight type uint32 OSDPosType_Custom : 1; // Indicates whether support OSD position Custom type uint32 TextOptionFlag : 1; // Indicates whether the field TextOption is valid uint32 ImageOptionFlag : 1; // Indicates whether the field ImageOption is valid uint32 Reserved : 22; onvif_MaximumNumberOfOSDs MaximumNumberOfOSDs; // required, The maximum number of OSD configurations supported for the specificate video source configuration. // If a device limits the number of instances by OSDType, it should indicate the supported number via the related attribute onvif_OSDTextOptions TextOption; // optional, Option of the OSD text configuration. This element shall be returned if the device is signaling the support for Text onvif_OSDImgOptions ImageOption; // optional, Option of the OSD image configuration. This element shall be returned if the device is signaling the support for Image } onvif_OSDConfigurationOptions; typedef struct { uint32 spaceFlag : 1; // Indicates whether the field space is valid uint32 reserved : 31; float x; // required char space[256]; // optional } onvif_Vector1D; typedef struct { uint32 PanTiltFlag : 1; // Indicates whether the field PanTilt is valid uint32 ZoomFlag : 1; // Indicates whether the field Zoom is valid uint32 Reserved : 30; onvif_Vector PanTilt; // optional, Pan and tilt position. The x component corresponds to pan and the y component to tilt onvif_Vector1D Zoom; // optional, A zoom position } onvif_PTZVector; typedef struct { uint32 PanTiltFlag : 1; // Indicates whether the field PanTilt is valid uint32 ZoomFlag : 1; // Indicates whether the field Zoom is valid uint32 Reserved : 30; onvif_Vector PanTilt; // optional, Pan and tilt speed. The x component corresponds to pan and the y component to tilt. If omitted in a request, the current (if any) PanTilt movement should not be affected onvif_Vector1D Zoom; // optional, A zoom speed. If omitted in a request, the current (if any) Zoom movement should not be affected } onvif_PTZSpeed; typedef struct { uint32 PTZPositionFlag : 1; // Indicates whether the field PTZPosition is valid uint32 Reserved : 31; char Name[ONVIF_NAME_LEN]; // required, A list of preset position name char token[ONVIF_TOKEN_LEN]; // required onvif_PTZVector PTZPosition; // optional, A list of preset position } onvif_PTZPreset; typedef struct { onvif_FloatRange XRange; // required onvif_FloatRange YRange; // required } onvif_PanTiltLimits; typedef struct { onvif_FloatRange XRange; // required } onvif_ZoomLimits; typedef struct onvif_PTControlDirection { uint32 EFlipFlag : 1; // Indicates whether the field EFlip is valid uint32 ReverseFlag : 1; // Indicates whether the field Reverse is valid uint32 Reserved : 30; onvif_EFlipMode EFlip; // optional, Optional element to configure related parameters for E-Flip onvif_ReverseMode Reverse; // optional, Optional element to configure related parameters for reversing of PT Control Direction } onvif_PTControlDirection; typedef struct { uint32 PTControlDirectionFlag : 1; // Indicates whether the field PTControlDirection is valid uint32 Reserved : 31; onvif_PTControlDirection PTControlDirection; // optional, Optional element to configure PT Control Direction related features } onvif_PTZConfigurationExtension; typedef struct { uint32 DefaultPTZSpeedFlag : 1; // Indicates whether the field DefaultPTZSpeed is valid uint32 DefaultPTZTimeoutFlag : 1; // Indicates whether the field DefaultPTZTimeout is valid uint32 PanTiltLimitsFlag : 1; // Indicates whether the field PanTiltLimits is valid uint32 ZoomLimitsFlag : 1; // Indicates whether the field ZoomLimits is valid uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 MoveRampFlag : 1; // Indicates whether the field MoveRamp is valid uint32 PresetRampFlag : 1; // Indicates whether the field PresetRamp is valid uint32 PresetTourRampFlag : 1; // Indicates whether the field PresetTourRamp is valid uint32 Reserved : 24; char Name[ONVIF_NAME_LEN]; // required int UseCount; // required char token[ONVIF_TOKEN_LEN]; // required char NodeToken[ONVIF_TOKEN_LEN]; // required, A mandatory reference to the PTZ Node that the PTZ Configuration belongs to onvif_PTZSpeed DefaultPTZSpeed; // optional, If the PTZ Node supports absolute or relative PTZ movements, it shall specify corresponding default Pan/Tilt and Zoom speeds int DefaultPTZTimeout; // optional, If the PTZ Node supports continuous movements, it shall specify a default timeout, after which the movement stops onvif_PanTiltLimits PanTiltLimits; // optional, The Pan/Tilt limits element should be present for a PTZ Node that supports an absolute Pan/Tilt. If the element is present it signals the support for configurable Pan/Tilt limits. // If limits are enabled, the Pan/Tilt movements shall always stay within the specified range. The Pan/Tilt limits are disabled by setting the limits to -INF or +INF onvif_ZoomLimits ZoomLimits; // optional, The Zoom limits element should be present for a PTZ Node that supports absolute zoom. If the element is present it signals the supports for configurable Zoom limits. // If limits are enabled the zoom movements shall always stay within the specified range. The Zoom limits are disabled by settings the limits to -INF and +INF onvif_PTZConfigurationExtension Extension; // optional int MoveRamp; // optional, The optional acceleration ramp used by the device when moving int PresetRamp; // optional, The optional acceleration ramp used by the device when recalling presets int PresetTourRamp; // optional, The optional acceleration ramp used by the device when executing PresetTours } onvif_PTZConfiguration; typedef struct { // Indicates which preset tour operations are available for this PTZ Node uint32 PTZPresetTourOperation_Start : 1; uint32 PTZPresetTourOperation_Stop : 1; uint32 PTZPresetTourOperation_Pause : 1; uint32 PTZPresetTourOperation_Extended : 1; uint32 Reserved : 28; int MaximumNumberOfPresetTours; // required, Indicates number of preset tours that can be created. Required preset tour operations shall be available for this PTZ Node if one or more preset tour is supported } onvif_PTZPresetTourSupported; typedef struct { uint32 SupportedPresetTourFlag : 1; // Indicates whether the field SupportedPresetTour is valid uint32 Reserved : 31; onvif_PTZPresetTourSupported SupportedPresetTour;// optional, Detail of supported Preset Tour feature } onvif_PTZNodeExtension; typedef struct { char URI[256]; // required, A URI of coordinate systems. onvif_FloatRange XRange; // required, A range of x-axis onvif_FloatRange YRange; // required, A range of y-axis } onvif_Space2DDescription; typedef struct { char URI[256]; // required, A URI of coordinate systems onvif_FloatRange XRange; // required, A range of x-axis } onvif_Space1DDescription; typedef struct { uint32 AbsolutePanTiltPositionSpaceFlag : 1; // Indicates whether the field AbsolutePanTiltPositionSpace is valid uint32 AbsoluteZoomPositionSpaceFlag : 1; // Indicates whether the field AbsoluteZoomPositionSpace is valid uint32 RelativePanTiltTranslationSpaceFlag : 1; // Indicates whether the field RelativePanTiltTranslationSpace is valid uint32 RelativeZoomTranslationSpaceFlag : 1; // Indicates whether the field RelativeZoomTranslationSpace is valid uint32 ContinuousPanTiltVelocitySpaceFlag : 1; // Indicates whether the field ContinuousPanTiltVelocitySpace is valid uint32 ContinuousZoomVelocitySpaceFlag : 1; // Indicates whether the field ContinuousZoomVelocitySpace is valid uint32 PanTiltSpeedSpaceFlag : 1; // Indicates whether the field PanTiltSpeedSpace is valid uint32 ZoomSpeedSpaceFlag : 1; // Indicates whether the field ZoomSpeedSpace is valid uint32 Reserved : 24; onvif_Space2DDescription AbsolutePanTiltPositionSpace; // optional, The Generic Pan/Tilt Position space is provided by every PTZ node that supports absolute Pan/Tilt, since it does not relate to a specific physical range. // Instead, the range should be defined as the full range of the PTZ unit normalized to the range -1 to 1 resulting in the following space description onvif_Space1DDescription AbsoluteZoomPositionSpace; // optional, The Generic Zoom Position Space is provided by every PTZ node that supports absolute Zoom, since it does not relate to a specific physical range. // Instead, the range should be defined as the full range of the Zoom normalized to the range 0 (wide) to 1 (tele). // There is no assumption about how the generic zoom range is mapped to magnification, FOV or other physical zoom dimension onvif_Space2DDescription RelativePanTiltTranslationSpace;// optional, The Generic Pan/Tilt translation space is provided by every PTZ node that supports relative Pan/Tilt, since it does not relate to a specific physical range. // Instead, the range should be defined as the full positive and negative translation range of the PTZ unit normalized to the range -1 to 1, // where positive translation would mean clockwise rotation or movement in right/up direction resulting in the following space description onvif_Space1DDescription RelativeZoomTranslationSpace; // optional, The Generic Zoom Translation Space is provided by every PTZ node that supports relative Zoom, since it does not relate to a specific physical range. // Instead, the corresponding absolute range should be defined as the full positive and negative translation range of the Zoom normalized to the range -1 to1, // where a positive translation maps to a movement in TELE direction. The translation is signed to indicate direction (negative is to wide, positive is to tele). // There is no assumption about how the generic zoom range is mapped to magnification, FOV or other physical zoom dimension. This results in the following space description onvif_Space2DDescription ContinuousPanTiltVelocitySpace; // optional, The generic Pan/Tilt velocity space shall be provided by every PTZ node, since it does not relate to a specific physical range. // Instead, the range should be defined as a range of the PTZ unit's speed normalized to the range -1 to 1, where a positive velocity would map to clockwise // rotation or movement in the right/up direction. A signed speed can be independently specified for the pan and tilt component resulting in the following space description onvif_Space1DDescription ContinuousZoomVelocitySpace; // optional, The generic zoom velocity space specifies a zoom factor velocity without knowing the underlying physical model. The range should be normalized from -1 to 1, // where a positive velocity would map to TELE direction. A generic zoom velocity space description resembles the following onvif_Space1DDescription PanTiltSpeedSpace; // optional, The speed space specifies the speed for a Pan/Tilt movement when moving to an absolute position or to a relative translation. // In contrast to the velocity spaces, speed spaces do not contain any directional information. The speed of a combined Pan/Tilt // movement is represented by a single non-negative scalar value onvif_Space1DDescription ZoomSpeedSpace; // optional, The speed space specifies the speed for a Zoom movement when moving to an absolute position or to a relative translation. // In contrast to the velocity spaces, speed spaces do not contain any directional information } onvif_PTZSpaces; typedef struct { uint32 NameFlag : 1; // Indicates whether the field Name is valid uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 Reserved : 30; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // optional, A unique identifier that is used to reference PTZ Nodes onvif_PTZSpaces SupportedPTZSpaces; // required, A list of Coordinate Systems available for the PTZ Node. For each Coordinate System, the PTZ Node MUST specify its allowed range int MaximumNumberOfPresets; // required, All preset operations MUST be available for this PTZ Node if one preset is supported BOOL HomeSupported; // required, A boolean operator specifying the availability of a home position. If set to true, the Home Position Operations MUST be available for this PTZ Node onvif_PTZNodeExtension Extension; // optional BOOL FixedHomePosition; // optional, Indication whether the HomePosition of a Node is fixed or it can be changed via the SetHomePosition command BOOL GeoMove; // optional, Indication whether the Node supports the geo-referenced move command uint32 sizeAuxiliaryCommands; // sequence of elements char AuxiliaryCommands[10][64]; // optional } onvif_PTZNode; typedef struct { // Supported options for EFlip feature uint32 EFlipMode_OFF : 1; uint32 EFlipMode_ON : 1; uint32 EFlipMode_Extended : 1; // Supported options for Reverse feature uint32 ReverseMode_OFF : 1; uint32 ReverseMode_ON : 1; uint32 ReverseMode_AUTO : 1; uint32 ReverseMode_Extended : 1; uint32 Reserved : 25; } onvif_PTControlDirectionOptions; typedef struct { uint32 PTControlDirectionFlag : 1; // Indicates whether the field PTControlDirection is valid uint32 Reserved : 31; onvif_PTZSpaces Spaces; // required, onvif_IntRange PTZTimeout; // required, A timeout Range within which Timeouts are accepted by the PTZ Node onvif_PTControlDirectionOptions PTControlDirection; // optional, } onvif_PTZConfigurationOptions; typedef struct { uint32 PanTiltFlag : 1; // Indicates whether the field PanTilt is valid uint32 ZoomFlag : 1; // Indicates whether the field Zoom is valid uint32 Reserved : 30; onvif_MoveStatus PanTilt; // optional onvif_MoveStatus Zoom; // optional } onvif_PTZMoveStatus; typedef struct { uint32 PositionFlag : 1; // Indicates whether the field Position is valid uint32 MoveStatusFlag : 1; // Indicates whether the field MoveStatus is valid uint32 ErrorFlag : 1; // Indicates whether the field MoveStatus is valid uint32 Reserved : 29; onvif_PTZVector Position; // optional, Specifies the absolute position of the PTZ unit together with the Space references. The default absolute spaces of the corresponding PTZ configuration MUST be referenced within the Position element onvif_PTZMoveStatus MoveStatus; // optional, Indicates if the Pan/Tilt/Zoom device unit is currently moving, idle or in an unknown state char Error[100]; // optional, States a current PTZ error time_t UtcTime; // required, Specifies the UTC time when this status was generated } onvif_PTZStatus; typedef struct { uint32 PresetTokenFlag : 1; // Indicates whether the field PresetToken is valid uint32 HomeFlag : 1; // Indicates whether the field Home is valid uint32 PTZPositionFlag : 1; // Indicates whether the field PTZPosition is valid uint32 Reserved : 29; char PresetToken[ONVIF_TOKEN_LEN]; // optional, Option to specify the preset position with Preset Token defined in advance BOOL Home; // optional, Option to specify the preset position with the home position of this PTZ Node. "False" to this parameter shall be treated as an invalid argument onvif_PTZVector PTZPosition; // optional, Option to specify the preset position with vector of PTZ node directly } onvif_PTZPresetTourPresetDetail; typedef struct { uint32 SpeedFlag : 1; // Indicates whether the field Speed is valid uint32 StayTimeFlag : 1; // Indicates whether the field StayTime is valid uint32 Reserved : 30; onvif_PTZPresetTourPresetDetail PresetDetail; // required, Detail definition of preset position of the tour spot onvif_PTZSpeed Speed; // optional, Optional parameter to specify Pan/Tilt and Zoom speed on moving toward this tour spot int StayTime; // optional, Optional parameter to specify time duration of staying on this tour sport } onvif_PTZPresetTourSpot; typedef struct _PTZPresetTourSpotList { struct _PTZPresetTourSpotList * next; onvif_PTZPresetTourSpot PTZPresetTourSpot; } PTZPresetTourSpotList; typedef struct { uint32 CurrentTourSpotFlag : 1; // Indicates whether the field CurrentTourSpot is valid uint32 Reserved : 31; onvif_PTZPresetTourState State; // required, Indicates state of this preset tour by Idle/Touring/Paused onvif_PTZPresetTourSpot CurrentTourSpot; // optional, Indicates a tour spot currently staying } onvif_PTZPresetTourStatus; typedef struct { uint32 RecurringTimeFlag : 1; // Indicates whether the field RecurringTime is valid uint32 RecurringDurationFlag : 1; // Indicates whether the field RecurringDuration is valid uint32 DirectionFlag : 1; // Indicates whether the field Direction is valid uint32 RandomPresetOrderFlag : 1; // Indicates whether the field RandomPresetOrder is valid uint32 Reserved : 28; int RecurringTime; // optional, Optional parameter to specify how many times the preset tour is recurred int RecurringDuration; // optional, Optional parameter to specify how long time duration the preset tour is recurred onvif_PTZPresetTourDirection Direction; // optional, Optional parameter to choose which direction the preset tour goes. Forward shall be chosen in case it is omitted BOOL RandomPresetOrder; // optional, Execute presets in random order. If set to true and Direction is also present, Direction will be ignored and presets of the Tour will be recalled randomly } onvif_PTZPresetTourStartingCondition; typedef struct { char Name[ONVIF_NAME_LEN]; // optional, Readable name of the preset tour char token[ONVIF_TOKEN_LEN]; // required, Unique identifier of this preset tour BOOL AutoStart; // required, Auto Start flag of the preset tour. True allows the preset tour to be activated always onvif_PTZPresetTourStatus Status; // required, Read only parameters to indicate the status of the preset tour onvif_PTZPresetTourStartingCondition StartingCondition; // required, Parameters to specify the detail behavior of the preset tour PTZPresetTourSpotList * TourSpot; // optional, A list of detail of touring spots including preset positions } onvif_PresetTour; typedef struct { int Min; // required, unit is second int Max; // required, unit is second } onvif_DurationRange; typedef struct { uint32 RecurringTimeFlag : 1; // Indicates whether the field RecurringTime is valid uint32 RecurringDurationFlag : 1; // Indicates whether the field RecurringDuration is valid uint32 PTZPresetTourDirection_Forward : 1; // uint32 PTZPresetTourDirection_Backward : 1; // uint32 PTZPresetTourDirection_Extended : 1; // uint32 Reserved : 27; onvif_IntRange RecurringTime; // optional, Supported range of Recurring Time onvif_DurationRange RecurringDuration; // optional, Supported range of Recurring Duration } onvif_PTZPresetTourStartingConditionOptions; typedef struct { uint32 HomeFlag : 1; // Indicates whether the field Home is valid uint32 PanTiltPositionSpaceFlag : 1; // Indicates whether the field PanTiltPositionSpace is valid uint32 ZoomPositionSpaceFlag : 1; // Indicates whether the field ZoomPositionSpace is valid uint32 Reserved : 29; uint32 sizePresetToken; char PresetToken[MAX_PTZ_PRESETS][ONVIF_TOKEN_LEN]; // optional, A list of available Preset Tokens for tour spots BOOL Home; // optional, An option to indicate Home postion for tour spots onvif_Space2DDescription PanTiltPositionSpace; // optional, Supported range of Pan and Tilt for tour spots onvif_Space1DDescription ZoomPositionSpace; // optional, Supported range of Zoom for a tour spot } onvif_PTZPresetTourPresetDetailOptions; typedef struct { onvif_PTZPresetTourPresetDetailOptions PresetDetail; // required, Supported options for detail definition of preset position of the tour spot onvif_DurationRange StayTime; // required, Supported range of stay time for a tour spot } onvif_PTZPresetTourSpotOptions; typedef struct { BOOL AutoStart; // required, Indicates whether or not the AutoStart is supported onvif_PTZPresetTourStartingConditionOptions StartingCondition; // required, Supported options for Preset Tour Starting Condition onvif_PTZPresetTourSpotOptions TourSpot; // required, Supported options for Preset Tour Spot } onvif_PTZPresetTourOptions; typedef struct { uint32 NameFlag : 1; // Indicates whether the field Name is valid uint32 MTUFlag : 1; // Indicates whether the field MTU is valid uint32 Reserved : 30; char Name[ONVIF_NAME_LEN]; // optional, Network interface name, for example eth0 char HwAddress[32]; // required, Network interface MAC address int MTU; // optional, Maximum transmission unit } onvif_NetworkInterfaceInfo; typedef struct { char Address[32]; // required int PrefixLength; // required BOOL DHCP; // required, Indicates whether or not DHCP is used } onvif_IPv4Configuration; typedef struct { BOOL Enabled; // required, Indicates whether or not IPv4 is enabled onvif_IPv4Configuration Config; // required, IPv4 configuration } onvif_IPv4NetworkInterface; typedef struct { uint32 KeyFlag : 1; // Indicates whether the field Key is valid uint32 PassphraseFlag : 1; // Indicates whether the field Passphrase is valid uint32 Reserved : 30; char Key[256]; // optional, hexBinary, // According to IEEE802.11-2007 H.4.1 the RSNA PSK consists of 256 bits, // or 64 octets when represented in hex // Either Key or Passphrase shall be given, // if both are supplied Key shall be used by the device and Passphrase ignored. char Passphrase[128]; // optional, // According to IEEE802.11-2007 H.4.1 a pass-phrase is // a sequence of between 8 and 63 ASCII-encoded characters and // each character in the pass-phrase must have an encoding in the range of 32 to 126 (decimal),inclusive. // If only Passpharse is supplied the Key shall be derived using the algorithm described in // IEEE802.11-2007 section H.4 } onvif_Dot11PSKSet; typedef struct { uint32 AlgorithmFlag : 1; // Indicates whether the field Algorithm is valid uint32 PSKFlag : 1; // Indicates whether the field PSK is valid uint32 Dot1XFlag : 1; // // Indicates whether the field Dot1X is valid uint32 Reserved : 29; onvif_Dot11SecurityMode Mode; // required onvif_Dot11Cipher Algorithm; // optional onvif_Dot11PSKSet PSK; // optional char Dot1X[ONVIF_TOKEN_LEN]; // optional } onvif_Dot11SecurityConfiguration; typedef struct { char SSID[32]; // required, hexBinary onvif_Dot11StationMode Mode; // required char Alias[32]; // required int Priority; // required, range is 0-31 onvif_Dot11SecurityConfiguration Security; // required element of type ns2:Dot11SecurityConfiguration */ } onvif_Dot11Configuration; typedef struct { int InterfaceType; // required, tt:IANA-IfTypes, Integer indicating interface type, for example: 6 is ethernet // ieee80211(71) // For valid numbers, please refer to http://www.iana.org/assignments/ianaiftype-mib uint32 sizeDot11; // sequence of elements onvif_Dot11Configuration Dot11[4]; // optional } onvif_NetworkInterfaceExtension; typedef struct { uint32 InfoFlag : 1; // Indicates whether the field Info is valid uint32 IPv4Flag : 1; // Indicates whether the field IPv4 is valid uint32 ExtensionFlag : 1; // Indicates whether the field Extension is valid uint32 Reserved : 29; char token[ONVIF_TOKEN_LEN]; // required BOOL Enabled; // required, Indicates whether or not an interface is enabled onvif_NetworkInterfaceInfo Info; // optional, Network interface information onvif_IPv4NetworkInterface IPv4; // optional, IPv4 network interface configuration onvif_NetworkInterfaceExtension Extension; // optional, } onvif_NetworkInterface; typedef struct { BOOL HTTPFlag; // Indicates if the http protocol required BOOL HTTPEnabled; // Indicates if the http protocol is enabled or not BOOL HTTPSFlag; // Indicates if the https protocol required BOOL HTTPSEnabled; // Indicates if the https protocol is enabled or not BOOL RTSPFlag; // Indicates if the rtsp protocol required BOOL RTSPEnabled; // Indicates if the rtsp protocol is enabled or not int HTTPPort[MAX_SERVER_PORT]; // The port that is used by the protocol int HTTPSPort[MAX_SERVER_PORT]; // The port that is used by the protocol int RTSPPort[MAX_SERVER_PORT]; // The port that is used by the protocol } onvif_NetworkProtocol; typedef struct { uint32 SearchDomainFlag : 1; // Indicates whether the field SearchDomain is valid uint32 Reserved : 31; BOOL FromDHCP; // required, Indicates whether or not DNS information is retrieved from DHCP char SearchDomain[MAX_SEARCHDOMAIN][64]; // optional, Search domain char DNSServer[MAX_DNS_SERVER][32]; // required } onvif_DNSInformation; typedef struct { uint32 NameFlag : 1; // Indicates whether the field Name is valid uint32 TTLFlag : 1; // Indicates whether the field TTL is valid uint32 Reserved : 30; onvif_DynamicDNSType Type; // required, Dynamic DNS type char Name[ONVIF_NAME_LEN]; // optional, DNS name int TTL; // optional, DNS record time to live } onvif_DynamicDNSInformation; typedef struct { BOOL FromDHCP; // required, Indicates if NTP information is to be retrieved by using DHCP char NTPServer[MAX_NTP_SERVER][32]; // required } onvif_NTPInformation; typedef struct { uint32 NameFlag : 1; // Indicates whether the field Name is valid uint32 Reserved : 31; BOOL FromDHCP; // required, Indicates whether the hostname is obtained from DHCP or not BOOL RebootNeeded; // required, Indicates whether or not a reboot is required after configuration updates char Name[ONVIF_NAME_LEN]; // optional, Indicates the hostname } onvif_HostnameInformation; typedef struct { char IPv4Address[MAX_GATEWAY][32]; // required, IPv4 address string } onvif_NetworkGateway; typedef struct { char InterfaceToken[ONVIF_TOKEN_LEN]; // required, Unique identifier of network interface BOOL Enabled; // required, Indicates whether the zero-configuration is enabled or not uint32 sizeAddresses; // sequence of elements char Addresses[4][32]; // optional, The zero-configuration IPv4 address(es) } onvif_NetworkZeroConfiguration; typedef struct { char Uri[ONVIF_URI_LEN]; // required BOOL InvalidAfterConnect; // required BOOL InvalidAfterReboot; // required int Timeout; // required, unit is second } onvif_MediaUri; typedef struct { uint32 BSSIDFlag : 1; uint32 PairCipherFlag : 1; uint32 GroupCipherFlag : 1; uint32 SignalStrengthFlag : 1; uint32 Reserved : 28; char SSID[32]; // required, hexBinary char BSSID[64]; // optional onvif_Dot11Cipher PairCipher; // optional onvif_Dot11Cipher GroupCipher; // optional onvif_Dot11SignalStrength SignalStrength; // optional char ActiveConfigAlias[32]; // required } onvif_Dot11Status; typedef struct { uint32 BSSIDFlag : 1; uint32 SignalStrengthFlag : 1; uint32 Reserved : 30; char SSID[32]; // required, hexBinary char BSSID[64]; // optional uint32 sizeAuthAndMangementSuite; // sequence of elements onvif_Dot11AuthAndMangementSuite AuthAndMangementSuite[4]; // optional uint32 sizePairCipher; // sequence of elements onvif_Dot11Cipher PairCipher[4]; // optional uint32 sizeGroupCipher; // sequence of elements onvif_Dot11Cipher GroupCipher[4]; // optional onvif_Dot11SignalStrength SignalStrength; // optional } onvif_Dot11AvailableNetworks; typedef struct _Dot11AvailableNetworksList { struct _Dot11AvailableNetworksList * next; onvif_Dot11AvailableNetworks Networks; } Dot11AvailableNetworksList; typedef struct { char TZ[128]; // required, Posix timezone string } onvif_TimeZone; typedef struct { int Hour; // Range is 0 to 23 int Minute; // Range is 0 to 59 int Second; // Range is 0 to 61 (typically 59) } onvif_Time; typedef struct { int Year; // int Month; // Range is 1 to 12 int Day; // Range is 1 to 31 } onvif_Date; typedef struct { onvif_Time Time; // required onvif_Date Date; // required } onvif_DateTime; typedef struct { uint32 TimeZoneFlag : 1; // Indicates whether the field TimeZone is valid uint32 Reserved : 31; BOOL DaylightSavings; // required, Informative indicator whether daylight savings is currently on/off onvif_SetDateTimeType DateTimeType; // required, Indicates if the time is set manully or through NTP onvif_TimeZone TimeZone; // optional, Timezone information in Posix format } onvif_SystemDateTime; typedef struct { onvif_ScopeDefinition ScopeDef; // required char ScopeItem[128]; // required } onvif_Scope; typedef struct { uint32 lonFlag : 1; // Indicates whether the field lon is valid uint32 latFlag : 1; // Indicates whether the field lat is valid uint32 elevationFlag : 1; // Indicates whether the field elevation is valid uint32 Reserved : 29; double lon; // optional, East west location as angle double lat; // optional, North south location as angle float elevation; // optional, Hight in meters above sea level } onvif_GeoLocation; typedef struct { uint32 rollFlag : 1; // Indicates whether the field roll is valid uint32 pitchFlag : 1; // Indicates whether the field pitch is valid uint32 yawFlag : 1; // Indicates whether the field yaw is valid uint32 Reserved : 29; float roll; // optional, Rotation around the x axis float pitch; // optional, Rotation around the y axis float yaw; // optional, Rotation around the z axis } onvif_GeoOrientation; typedef struct { uint32 xFlag : 1; // Indicates whether the field x is valid uint32 yFlag : 1; // Indicates whether the field y is valid uint32 zFlag : 1; // Indicates whether the field z is valid uint32 Reserved : 29; float x; // optional, East west location as angle float y; // optional, North south location as angle float z; // optional, Offset in meters from the sea level } onvif_LocalLocation; typedef struct { uint32 panFlag : 1; // Indicates whether the field pan is valid uint32 tiltFlag : 1; // Indicates whether the field tilt is valid uint32 rollFlag : 1; // Indicates whether the field roll is valid uint32 Reserved : 29; float pan; // optional, Rotation around the y axis float tilt; // optional, Rotation around the z axis float roll; // optional, Rotation around the x axis } onvif_LocalOrientation; typedef struct { uint32 GeoLocationFlag : 1; // Indicates whether the field GeoLocation is valid uint32 GeoOrientationFlag : 1; // Indicates whether the field GeoOrientation is valid uint32 LocalLocationFlag : 1; // Indicates whether the field LocalLocation is valid uint32 LocalOrientationFlag : 1; // Indicates whether the field LocalOrientation is valid uint32 EntityFlag : 1; // Indicates whether the field Entity is valid uint32 TokenFlag : 1; // Indicates whether the field Token is valid uint32 FixedFlag : 1; // Indicates whether the field Fixed is valid uint32 GeoSourceFlag : 1; // Indicates whether the field GeoSource is valid uint32 AutoGeoFlag : 1; // Indicates whether the field AutoGeo is valid uint32 Reserved : 23; onvif_GeoLocation GeoLocation; // optional, Location on earth onvif_GeoOrientation GeoOrientation; // optional, Orientation relative to earth onvif_LocalLocation LocalLocation; // optional, Indoor location offset onvif_LocalOrientation LocalOrientation; // optional, Indoor orientation offset char Entity[200]; // optional, Entity type the entry refers to as defined in tds:Entity char Token[ONVIF_TOKEN_LEN]; // optional, Optional entity token BOOL Fixed; // optional, If this value is true the entity cannot be deleted char GeoSource[256]; // optional, Optional reference to the XAddr of another devices DeviceManagement service BOOL AutoGeo; // optional, If set the geo location is obtained internally } onvif_LocationEntity; typedef struct _LocationEntityList { struct _LocationEntityList * next; onvif_LocationEntity Location; } LocationEntityList; typedef struct { char * ptr; // required, need call free to free the buffer int size; // required, the ptr buffer length } onvif_base64Binary; typedef struct { uint32 contentTypeFlag : 1; // Indicates whether the field contentType is valid uint32 Reserved : 31; onvif_base64Binary Data; // required, base64 encoded binary data char contentType[100]; // optional } onvif_BinaryData; typedef struct { uint32 PasswordFlag : 1; // Indicates whether the field Password is valid uint32 Reserved : 31; char UserName[64]; // required, User name char Password[64]; // optional, optional password } onvif_UserCredential; typedef struct { uint32 LocalPathFlag : 1; // Indicates whether the field LocalPath is valid uint32 StorageUriFlag : 1; // Indicates whether the field StorageUri is valid uint32 UserFlag : 1; // Indicates whether the field User is valid uint32 RegionFlag : 1; // Indicates whether the field Region is valid uint32 Reserved : 28; char LocalPath[256]; // optional, local path char StorageUri[256]; // optional, Storage server address onvif_UserCredential User; // optional, User credential for the storage server char type[100]; // required, StorageType lists the acceptable values for type attribute // NFS, CIFS, CDMI, FTP, ObjectStorageS3, ObjectStorageAzure char Region[100]; // optinal, Optional region of the storage server } onvif_StorageConfigurationData; typedef struct { char token[ONVIF_TOKEN_LEN]; // required onvif_StorageConfigurationData Data; // required } onvif_StorageConfiguration; typedef struct _StorageConfigurationList { struct _StorageConfigurationList *next; onvif_StorageConfiguration Configuration; } StorageConfigurationList; typedef struct { onvif_TransportProtocol Protocol; // required, Defines the network protocol for streaming, either UDP=RTP/UDP, RTSP=RTP/RTSP/TCP or HTTP=RTP/RTSP/HTTP/TCP } onvif_Transport; typedef struct { onvif_StreamType Stream; // required, Defines if a multicast or unicast stream is requested onvif_Transport Transport; // required } onvif_StreamSetup; typedef struct { int SessionTimeout; // required, The RTSP session timeout, unit is second } onvif_ReplayConfiguration; typedef struct { char SourceId[128]; // required, Identifier for the source chosen by the client that creates the structure. // This identifier is opaque to the device. Clients may use any type of URI for this field. A device shall support at least 128 characters char Name[ONVIF_NAME_LEN]; // required, Informative user readable name of the source, e.g. "Camera23". A device shall support at least 20 characters char Location[100]; // required, Informative description of the physical location of the source, e.g. the coordinates on a map char Description[128]; // required, Informative description of the source char Address[128]; // required, URI provided by the service supplying data to be recorded. A device shall support at least 128 characters } onvif_RecordingSourceInformation; typedef struct { uint32 KeyFlag : 1; // Indicates whether the field Key is valid uint32 Reserved : 31; char KID[64]; // required, Key ID of the associated key for encryption char Key[1024]; // optional element of type xsd:hexBinary, Key for encrypting content.The device shall not include this parameter when reading uint32 sizeTrack; // sequence of elements char Track[4][32]; // optional, Optional list of track tokens to be encrypted // If no track tokens are specified, all tracks are encrypted and // no other encryption configurations shall exist for the recording. // Each track shall only be contained in one encryption configuration. char Mode[32]; // required, Mode of encryption. See tt:EncryptionMode for a list of definitions and capability trc:SupportedEncryptionModes for the supported encryption modes // CENC - AES-CTR mode full sample and video NAL Subsample encryption, defined in ISO/IEC 23001-7 // CBCS - AES-CBC mode partial video NAL pattern encryption, defined in ISO/IEC 23001-7 } onvif_RecordingEncryption; typedef struct { uint32 PrefixFlag : 1; // Indicates whether the field Prefix is valid uint32 PostfixFlag : 1; // Indicates whether the field Postfix is valid uint32 SpanDurationFlag : 1; // Indicates whether the field SpanDuration is valid uint32 SegmentDurationFlag : 1; // Indicates whether the field SegmentDuration is valid uint32 Reserved : 28; char Storage[ONVIF_TOKEN_LEN]; // required , Token of a storage configuration char Format[32]; // required , Format of the recording.See tt:TargetFormat for a list of definitions and capability trc:SupportedTargetFormats for the supported formats. // MP4 - MP4 files with all tracks in a single file // CMAF - CMAF compliant MP4 files with 1 track per file char Prefix[64]; // optional, Path prefix to be inserted in the object key char Postfix[64]; // optional, Path postfix to be inserted in the object key uint32 SpanDuration; // optional, Maximum duration of a span, unit is second uint32 SegmentDuration; // external, Maximum duration of a segment, unit is second uint32 sizeEncryption; // sequence of elements onvif_RecordingEncryption Encryption[4]; // optional, Optional encryption configuration. // See capability trc:EncryptionEntryLimit for the number of supported entries. // By specifying multiple encryption entries per recording, different tracks // can be encrypted with different configurations. // Each track shall only be contained in one encryption configuration. } onvif_RecordingTargetConfiguration; typedef struct { uint32 MaximumRetentionTimeFlag : 1; // Indicates whether the field MaximumRetentionTime is valid uint32 TargetFlag : 1; // Indicates whether the field Target is valid uint32 Reserved : 30; onvif_RecordingSourceInformation Source; // required, Information about the source of the recording char Content[256]; // required, Informative description of the source uint32 MaximumRetentionTime; // optional, specifies the maximum time that data in any track within the // recording shall be stored. The device shall delete any data older than the maximum retention // time. Such data shall not be accessible anymore. If the MaximumRetentionPeriod is set to 0, // the device shall not limit the retention time of stored data, except by resource constraints. // Whatever the value of MaximumRetentionTime, the device may automatically delete // recordings to free up storage space for new recordings. // unit is second onvif_RecordingTargetConfiguration Target; // optional, Optional external storage target configuration } onvif_RecordingConfiguration; typedef struct { onvif_TrackType TrackType; // required, Type of the track. It shall be equal to the strings "Video", "Audio" or "Metadata" char Description[100]; // required, Informative description of the track } onvif_TrackConfiguration; typedef struct { uint32 TypeFlag : 1; // Indicates whether the field Type is valid uint32 Reserved : 31; char Token[ONVIF_TOKEN_LEN]; // required, char Type[256]; // optional, default is "http://www.onvif.org/ver10/schema/Receiver", "http://www.onvif.org/ver10/schema/Profile" } onvif_SourceReference; typedef struct { char SourceTag[64]; // required, If the received RTSP stream contains multiple tracks of the same type, the // SourceTag differentiates between those Tracks. This field can be ignored in case of recording a local source char Destination[ONVIF_TOKEN_LEN]; // required, The destination is the tracktoken of the track to which the device shall store the received data } onvif_RecordingJobTrack; typedef struct { uint32 SourceTokenFlag : 1; // Indicates whether the field SourceToken is valid uint32 AutoCreateReceiverFlag : 1; // Indicates whether the field AutoCreateReceiver is valid uint32 Reserved : 30; onvif_SourceReference SourceToken; // optional, This field shall be a reference to the source of the data. The type of the source // is determined by the attribute Type in the SourceToken structure. If Type is // http://www.onvif.org/ver10/schema/Receiver, the token is a ReceiverReference. In this case // the device shall receive the data over the network. If Type is // http://www.onvif.org/ver10/schema/Profile, the token identifies a media profile, instructing the // device to obtain data from a profile that exists on the local device BOOL AutoCreateReceiver; // optional, If this field is TRUE, and if the SourceToken is omitted, the device // shall create a receiver object (through the receiver service) and assign the // ReceiverReference to the SourceToken field. When retrieving the RecordingJobConfiguration // from the device, the AutoCreateReceiver field shall never be present uint32 sizeTracks; onvif_RecordingJobTrack Tracks[5]; // optional, List of tracks associated with the recording } onvif_RecordingJobSource; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required, Identifies the recording to which this job shall store the received data char Mode[16]; // required, The mode of the job. If it is idle, nothing shall happen. If it is active, the device shall try to obtain data from the receivers. // A client shall use GetRecordingJobState to determine if data transfer is really taking place // The only valid values for Mode shall be "Idle" or "Active" int Priority; // required, This shall be a non-negative number. If there are multiple recording jobs that store data to // the same track, the device will only store the data for the recording job with the highest // priority. The priority is specified per recording job, but the device shall determine the priority // of each track individually. If there are two recording jobs with the same priority, the device // shall record the data corresponding to the recording job that was activated the latest uint32 sizeSource; onvif_RecordingJobSource Source[5]; // optional, Source of the recording char ScheduleToken[ONVIF_TOKEN_LEN]; // optional, This attribute adds an additional requirement for activating the recording job. // If this optional field is provided the job shall only record if the schedule exists and is active. } onvif_RecordingJobConfiguration; typedef struct { uint32 ErrorFlag : 1; // Indicates whether the field Error is valid uint32 Reserved : 31; char SourceTag[64]; // required, Identifies the track of the data source that provides the data char Destination[ONVIF_TOKEN_LEN]; // required, Indicates the destination track char Error[100]; // optional, Optionally holds an implementation defined string value that describes the error. The string should be in the English language char State[16]; // required, Provides the job state of the track. // The valid values of state shall be "Idle", "Active" and "Error". If state equals "Error", the Error field may be filled in with an implementation defined value } onvif_RecordingJobStateTrack; typedef struct { onvif_SourceReference SourceToken; // required, Identifies the data source of the recording job char State[16]; // required, Holds the aggregated state over all substructures of RecordingJobStateSource // Idle : All state values in sub-nodes are "Idle" // PartiallyActive : The state of some sub-nodes are "active" and some sub-nodes are "idle" // Active : The state of all sub-nodes is "Active" // Error : At least one of the sub-nodes has state "Error" uint32 sizeTrack; onvif_RecordingJobStateTrack Track[5]; // optional, } onvif_RecordingJobStateSource; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required, Identification of the recording that the recording job records to char State[16]; // required, Holds the aggregated state over the whole RecordingJobInformation structure // Idle : All state values in sub-nodes are "Idle" // PartiallyActive : The state of some sub-nodes are "active" and some sub-nodes are "idle" // Active : The state of all sub-nodes is "Active" // Error : At least one of the sub-nodes has state "Error" uint32 sizeSources; onvif_RecordingJobStateSource Sources[5]; // optional, Identifies the data source of the recording job } onvif_RecordingJobStateInformation; typedef struct { uint32 SpareFlag : 1; // Indicates whether the field Spare is valid uint32 CompatibleSourcesFlag : 1; // Indicates whether the field CompatibleSources is valid uint32 Reserved : 30; int Spare; // optional, Number of spare jobs that can be created for the recording char CompatibleSources[160]; // optional, A device that supports recording of a restricted set of Media Service Profiles returns the list of profiles that can be recorded on the given Recording } onvif_JobOptions; typedef struct { uint32 SpareTotalFlag : 1; // Indicates whether the field SpareTotal is valid uint32 SpareVideoFlag : 1; // Indicates whether the field SpareVideo is valid uint32 SpareAudioFlag : 1; // Indicates whether the field SpareAudio is valid uint32 SpareMetadataFlag : 1; // Indicates whether the field SpareMetadata is valid uint32 Reserved : 28; int SpareTotal; // optional, Total spare number of tracks that can be added to this recording int SpareVideo; // optional, Number of spare Video tracks that can be added to this recording int SpareAudio; // optional, Number of spare Aduio tracks that can be added to this recording int SpareMetadata; // optional, Number of spare Metadata tracks that can be added to this recording } onvif_TrackOptions; typedef struct { onvif_JobOptions Job; // required, onvif_TrackOptions Track; // required, } onvif_RecordingOptions; typedef struct { char TrackToken[ONVIF_TOKEN_LEN]; // required onvif_TrackConfiguration Configuration; // required } onvif_Track; typedef struct _TrackList { struct _TrackList * next; onvif_Track Track; } TrackList; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required onvif_RecordingConfiguration Configuration; // required TrackList * Tracks; } onvif_Recording; typedef struct { char JobToken[ONVIF_TOKEN_LEN]; // required onvif_RecordingJobConfiguration JobConfiguration; // required } onvif_RecordingJob; typedef struct { char Name[ONVIF_NAME_LEN]; // required, Item name char Value[ONVIF_TOKEN_LEN]; // required, Item value. The type is defined in the corresponding description } onvif_SimpleItem; typedef struct _SimpleItemList { struct _SimpleItemList * next; onvif_SimpleItem SimpleItem; // Value name pair as defined by the corresponding description } SimpleItemList; typedef struct { uint32 AnyFlag : 1; uint32 Reserverd : 31; char Name[ONVIF_NAME_LEN]; // required, Item name char * Any; // optional } onvif_ElementItem; typedef struct _ElementItemList { struct _ElementItemList * next; onvif_ElementItem ElementItem; // Value name pair as defined by the corresponding description } ElementItemList; typedef struct { SimpleItemList * SimpleItem; // optional ElementItemList * ElementItem; // optional } onvif_ItemList; typedef struct { uint32 PropertyOperationFlag : 1; // Indicates whether the field PropertyOperation is valid uint32 SourceFlag : 1; // Indicates whether the field Source is valid uint32 KeyFlag : 1; // Indicates whether the field Key is valid uint32 DataFlag : 1; // Indicates whether the field Data is valid uint32 Reserved : 28; time_t UtcTime; // required onvif_ItemList Source; // optional, Token value pairs that triggered this message. Typically only one item is present onvif_ItemList Key; // optional element of type tt:ItemList */ onvif_ItemList Data; // optional element of type tt:ItemList */ onvif_PropertyOperation PropertyOperation; // optional } onvif_Message; typedef struct { char ConsumerAddress[256]; // required, char ProducterAddress[256]; // required, char Dialect[256]; // required, char Topic[256]; // required, onvif_Message Message; // required } onvif_NotificationMessage; typedef struct { time_t DataFrom; // required, The earliest point in time where there is recorded data on the device time_t DataUntil; // required, The most recent point in time where there is recorded data on the device int NumberRecordings; // required, The device contains this many recordings } onvif_RecordingSummary; typedef struct { char TrackToken[ONVIF_TOKEN_LEN]; // required, onvif_TrackType TrackType; // required, Type of the track: "Video", "Audio" or "Metadata". // The track shall only be able to hold data of that type char Description[100]; // required, Informative description of the contents of the track time_t DataFrom; // required, The start date and time of the oldest recorded data in the track time_t DataTo; // required, The stop date and time of the newest recorded data in the track } onvif_TrackInformation; typedef struct { uint32 EarliestRecordingFlag : 1; // Indicates whether the field EarliestRecording is valid uint32 LatestRecordingFlag : 1; // Indicates whether the field LatestRecording is valid uint32 Reserved : 30; char RecordingToken[ONVIF_TOKEN_LEN]; // required, onvif_RecordingSourceInformation Source; // required, Information about the source of the recording time_t EarliestRecording; // optional, time_t LatestRecording; // optional, char Content[256]; // required, uint32 sizeTrack; onvif_TrackInformation Track[5]; // optional, Basic information about the track. Note that a track may represent a single contiguous time span or consist of multiple slices onvif_RecordingStatus RecordingStatus; // required, } onvif_RecordingInformation; typedef struct { uint32 BitrateFlag : 1; // Indicates whether the field Bitrate is valid uint32 Reserved : 31; int Bitrate; // optional, Average bitrate in kbps int Width; // required, The width of the video in pixels int Height; // required, The height of the video in pixels onvif_VideoEncoding Encoding; // required, Used video codec, either Jpeg, H.264 or Mpeg4 float Framerate; // required, Average framerate in frames per second } onvif_VideoAttributes; typedef struct { uint32 BitrateFlag : 1; // Indicates whether the field Bitrate is valid uint32 Reserved : 31; int Bitrate; // optional, The bitrate in kbps onvif_AudioEncoding Encoding; // required, Audio codec used for encoding the audio (either G.711, G.726 or AAC) int Samplerate; // required, The sample rate in kHz } onvif_AudioAttributes; typedef struct { uint32 PtzSpacesFlag : 1; // Indicates whether the field PtzSpaces is valid uint32 Reserved : 31; BOOL CanContainPTZ; // required, Indicates that there can be PTZ data in the metadata track in the specified time interval BOOL CanContainAnalytics; // required, Indicates that there can be analytics data in the metadata track in the specified time interval BOOL CanContainNotifications; // required, Indicates that there can be notifications in the metadata track in the specified time interval char PtzSpaces[256]; // optional, List of all PTZ spaces active for recording. Note that events are only recorded on position changes and // the actual point of recording may not necessarily contain an event of the specified type } onvif_MetadataAttributes; typedef struct { uint32 VideoAttributesFlag : 1; // Indicates whether the field VideoAttributes is valid uint32 AudioAttributesFlag : 1; // Indicates whether the field AudioAttributes is valid uint32 MetadataAttributesFlag : 1; // Indicates whether the field MetadataAttributes is valid uint32 Reserved : 29; onvif_TrackInformation TrackInformation; // required, The basic information about the track. Note that a track may represent a single contiguous time span or consist of multiple slices onvif_VideoAttributes VideoAttributes; // optional, If the track is a video track, exactly one of this structure shall be present and contain the video attributes onvif_AudioAttributes AudioAttributes; // optional, If the track is an audio track, exactly one of this structure shall be present and contain the audio attributes onvif_MetadataAttributes MetadataAttributes; // optional, If the track is an metadata track, exactly one of this structure shall be present and contain the metadata attributes } onvif_TrackAttributes; typedef struct _TrackAttributesList { struct _TrackAttributesList * next; onvif_TrackAttributes TrackAttributes; } TrackAttributesList; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required, A reference to the recording that has these attributes uint32 sizeTrackAttributes; onvif_TrackAttributes TrackAttributes[5]; // optional, A set of attributes for each track time_t From; // required, The attributes are valid from this point in time in the recording time_t Until; // required, The attributes are valid until this point in time in the recording. // Can be equal to 'From' to indicate that the attributes are only known to be valid for this particular point in time } onvif_MediaAttributes; typedef struct { char StorageToken[ONVIF_TOKEN_LEN]; // required, char RelativePath[256]; // optional, } onvif_StorageReferencePath; typedef struct { char FileName[256]; // required, Exported file name float Progress; // required, Normalized percentage completion for uploading the exported file } onvif_FileProgress; typedef struct { uint32 sizeFileProgress; // sequence of elements onvif_FileProgress FileProgress[100]; // optional, Exported file name and export progress information } onvif_ArrayOfFileProgress; typedef struct { uint32 RecordingInformationFilterFlag : 1; // Indicates whether the field RecordingInformationFilter is valid uint32 Reserved : 31; int sizeIncludedSources; onvif_SourceReference IncludedSources[10]; // optional, A list of sources that are included in the scope. If this list is included, only data from one of these sources shall be searched int sizeIncludedRecordings; char IncludedRecordings[10][ONVIF_TOKEN_LEN]; // optional, A list of recordings that are included in the scope. If this list is included, only data from one of these recordings shall be searched char RecordingInformationFilter[128]; // optional, An xpath expression used to specify what recordings to search. // Only those recordings with an RecordingInformation structure that matches the filter shall be searched } onvif_SearchScope; typedef struct { onvif_PTZVector MinPosition; // required, onvif_PTZVector MaxPosition; // required, BOOL EnterOrExit; // required, } onvif_PTZPositionFilter; typedef struct { char MetadataStreamFilter[100]; // required } onvif_MetadataFilter; typedef struct _RecordingInformationList { struct _RecordingInformationList * next; onvif_RecordingInformation RecordingInformation; } RecordingInformationList; typedef struct { onvif_SearchState SearchState; // required, The state of the search when the result is returned. Indicates if there can be more results, or if the search is completed RecordingInformationList * RecordInformation; // optional, A RecordingInformation structure for each found recording matching the search } onvif_FindRecordingResultList; typedef struct { char Address[128]; // required, } onvif_EndpointReferenceType; typedef struct { char Dialect[128]; // required, char Topic[128]; // required, } onvif_TopicExpressionType; typedef struct { uint32 SubscriptionReferenceFlag : 1; // Indicates whether the field SubscriptionReference is valid uint32 TopicFlag : 1; // Indicates whether the field Topic is valid uint32 ProducerReferenceFlag : 1; // Indicates whether the field ProducerReference is valid uint32 Reserved : 31; onvif_EndpointReferenceType SubscriptionReference; // optional, onvif_TopicExpressionType Topic; // optional, onvif_EndpointReferenceType ProducerReference; // optional, onvif_Message Message; // required } onvif_NotificationMessageHolderType; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required, The recording where this event was found. Empty string if no recording is associated with this event char TrackToken[ONVIF_TOKEN_LEN]; // required, A reference to the track where this event was found. Empty string if no track is associated with this event time_t Time; // required, The time when the event occured onvif_NotificationMessageHolderType Event; // required, The description of the event BOOL StartStateEvent; // required, If true, indicates that the event is a virtual event generated for this particular search session to give the state of a property at the start time of the search } onvif_FindEventResult; typedef struct _FindEventResultList { struct _FindEventResultList * next; onvif_FindEventResult Result; } FindEventResultList; typedef struct { onvif_SearchState SearchState; // required, The state of the search when the result is returned. Indicates if there can be more results, or if the search is completed FindEventResultList * Result; // optional } onvif_FindEventResultList; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required, The recording where this event was found. Empty string if no recording is associated with this event char TrackToken[ONVIF_TOKEN_LEN]; // required, A reference to the track where this event was found. Empty string if no track is associated with this event time_t Time; // required, The time when the event occured } onvif_FindMetadataResult; typedef struct _FindMetadataResultList { struct _FindMetadataResultList * next; onvif_FindMetadataResult Result; } FindMetadataResultList; typedef struct { onvif_SearchState SearchState; // required, The state of the search when the result is returned. Indicates if there can be more results, or if the search is completed FindMetadataResultList * Result; // optional } onvif_FindMetadataResultList; typedef struct { char RecordingToken[ONVIF_TOKEN_LEN]; // required char TrackToken[ONVIF_TOKEN_LEN]; // required time_t Time; // required onvif_PTZVector Position; // required } onvif_FindPTZPositionResult; typedef struct _FindPTZPositionResultList { struct _FindPTZPositionResultList * next; onvif_FindPTZPositionResult Result; } FindPTZPositionResultList; typedef struct { onvif_SearchState SearchState; // required, The state of the search when the result is returned. Indicates if there can be more results, or if the search is completed FindPTZPositionResultList * Result; // optional } onvif_FindPTZPositionResultList; ////////////////////////////////////////////////////////////////////////// // Video analytics struct defines ////////////////////////////////////////////////////////////////////////// typedef struct { uint32 attrFlag : 1; uint32 reserved : 31; onvif_ItemList Parameters; // required char Name[ONVIF_NAME_LEN]; // required char Type[100]; // required char attr[256]; } onvif_Config; typedef struct _ConfigList { struct _ConfigList * next; onvif_Config Config; } ConfigList; typedef struct { ConfigList * AnalyticsModule; // optional } onvif_AnalyticsEngineConfiguration; typedef struct { ConfigList * Rule; // optional } onvif_RuleEngineConfiguration; typedef struct { char Name[ONVIF_NAME_LEN]; // required int UseCount; // required char token[ONVIF_TOKEN_LEN]; // required onvif_AnalyticsEngineConfiguration AnalyticsEngineConfiguration; // required onvif_RuleEngineConfiguration RuleEngineConfiguration; // required } onvif_VideoAnalyticsConfiguration; typedef struct { char Name[ONVIF_NAME_LEN]; // required char Type[100]; // required } onvif_SimpleItemDescription; typedef struct _SimpleItemDescriptionList { struct _SimpleItemDescriptionList * next; onvif_SimpleItemDescription SimpleItemDescription; } SimpleItemDescriptionList; typedef struct { SimpleItemDescriptionList * SimpleItemDescription; SimpleItemDescriptionList * ElementItemDescription; } onvif_ItemListDescription; typedef struct { uint32 SourceFlag : 1; // Indicates whether the field Source is valid uint32 KeyFlag : 1; // Indicates whether the field Source is valid uint32 DataFlag : 1; // Indicates whether the field Source is valid uint32 IsPropertyFlag : 1; // Indicates whether the field Source is valid uint32 Reserved : 28; onvif_ItemListDescription Source; // optional onvif_ItemListDescription Key; // optional onvif_ItemListDescription Data; // optional BOOL IsProperty; // optional char ParentTopic[100]; // required } onvif_ConfigDescription_Messages; typedef struct _ConfigDescription_MessagesList { struct _ConfigDescription_MessagesList * next; onvif_ConfigDescription_Messages Messages; } ConfigDescription_MessagesList; typedef struct { uint32 fixedFlag : 1; // Indicates whether the field fixed is valid uint32 maxInstancesFlag : 1; // Indicates whether the field maxInstances is valid uint32 Reserved : 30; onvif_ItemListDescription Parameters; // required ConfigDescription_MessagesList * Messages; char Name[ONVIF_NAME_LEN]; // required, The Name attribute (e.g. "tt::LineDetector") uniquely identifies the type of rule, not a type definition in a schema BOOL fixed; // optional, The fixed attribute signals that it is not allowed to add or remove this type of configuration int maxInstances; // optional, The maxInstances attribute signals the maximum number of instances per configuration } onvif_ConfigDescription; typedef struct { uint32 RuleTypeFlag : 1; // Indicates whether the field RuleType is valid uint32 AnalyticsModuleFlag : 1; // Indicates whether the field AnalyticsModule is valid uint32 Reserved : 30; char RuleType[100]; // optional, The RuleType the ConfigOptions applies to if the Name attribute is ambiguous. char Name[ONVIF_NAME_LEN]; // required, The Name of the SimpleItemDescription/ElementItemDescription // the ConfigOptions applies to char Type[100]; // required, Type of the Rule Options represented by a unique QName. // The Type defines the element contained in this structure char AnalyticsModule[100]; // optional, Optional name of the analytics module this constraint applies to. // This option is only necessary in cases where different constraints for elements with the same Name exist. char * any; } onvif_ConfigOptions; typedef struct _ConfigOptionsList { struct _ConfigOptionsList * next; onvif_ConfigOptions Options; } ConfigOptionsList; typedef struct _ConfigDescriptionList { struct _ConfigDescriptionList * next; onvif_ConfigDescription ConfigDescription; } ConfigDescriptionList; typedef struct { uint32 LimitFlag : 1; // Indicates whether the field Limit is valid uint32 Reserved : 31; uint32 sizeRuleContentSchemaLocation; char RuleContentSchemaLocation[10][256]; // optional, Lists the location of all schemas that are referenced in the rules ConfigDescriptionList * RuleDescription; // List of rules supported by the Video Analytics configuration int Limit; // optional, Maximum number of concurrent instances } onvif_SupportedRules; typedef struct { uint32 sizeAnalyticsModuleContentSchemaLocation; // sequence of elements char AnalyticsModuleContentSchemaLocation[10][128]; // It optionally contains a list of URLs that provide the location of schema files // These schema files describe the types and elements used in the analytics module descriptions. // If the analytics module descriptions reference types or elements of the ONVIF schema file, // the ONVIF schema file MUST be explicitly listed ConfigDescriptionList * AnalyticsModuleDescription; // optional, } onvif_SupportedAnalyticsModules; typedef struct { char Type[128]; // required, Type of the Analytics Module Options represented by a unique QName. // The Type defines the element contained in this structure } onvif_AnalyticsModuleConfigOptions; typedef struct _AnalyticsModuleConfigOptionsList { struct _AnalyticsModuleConfigOptionsList * next; onvif_AnalyticsModuleConfigOptions Options; } AnalyticsModuleConfigOptionsList; typedef struct { char Dialect[128]; char Expression[256]; } onvif_EventFilterItem; typedef struct { int sizeTopicExpression; int sizeMessageContent; onvif_EventFilterItem TopicExpression[5]; onvif_EventFilterItem MessageContent[5]; } onvif_EventFilter; typedef struct { uint32 AnalyticsFlag : 1; // Indicates whether the field Analytics is valid uint32 PTZStatusFlag : 1; // Indicates whether the field PTZStatus is valid uint32 EventsFlag : 1; // Indicates whether the field Events is valid uint32 CompressionTypeFlag : 1; // Indicates whether the field CompressionType is valid uint32 AnalyticsEngineConfigurationFlag : 1; // Indicates whether the field AnalyticsEngineConfiguration is valid uint32 GeoLocation : 1; // Optional parameter to configure if the metadata stream shall contain the Geo Location coordinates of each target uint32 ShapePolygon : 1; // Optional parameter to configure if the generated metadata stream should contain shape information as polygon uint32 Reserved : 25; char Name[ONVIF_NAME_LEN]; // required , User readable name. Length up to 64 characters int UseCount; // required, Number of internal references currently using this configuration. This parameter is read-only and cannot be changed by a set request char token[ONVIF_TOKEN_LEN]; // required, Token that uniquely refernces this configuration. Length up to 64 characters BOOL Analytics; // optional, Defines whether the streamed metadata will include metadata from the analytics engines (video, cell motion, audio etc.) int SessionTimeout; // required, The rtsp session timeout for the related audio stream, unit is second char CompressionType[100]; // optional, Optional parameter to configure compression type of Metadata payload. Use values from enumeration MetadataCompressionType // None,GZIP,EXI onvif_PTZFilter PTZStatus; // optional, optional element to configure which PTZ related data is to include in the metadata stream onvif_EventSubscription Events; // optional, Optional element to configure the streaming of events. A client might be interested in receiving all, // none or some of the events produced by the device: // To get all events: Include the Events element but do not include a filter. // To get no events: Do not include the Events element. // To get only some events: Include the Events element and include a filter in the element. onvif_MulticastConfiguration Multicast; // required, defines the multicast settings that could be used for video streaming onvif_AnalyticsEngineConfiguration AnalyticsEngineConfiguration; //optional, Defines whether the streamed metadata will include metadata from the analytics engines (video, cell motion, audio etc.) } onvif_MetadataConfiguration; typedef struct { uint32 attrFlag : 1; uint32 reserved : 31; char Type[128]; // required, Reference to an AnalyticsModule Type char attr[256]; char * Frame; // required, Sample frame content starting with the tt:Frame node } onvif_MetadataInfo; typedef struct _MetadataInfoList { struct _MetadataInfoList * next; onvif_MetadataInfo MetadataInfo; } MetadataInfoList; // PROFILE C Define Begin /** * The AccessPoint capabilities reflect optional functionality of a particular physical entity. * Different AccessPoint instances may have different set of capabilities. * This information maychange during device operation, e.g. if hardware settings are changed. */ typedef struct { uint32 DisableAccessPoint : 1; // required, Indicates whether or not this AccessPoint instance supports EnableAccessPoint and DisableAccessPoint commands uint32 Duress : 1; // optional, Indicates whether or not this AccessPoint instance supports generation of duress events uint32 AnonymousAccess : 1; // optional, Indicates whether or not this AccessPoint has a REX switch or other input that allows anonymous access uint32 AccessTaken : 1; // optional, Indicates whether or not this AccessPoint instance supports generation of AccessTaken and AccessNotTaken events. // If AnonymousAccess and AccessTaken are both true, it indicates that the Anonymous versions of AccessTaken and AccessNotTaken are supported uint32 ExternalAuthorization : 1; // optional, Indicates whether or not this AccessPoint instance supports the ExternalAuthorization operation and the generation of Request events. // If AnonymousAccess and ExternalAuthorization are both true, it indicates that the Anonymous version is supported as well uint32 IdentifierAccess : 1; // optional, Indicates whether or not this access point supports the AccessControl/Request/Identifier // event to request external authorization. uint32 SupportedRecognitionTypesFlag : 1; // Indicates whether the field SupportedRecognitionTypes is valid uint32 SupportedFeedbackTypesFlag : 1; // Indicates whether the field SupportedFeedbackTypes is valid uint32 Reserved : 24; char SupportedRecognitionTypes[200]; // optional, A list of recognition types that the device supports char SupportedFeedbackTypes[200]; // optional, List of supported feedback types } onvif_AccessPointCapabilities; /** * The AccessPointInfo structure contains basic information about an AccessPoint instance. * An AccessPoint defines an entity a Credential can be granted or denied access to. * TheAccessPointInfo provides basic information on how access is controlled in one direction for adoor (from which area to which area). * door is the typical device involved, but other type ofdevices may be supported as well. * Multiple AccessPoints may cover the same Door.A typical case is one AccessPoint for entry and another for exit, both referencingthe same Door. * An ONVIF compliant device shall provide the following fields for each AccessPoint instance */ typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 AreaFromFlag : 1; // Indicates whether the field AreaFrom is valid uint32 AreaToFlag : 1; // Indicates whether the field AreaTo is valid uint32 EntityTypeFlag : 1; // Indicates whether the field EntityType is valid uint32 EntityTypeAttrFlag : 1; // Indicates whether the field EntityTypeAttr is valid uint32 Reserved : 27; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, Optional user readable description for the AccessPoint. It shall be up to 1024 characters char AreaFrom[ONVIF_TOKEN_LEN]; // optional, Optional reference to the Area from which access is requested char AreaTo[ONVIF_TOKEN_LEN]; // optional, Optional reference to the Area to which access is requested char EntityType[100]; // optional, Optional entity type; if missing, a Door type as defined by the ONVIF DoorControl service should be assumed. // This can also be represented by the QName value "tdc:Door" - where tdc is the namespace of the Door Control service. // This field is provided for future extensions; it will allow an AccessPoint being extended to cover entity types other than Doors as well char EntityTypeAttr[256]; char Entity[ONVIF_TOKEN_LEN]; // required, Reference to the entity used to control access; the entity type may be specified by the optional EntityType field explained below but is typically a Door onvif_AccessPointCapabilities Capabilities; // required, The capabilities for the AccessPoint } onvif_AccessPointInfo; typedef struct _AccessPointList { struct _AccessPointList * next; uint32 Enabled : 1; // Indicates that the AccessPoint is enabled. By default this field value shall be True, if the DisableAccessPoint capabilities is not supported uint32 AuthenticationProfileTokenFlag : 1; // Indicates whether the field AuthenticationProfileToken is valid uint32 Reserved : 30; onvif_AccessPointInfo AccessPointInfo; char AuthenticationProfileToken[ONVIF_TOKEN_LEN]; // A reference to an authentication profile which defines the authentication behavior of the access point } AccessPointList; /** * DoorCapabilities reflect optional functionality of a particular physical entity. * Different door instances may have different set of capabilities. * This information may change during device operation, e.g. if hardware settings are changed */ typedef struct { BOOL Access; // optional, Indicates whether or not this Door instance supports AccessDoor command to perform momentary access BOOL AccessTimingOverride; // optional, Indicates that this Door instance supports overriding configured timing in the AccessDoor command BOOL Lock; // optional, Indicates that this Door instance supports LockDoor command to lock the door BOOL Unlock; // optional, Indicates that this Door instance supports UnlockDoor command to unlock the door BOOL Block; // optional, Indicates that this Door instance supports BlockDoor command to block the door BOOL DoubleLock; // optional, Indicates that this Door instance supports DoubleLockDoor command to lock multiple locks on the door BOOL LockDown; // optional, Indicates that this Door instance supports LockDown (and LockDownRelease) commands to lock the door and put it in LockedDown mode BOOL LockOpen; // optional, Indicates that this Door instance supports LockOpen (and LockOpenRelease) commands to unlock the door and put it in LockedOpen mode BOOL DoorMonitor; // optional, Indicates that this Door instance has a DoorMonitor and supports the DoorPhysicalState event BOOL LockMonitor; // optional, Indicates that this Door instance has a LockMonitor and supports the LockPhysicalState event BOOL DoubleLockMonitor; // optional, Indicates that this Door instance has a DoubleLockMonitor and supports the DoubleLockPhysicalState event BOOL Alarm; // optional, Indicates that this Door instance supports door alarm and the DoorAlarm event BOOL Tamper; // optional, Indicates that this Door instance has a Tamper detector and supports the DoorTamper event BOOL Fault; // optional, Indicates that this Door instance supports door fault and the DoorFault event } onvif_DoorCapabilities; // Tampering information for a Door typedef struct { uint32 ReasonFlag : 1; // Indicates whether the field Reason is valid uint32 Reserved : 31; char Reason[100]; // optional, Optional field; Details describing tampering state change (e.g., reason, place and time). // NOTE: All fields (including this one) which are designed to give end-user prompts can be localized to the customers's native language onvif_DoorTamperState State; // required, State of the tamper detector } onvif_DoorTamper; // Fault information for a Door typedef struct { uint32 ReasonFlag : 1; // Indicates whether the field Reason is valid uint32 Reserved : 31; char Reason[100]; // optional, Optional reason for fault onvif_DoorFaultState State; // required, Overall fault state for the door; it is of type DoorFaultState. If there are any faults, the value shall be: FaultDetected. // Details of the detected fault shall be found in the Reason field, and/or the various DoorState fields and/or in extensions to this structure } onvif_DoorFault; // The DoorState structure contains current aggregate runtime status of Door typedef struct { uint32 DoorPhysicalStateFlag : 1; // Indicates whether the field DoorPhysicalState is valid uint32 LockPhysicalStateFlag : 1; // Indicates whether the field LockPhysicalState is valid uint32 DoubleLockPhysicalStateFlag : 1; // Indicates whether the field DoubleLockPhysicalState is valid uint32 AlarmFlag : 1; // Indicates whether the field Alarm is valid uint32 TamperFlag : 1; // Indicates whether the field Tamper is valid uint32 FaultFlag : 1; // Indicates whether the field Fault is valid uint32 Reserved : 26; onvif_DoorPhysicalState DoorPhysicalState; // optional, Physical state of Door; it is of type DoorPhysicalState. // A device that signals support for DoorMonitor capability for a particular door instance shall provide this field onvif_LockPhysicalState LockPhysicalState; // optional, Physical state of the Lock; it is of type LockPhysicalState. // A device that signals support for LockMonitor capability for a particular door instance shall provide this field onvif_LockPhysicalState DoubleLockPhysicalState; // optional, Physical state of the DoubleLock; it is of type LockPhysicalState. // A device that signals support for DoubleLockMonitor capability for a particular door instance shall provide this field onvif_DoorAlarmState Alarm; // optional, Alarm state of the door; it is of type DoorAlarmState. // A device that signals support for Alarm capability for a particular door instance shall provide this field onvif_DoorTamper Tamper; // optional, Tampering state of the door; it is of type DoorTamper. // A device that signals support for Tamper capability for a particular door instance shall provide this field onvif_DoorFault Fault; // optional, Fault information for door; it is of type DoorFault. // A device that signals support for Fault capability for a particular door instance shall provide this field onvif_DoorMode DoorMode; // required, The logical operating mode of the door; it is of type DoorMode. An ONVIF compatible device shall report current operating mode in this field } onvif_DoorState; typedef struct { uint32 ExtendedReleaseTimeFlag : 1; // Indicates whether the field ExtendedReleaseTime is valid uint32 DelayTimeBeforeRelockFlag : 1; // Indicates whether the field DelayTimeBeforeRelock is valid uint32 ExtendedOpenTimeFlag : 1; // Indicates whether the field ExtendedOpenTime is valid uint32 PreAlarmTimeFlag : 1; // Indicates whether the field PreAlarmTime is valid uint32 Reserved : 28; uint32 ReleaseTime; // external, When access is granted (door mode becomes Accessed), the latch is unlocked. // ReleaseTime is the time from when the latch is unlocked until it is // relocked again (unless the door is physically opened), unit is second uint32 OpenTime; // external, The time from when the door is physically opened until the door is set in the // DoorOpenTooLong alarm state, unit is second uint32 ExtendedReleaseTime; // optional, Some individuals need extra time to open the door before the latch relocks. // If supported, ExtendedReleaseTime shall be added to ReleaseTime if UseExtendedTime // is set to true in the AccessDoor command, unit is second uint32 DelayTimeBeforeRelock; // optional, If the door is physically opened after access is granted, then DelayTimeBeforeRelock is the time from when the door is physically // opened until the latch goes back to locked state, unit is second uint32 ExtendedOpenTime; // optional, Some individuals need extra time to pass through the door. If supported, // ExtendedOpenTime shall be added to OpenTime if UseExtendedTime // is set to true in the AccessDoor command. unit is second uint32 PreAlarmTime; // optional, Before a DoorOpenTooLong alarm state is generated, a signal will sound to indicate that the door must be closed. // PreAlarmTime defines how long before DoorOpenTooLong the warning signal shall sound, unit is second } onvif_Timings; /** * The DoorInfo type represents the Door as a physical object. * The structure contains information and capabilities of a specific door instance */ typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, A user readable description. It shall be up to 1024 characters onvif_DoorCapabilities Capabilities; // required, The capabilities of the Door } onvif_DoorInfo; typedef struct _DoorInfoList { struct _DoorInfoList * next; onvif_DoorInfo DoorInfo; } DoorInfoList; typedef struct { onvif_DoorInfo DoorInfo; // Door information char DoorType[64]; // required, The type of door. Is of type text. Can be either one of the following reserved ONVIF types: // "pt:Door", "pt:ManTrap", "pt:Turnstile", "pt:RevolvingDoor", // "pt:Barrier", or a custom defined type onvif_Timings Timings; // required, A structure defining times such as how long the door is unlocked when accessed, extended grant time, etc. } onvif_Door; typedef struct _DoorList { struct _DoorList * next; onvif_Door Door; } DoorList; /** * The AreaInfo structure contains basic information about an Area */ typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, A user readable description. It shall be up to 1024 characters } onvif_AreaInfo; typedef struct _AreaList { struct _AreaList * next; onvif_AreaInfo AreaInfo; } AreaList; // PROFILE C Define End // DEVICEIO Define Begin // A pane layout describes one Video window of a display. It links a pane configuration to a region of the screen typedef struct { char Pane[ONVIF_TOKEN_LEN]; // required, Reference to the configuration of the streaming and coding parameters onvif_Rectangle Area; // required, Describes the location and size of the area on the monitor. // The area coordinate values are espressed in normalized units [-1.0, 1.0] } onvif_PaneLayout; typedef struct _PaneLayoutList { struct _PaneLayoutList * next; onvif_PaneLayout PaneLayout; // required } PaneLayoutList; // A layout describes a set of Video windows that are displayed simultaniously on a display typedef struct { PaneLayoutList * PaneLayout; // required, List of panes assembling the display layout } onvif_Layout; // Representation of a physical video outputs typedef struct { uint32 ResolutionFlag : 1; // Indicates whether the field Resolution is valid uint32 RefreshRateFlag : 1; // Indicates whether the field RefreshRate is valid uint32 AspectRatioFlag : 1; // Indicates whether the field AspectRatio is valid uint32 Reserved : 29; char token[ONVIF_TOKEN_LEN]; // required, onvif_Layout Layout; // required, onvif_VideoResolution Resolution; // optional, Resolution of the display in Pixel float RefreshRate; // optional, Refresh rate of the display in Hertz float AspectRatio; // optional, Aspect ratio of the display as physical extent of width divided by height } onvif_VideoOutput; typedef struct _VideoOutputList { struct _VideoOutputList * next; onvif_VideoOutput VideoOutput; } VideoOutputList; typedef struct { char Name[ONVIF_NAME_LEN]; // required int UseCount; // required char token[ONVIF_TOKEN_LEN]; // required char OutputToken[ONVIF_TOKEN_LEN]; // required } onvif_VideoOutputConfiguration; typedef struct _VideoOutputConfigurationList { struct _VideoOutputConfigurationList * next; onvif_VideoOutputConfiguration Configuration; } VideoOutputConfigurationList; typedef struct { char token[ONVIF_TOKEN_LEN]; // required, } onvif_AudioOutput; typedef struct _AudioOutputList { struct _AudioOutputList * next; onvif_AudioOutput AudioOutput; } AudioOutputList; typedef struct { uint32 sizeOutputTokensAvailable; char OutputTokensAvailable[5][ONVIF_TOKEN_LEN]; // required, Tokens of the physical Audio outputs (typically one) uint32 sizeSendPrimacyOptions; char SendPrimacyOptions[5][100]; // optional, The following modes for the Send-Primacy are defined: // www.onvif.org/ver20/HalfDuplex/Server // www.onvif.org/ver20/HalfDuplex/Client // www.onvif.org/ver20/HalfDuplex/Auto onvif_IntRange OutputLevelRange; // required, Minimum and maximum level range supported for this Output } onvif_AudioOutputConfigurationOptions; typedef struct { uint32 SendPrimacyFlag : 1; // Indicates whether the field SendPrimacy is valid uint32 Reserved : 31; char Name[ONVIF_NAME_LEN]; // required, int UseCount; // required, char token[ONVIF_TOKEN_LEN]; // required, char OutputToken[ONVIF_TOKEN_LEN]; // required, Token of the phsycial Audio output char SendPrimacy[100]; // optional, The following modes for the Send-Primacy are defined: // www.onvif.org/ver20/HalfDuplex/Server // www.onvif.org/ver20/HalfDuplex/Client // www.onvif.org/ver20/HalfDuplex/Auto int OutputLevel; // required, Volume setting of the output. The applicable range is defined via the option AudioOutputOptions.OutputLevelRange } onvif_AudioOutputConfiguration; typedef struct _AudioOutputConfigurationList { struct _AudioOutputConfigurationList * next; onvif_AudioOutputConfigurationOptions Options; onvif_AudioOutputConfiguration Configuration; } AudioOutputConfigurationList; typedef struct { onvif_RelayMode Mode; // required, 'Bistable' or 'Monostable' int DelayTime; // external, Time after which the relay returns to its idle state if it is in monostable mode. // If the Mode field is set to bistable mode the value of the parameter can be ignored onvif_RelayIdleState IdleState; // required, 'open' or 'closed' } onvif_RelayOutputSettings; typedef struct { uint32 RelayMode_BistableFlag : 1; uint32 RelayMode_MonostableFlag : 1; uint32 DelayTimesFlag : 1; // Indicates whether the field DelayTimes is valid uint32 DiscreteFlag : 1; // Indicates whether the field Discrete is valid uint32 Reserved : 28; char DelayTimes[100]; // optional, Supported delay time range or discrete values in seconds. This element must be present if MonoStable mode is supported. BOOL Discrete; // optional, True if the relay only supports the exact values for the DelayTimes listed. Default is false char token[ONVIF_TOKEN_LEN]; // required, Token of the relay output } onvif_RelayOutputOptions; typedef struct _RelayOutputOptionsList { struct _RelayOutputOptionsList * next; onvif_RelayOutputOptions Options; } RelayOutputOptionsList; typedef struct { char token[ONVIF_TOKEN_LEN]; // required onvif_RelayOutputSettings Properties; // required } onvif_RelayOutput; typedef struct _RelayOutputList { struct _RelayOutputList * next; onvif_RelayOutput RelayOutput; } RelayOutputList; typedef struct { uint32 IdleStateFlag : 1; // Indicates whether the field IdleState is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required onvif_DigitalIdleState IdleState; // optional, Indicate the Digital IdleState status } onvif_DigitalInput; typedef struct { uint32 DigitalIdleState_closedFlag : 1; uint32 DigitalIdleState_openFlag : 1; uint32 Reserved : 30; } onvif_DigitalInputConfigurationOptions; typedef struct _DigitalInputList { struct _DigitalInputList * next; onvif_DigitalInput DigitalInput; } DigitalInputList; typedef struct { int BaudRate; // required, The transfer bitrate int CharacterLength; // required, The bit length for each character float StopBit; // required, The number of stop bits used to terminate each character char token[ONVIF_TOKEN_LEN]; // required, onvif_ParityBit ParityBit; // required, The parity for the data error detection onvif_SerialPortType type; // required, } onvif_SerialPortConfiguration; typedef struct { onvif_IntList BaudRateList; // required, The list of configurable transfer bitrate onvif_ParityBitList ParityBitList; // required, The list of configurable parity for the data error detection onvif_IntList CharacterLengthList; // required, The list of configurable bit length for each character onvif_FloatList StopBitList; // required, The list of configurable number of stop bits used to terminate each character char token[ONVIF_TOKEN_LEN]; // required, } onvif_SerialPortConfigurationOptions; typedef struct { char token[ONVIF_TOKEN_LEN]; // required } onvif_SerialPort; typedef struct _SerialPortList { struct _SerialPortList * next; onvif_SerialPortConfiguration Configuration; onvif_SerialPortConfigurationOptions Options; onvif_SerialPort SerialPort; } SerialPortList; typedef union { char * Binary; char * String; } onvif_union_SerialData; typedef struct { int _union_SerialData; // 0 - Binary; 1 - String onvif_union_SerialData union_SerialData; } onvif_SerialData; typedef struct { uint32 SerialDataFlag : 1; // Indicates whether the field SerialData is valid uint32 TimeOutFlag : 1; // Indicates whether the field TimeOut is valid uint32 DataLengthFlag : 1; // Indicates whether the field DataLength is valid uint32 DelimiterFlag : 1; // Indicates whether the field Delimiter is valid uint32 Reserved : 28; onvif_SerialData SerialData; // optional, The serial port data uint32 TimeOut; // optional, Indicates that the command should be responded back within the specified period of time int DataLength; // optional, This element may be put in the case that data length returned from the connected serial device is already determined as some fixed bytes length. // It indicates the length of received data which can be regarded as available char Delimiter[100]; // optional, This element may be put in the case that the delimiter codes returned from the connected serial device is already known. // It indicates the termination data sequence of the responded data. In case the string has more than one character a device shall interpret the whole string as a single delimiter. // Furthermore a device shall return the delimiter character(s) to the client } onvif_SendReceiveSerialCommand; // DEVICEIO Define End // MEDIA2 Define Begin typedef struct { uint32 GovLengthRangeFlag : 1; // Indicates whether the field GovLengthRange is valid uint32 FrameRatesSupportedFlag : 1; // Indicates whether the field FrameRatesSupported is valid uint32 ProfilesSupportedFlag : 1; // Indicates whether the field ProfilesSupported is valid uint32 ConstantBitRateSupportedFlag : 1; // Indicates whether the field ConstantBitRateSupported is valid uint32 MaxAnchorFrameDistanceFlag : 1; // Indicates whether the field MaxAnchorFrameDistance is valid uint32 ConstantBitRateSupported : 1; // optional, Signal whether enforcing constant bitrate is supported uint32 GuaranteedFrameRateSupported : 1; // Indicates the support for the GuaranteedFrameRate attribute on the VideoEncoder2Configuration element uint32 Reserved : 25; char Encoding[64]; // required, Mime name of the supported Video format // JPEG, MP4V-ES, H264, H265 onvif_VideoEncoding VideoEncoding; // media server 1 field onvif_FloatRange QualityRange; // required, Range of the quality values. A high value means higher quality onvif_VideoResolution ResolutionsAvailable[MAX_RES_NUMS]; // required, List of supported image sizes onvif_IntRange BitrateRange; // required, Supported range of encoded bitrate in kbps char GovLengthRange[100]; // optional, Lower and Upper bounds for the supported group of Video frames length. // This value typically corresponds to the I-Frame distance int MaxAnchorFrameDistance; // optional, Signals support for B-Frames. Upper bound for the supported anchor frame distance (must be larger than one) char FrameRatesSupported[100]; // optional, List of supported target frame rates in fps (frames per second). // The list shall be sorted with highest values first char ProfilesSupported[256]; // optional, List of supported encoder profiles // Simple // AdvancedSimple // Baseline // Main // Main10 // Extended // High } onvif_VideoEncoder2ConfigurationOptions; typedef struct _VideoEncoder2ConfigurationOptionsList { struct _VideoEncoder2ConfigurationOptionsList * next; onvif_VideoEncoder2ConfigurationOptions Options; } VideoEncoder2ConfigurationOptionsList; typedef struct { uint32 ConstantBitRateFlag : 1; // Indicates whether the field ConstantBitRate is valid uint32 Reserved : 31; float FrameRateLimit; // required, Desired frame rate in fps. The actual rate may be lower due to e.g. performance limitations int BitrateLimit; // required, the maximum output bitrate in kbps BOOL ConstantBitRate; // optional, Enforce constant bitrate int EncodingInterval; // required, The media server field } onvif_VideoRateControl2; typedef struct { uint32 RateControlFlag : 1; // Indicates whether the field RateControl is valid uint32 MulticastFlag : 1; // Indicates whether the field Multicast is valid uint32 GovLengthFlag : 1; // Indicates whether the field GovLength is valid uint32 ProfileFlag : 1; // Indicates whether the field Profile is valid uint32 AnchorFrameDistanceFlag : 1; // Indicates whether the field AnchorFrameDistance is valid uint32 GuaranteedFrameRate : 1; // A value of true indicates that frame rate is a fixed value rather than an upper limit, // and that the video encoder shall prioritize frame rate over all other adaptable // configuration values such as bitrate. Default is false. uint32 Reserved : 26; char Name[ONVIF_NAME_LEN]; // required int UseCount; // required char token[ONVIF_TOKEN_LEN]; // required char Encoding[64]; // required, Mime name of the supported video format. // JPEG, MP4V-ES, H264, H265 onvif_VideoEncoding VideoEncoding; // required, the media 1 service field onvif_VideoResolution Resolution; // required, Configured video resolution onvif_VideoRateControl2 RateControl; // optional, Optional element to configure rate control related parameters onvif_MulticastConfiguration Multicast; // optional, Defines the multicast settings that could be used for video streaming float Quality; // required, Relative value for the video quantizers and the quality of the video. // A high value within supported quality range means higher quality int GovLength; // optional, Group of Video frames length. Determines typically the interval in which the I-Frames will be coded. // An entry of 1 indicates I-Frames are continuously generated. An entry of 2 indicates that every 2nd image is an I-Frame, and 3 only every 3rd frame, etc. // The frames in between are coded as P or B Frames char Profile[64]; // optional, The encoder profile // Simple // AdvancedSimple // Baseline // Main // Main10 // Extended // High int AnchorFrameDistance; // Distance between anchor frames of type I-Frame and P-Frame. '1' indicates no B-Frames, '2' indicates that every 2nd frame is encoded as B-Frame, '3' indicates a structure like IBBPBBP..., etc. int SessionTimeout; // required, the media service field } onvif_VideoEncoder2Configuration; typedef struct _VideoEncoder2ConfigurationList { struct _VideoEncoder2ConfigurationList * next; onvif_VideoEncoder2Configuration Configuration; } VideoEncoder2ConfigurationList; typedef struct { uint32 MulticastFlag : 1; // Indicates whether the field Multicast is valid uint32 Reserved : 31; char Name[ONVIF_NAME_LEN]; // required int UseCount; // required char token[ONVIF_TOKEN_LEN]; // required char Encoding[32]; // required, Mime name of the supported audio format // PCMU, G726, MP4A-LATM(AAC) onvif_AudioEncoding AudioEncoding; // required, the media service field onvif_MulticastConfiguration Multicast; // optional, Optional multicast configuration of the audio stream int Bitrate; // required, The output bitrate in kbps int SampleRate; // required, The output sample rate in kHz int SessionTimeout; // required, the media service field } onvif_AudioEncoder2Configuration; typedef struct { char Encoding[32]; // required, Mime name of the supported audio format // PCMU, G726, MP4A-LATM(AAC) onvif_AudioEncoding AudioEncoding; // media server 1 field onvif_IntList BitrateList; // required, List of supported bitrates in kbps for the specified Encoding onvif_IntList SampleRateList; // required, List of supported Sample Rates in kHz for the specified Encoding } onvif_AudioEncoder2ConfigurationOptions; typedef struct _AudioEncoder2ConfigurationOptionsList { struct _AudioEncoder2ConfigurationOptionsList * next; onvif_AudioEncoder2ConfigurationOptions Options; } AudioEncoder2ConfigurationOptionsList; typedef struct _AudioEncoder2ConfigurationList { struct _AudioEncoder2ConfigurationList * next; onvif_AudioEncoder2Configuration Configuration; } AudioEncoder2ConfigurationList; typedef struct { uint32 TokenFlag : 1; // Indicates whether the field Token is valid uint32 Reserved : 31; char Type[32]; // required, Type of the configuration // All, VideoSource, VideoEncoder, AudioSource, AudioEncoder, // AudioOutput, AudioDecoder, Metadata, Analytics, PTZ char Token[ONVIF_TOKEN_LEN]; // optional, Reference token of an existing configuration } onvif_ConfigurationRef; typedef struct { char Encoding[32]; // required, int Number; // required, } onvif_EncoderInstance; typedef struct { uint32 sizeCodec; onvif_EncoderInstance Codec[10]; // optional, If a device limits the number of instances for respective Video Codecs the response // contains the information how many streams can be set up at the same time per VideoSource int Total; // required, The minimum guaranteed total number of encoder instances (applications) per VideoSourceConfiguration. // The device is able to deliver the Total number of streams } onvif_EncoderInstanceInfo; typedef struct { char Name[ONVIF_NAME_LEN]; // required, int UseCount; // required, char token[ONVIF_TOKEN_LEN]; // required, } onvif_ConfigurationEntity; typedef struct { onvif_IntList Bitrate; // required onvif_IntList SampleRateRange; // required } onvif_AACDecOptions; typedef struct { onvif_IntList Bitrate; // required onvif_IntList SampleRateRange; // required } onvif_G711DecOptions; typedef struct { onvif_IntList Bitrate; // required onvif_IntList SampleRateRange; // required } onvif_G726DecOptions; typedef struct { uint32 AACDecOptionsFlag : 1; // Indicates whether the field AACDecOptions is valid uint32 G711DecOptionsFlag : 1; // Indicates whether the field G711DecOptions is valid uint32 G726DecOptionsFlag : 1; // Indicates whether the field G726DecOptions is valid uint32 Reserved : 29; onvif_AACDecOptions AACDecOptions; // optional onvif_G711DecOptions G711DecOptions; // optional onvif_G726DecOptions G726DecOptions; // optional } onvif_AudioDecoderConfigurationOptions; typedef struct { char Name[ONVIF_NAME_LEN]; // required, int UseCount; // required, char token[ONVIF_TOKEN_LEN]; // required, } onvif_AudioDecoderConfiguration; typedef struct _AudioDecoderConfigurationList { struct _AudioDecoderConfigurationList * next; onvif_AudioDecoderConfiguration Configuration; } AudioDecoderConfigurationList; typedef struct { uint32 VideoSourceFlag : 1; // Indicates whether the field VideoSource is valid uint32 AudioSourceFlag : 1; // Indicates whether the field AudioSource is valid uint32 VideoEncoderFlag : 1; // Indicates whether the field VideoEncoder is valid uint32 AudioEncoderFlag : 1; // Indicates whether the field AudioEncoder is valid uint32 AnalyticsFlag : 1; // Indicates whether the field Analytics is valid uint32 PTZFlag : 1; // Indicates whether the field PTZ is valid uint32 MetadataFlag : 1; // Indicates whether the field Metadata is valid uint32 AudioOutputFlag : 1; // Indicates whether the field AudioOutput is valid uint32 AudioDecoderFlag : 1; // Indicates whether the field AudioDecoder is valid uint32 Reserved : 23; onvif_VideoSourceConfiguration VideoSource; // optional, Optional configuration of the Video input onvif_AudioSourceConfiguration AudioSource; // optional, Optional configuration of the Audio input onvif_VideoEncoder2Configuration VideoEncoder; // optional, Optional configuration of the Video encoder onvif_AudioEncoder2Configuration AudioEncoder; // optional, Optional configuration of the Audio encoder onvif_VideoAnalyticsConfiguration Analytics; // optional, Optional configuration of the analytics module and rule engine onvif_PTZConfiguration PTZ; // optional, Optional configuration of the pan tilt zoom unit onvif_MetadataConfiguration Metadata; // optional, Optional configuration of the metadata stream onvif_AudioOutputConfiguration AudioOutput; // optional, Optional configuration of the Audio output onvif_AudioDecoderConfiguration AudioDecoder; // optional, Optional configuration of the Audio decoder } onvif_ConfigurationSet; typedef struct { char Name[ONVIF_NAME_LEN]; // required, User readable name of the profile onvif_ConfigurationSet Configurations; // required, The configurations assigned to the profile char token[ONVIF_TOKEN_LEN]; // required, Unique identifier of the profile BOOL fixed; // optional, A value of true signals that the profile cannot be deleted. Default is false char stream_uri[ONVIF_URI_LEN]; // this profile stream url address } onvif_MediaProfile; typedef struct _MediaProfileList { struct _MediaProfileList * next; onvif_MediaProfile MediaProfile; } MediaProfileList; typedef struct { uint32 sizePoint; // sequence of elements onvif_Vector Point[100]; // required, } onvif_Polygon; typedef struct { uint32 ColorFlag : 1; // Indicates whether the field Color is valid uint32 Reserved : 31; char ConfigurationToken[ONVIF_TOKEN_LEN]; // required, Token of the VideoSourceConfiguration the Mask is associated with onvif_Polygon Polygon; // required, Geometric representation of the mask area char Type[64]; // required, // Color - The masked area is colored with color defined by the Color field // Pixelated - The masked area is filled in mosaic style to hide details // Blurred - The masked area is low pass filtered to hide details onvif_Color Color; // optional, Color of the masked area BOOL Enabled; // required, If set the mask will cover the image, otherwise it will be fully transparent char token[ONVIF_TOKEN_LEN]; // required, Token of the mask } onvif_Mask; typedef struct { int MaxMasks; // required, Maximum supported number of masks per VideoSourceConfiguration int MaxPoints; // required, Maximum supported number of points per mask uint32 sizeTypes; // sequence, char Types[10][64]; // required, Information which types of tr2:MaskType are supported. // Valid values are 'Color', 'Pixelated' and 'Blurred' onvif_ColorOptions Color; // required, Colors supported BOOL RectangleOnly; // optional, Information whether the polygon must have four points and a rectangular shape BOOL SingleColorOnly; // optional, Indicates the device capability of change in color of privacy mask for one video source // configuration will automatically be applied to all the privacy masks associated with the same // video source configuration } onvif_MaskOptions; typedef struct _MaskList { struct _MaskList * next; onvif_Mask Mask; } MaskList; // MEDIA2 Define End // Thermal Define Begin typedef struct { char Name[ONVIF_NAME_LEN]; // required, User readable Color Palette name char token[ONVIF_TOKEN_LEN]; // required, Unique identifier of this Color Palette char Type[32]; // required, Indicates Color Palette Type. Can use the following value: // Custom,Grayscale,BlackHot,WhiteHot,Sepia,Red,Iron,Rain,Rainbow,Isotherm } onvif_ColorPalette; typedef enum { Polarity_WhiteHot = 0, Polarity_BlackHot = 1 } onvif_Polarity; typedef struct { uint32 LowTemperatureFlag : 1; // Indicates whether the field LowTemperature is valid uint32 HighTemperatureFlag : 1; // Indicates whether the field HighTemperature is valid uint32 Reserved : 30; char Name[ONVIF_NAME_LEN]; // required, User reabable name for the Non-Uniformity Correction (NUC) Table char token[ONVIF_TOKEN_LEN]; // required, Unique identifier of this NUC Table float LowTemperature; // optional, Low Temperature limit for application of NUC Table, in Kelvin float HighTemperature; // optional, High Temperature limit for application of NUC Table, in Kelvin } onvif_NUCTable; typedef struct { uint32 RunTimeFlag : 1; // Indicates whether the field RunTime is valid uint32 Reserved : 31; BOOL Enabled; // required, Indicates whether the Cooler is enabled (running) or not float RunTime; // optional, Number of hours the Cooler has been running (unit: hours). Read-only } onvif_Cooler; typedef struct { uint32 NUCTableFlag : 1; // Indicates whether the field NUCTable is valid uint32 CoolerFlag : 1; // Indicates whether the field Cooler is valid uint32 Reserved : 30; onvif_ColorPalette ColorPalette; // required, Current Color Palette in use by the Thermal Device onvif_Polarity Polarity; // required, Polarity configuration of the Thermal Device onvif_NUCTable NUCTable; // optional, Current Non-Uniformity Correction (NUC) Table in use by the Thermal Device onvif_Cooler Cooler; // optional, Cooler settings of the Thermal Device } onvif_ThermalConfiguration; typedef struct _ThermalConfigurationList { struct _ThermalConfigurationList * next; char token[ONVIF_TOKEN_LEN]; // required, Reference token to the thermal VideoSource onvif_ThermalConfiguration Configuration; } ThermalConfigurationList; typedef struct _ColorPaletteList { struct _ColorPaletteList * next; onvif_ColorPalette ColorPalette; } ColorPaletteList; typedef struct _NUCTableList { struct _NUCTableList * next; onvif_NUCTable NUCTable; } NUCTableList; typedef struct { BOOL Enabled; // optional, Indicates the Device allows cooler status to be changed from running (Enabled) to stopped (Disabled), and viceversa } onvif_CoolerOptions; typedef struct { uint32 CoolerOptionsFlag : 1; // Indicates whether the field CoolerOptions is valid uint32 Reserved : 31; ColorPaletteList * ColorPalette; // required, List of Color Palettes available for the requested Thermal VideoSource NUCTableList * NUCTable; // optional, List of Non-Uniformity Correction (NUC) Tables available for the requested Thermal VideoSource onvif_CoolerOptions CoolerOptions; // optional, Specifies Cooler Options for cooled thermal devices } onvif_ThermalConfigurationOptions; typedef struct { uint32 RelativeHumidityFlag : 1; // Indicates whether the field RelativeHumidity is valid uint32 AtmosphericTemperatureFlag : 1; // Indicates whether the field AtmosphericTemperature is valid uint32 AtmosphericTransmittanceFlag : 1; // Indicates whether the field AtmosphericTransmittance is valid uint32 ExtOpticsTemperatureFlag : 1; // Indicates whether the field ExtOpticsTemperature is valid uint32 ExtOpticsTransmittanceFlag : 1; // Indicates whether the field ExtOpticsTransmittance is valid uint32 Reserved : 27; float ReflectedAmbientTemperature; // required, Reflected Ambient Temperature for the environment in which the thermal device and the object being measured is located float Emissivity; // required, Emissivity of the surface of the object on which temperature is being measured float DistanceToObject; // required, Distance from the thermal device to the measured object float RelativeHumidity; // optional, Relative Humidity in the environment in which the measurement is located float AtmosphericTemperature; // optional, Temperature of the atmosphere between the thermal device and the object being measured float AtmosphericTransmittance; // optional, Transmittance value for the atmosphere between the thermal device and the object being measured float ExtOpticsTemperature; // optional, Temperature of the optics elements between the thermal device and the object being measured float ExtOpticsTransmittance; // optional, Transmittance value for the optics elements between the thermal device and the object being measured } onvif_RadiometryGlobalParameters; typedef struct { uint32 RadiometryGlobalParametersFlag : 1; // Indicates whether the field RadiometryGlobalParameters is valid uint32 Reserved : 31; onvif_RadiometryGlobalParameters RadiometryGlobalParameters; // optional, Global Parameters for Radiometry Measurements. // Shall exist if Radiometry Capability is reported, and Global Parameters are supported by the device } onvif_RadiometryConfiguration; typedef struct { uint32 RelativeHumidityFlag : 1; // Indicates whether the field RelativeHumidity is valid uint32 AtmosphericTemperatureFlag : 1; // Indicates whether the field AtmosphericTemperature is valid uint32 AtmosphericTransmittanceFlag : 1; // Indicates whether the field AtmosphericTransmittance is valid uint32 ExtOpticsTemperatureFlag : 1; // Indicates whether the field ExtOpticsTemperature is valid uint32 ExtOpticsTransmittanceFlag : 1; // Indicates whether the field ExtOpticsTransmittance is valid uint32 Reserved : 27; onvif_FloatRange ReflectedAmbientTemperature; // required, Valid range of temperature values, in Kelvin onvif_FloatRange Emissivity; // required, Valid range of emissivity values for the objects to measure onvif_FloatRange DistanceToObject; // required, Valid range of distance between camera and object for a valid temperature reading, in meters onvif_FloatRange RelativeHumidity; // optional, Valid range of relative humidity values, in percentage onvif_FloatRange AtmosphericTemperature; // optional, Valid range of temperature values, in Kelvin onvif_FloatRange AtmosphericTransmittance; // optional, Valid range of atmospheric transmittance values onvif_FloatRange ExtOpticsTemperature; // optional, Valid range of temperature values, in Kelvin onvif_FloatRange ExtOpticsTransmittance; // optional, Valid range of external optics transmittance } onvif_RadiometryGlobalParameterOptions; typedef struct { uint32 RadiometryGlobalParameterOptionsFlag : 1; // Indicates whether the field RadiometryGlobalParameterOptions is valid uint32 Reserved : 31; onvif_RadiometryGlobalParameterOptions RadiometryGlobalParameterOptions; // optional, Specifies valid ranges and options for the global radiometry parameters // used as default parameter values for temperature measurement modules (spots and boxes) } onvif_RadiometryConfigurationOptions; // Thermal Define End // Credential define start typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 ValidFromFlag : 1; // Indicates whether the field ValidFrom is valid uint32 ValidToFlag : 1; // Indicates whether the field ValidTo is valid uint32 Reserved : 29; char token[ONVIF_TOKEN_LEN]; // required, char Description[1024]; // optional, User readable description for the credential. It shall be up to 1024 characters char CredentialHolderReference[ONVIF_TOKEN_LEN]; // required, An external reference to a person holding this credential. // The reference is a username or used ID in an external system, such as a directory // service char ValidFrom[64]; // optional, The start date/time validity of the credential. If the // ValiditySupportsTimeValue capability is set to false, then only date is // supported (time is ignored) char ValidTo[64]; // optional, The expiration date/time validity of the credential. If the // ValiditySupportsTimeValue capability is set to false, then only date is // supported (time is ignored) } onvif_CredentialInfo; typedef struct { char Name[ONVIF_NAME_LEN]; // required, The name of the credential identifier type, such as pt:Card, pt:PIN, etc char FormatType[100]; // required, Specifies the format of the credential value for the specified identifier type name } onvif_CredentialIdentifierType; // A credential identifier is a card number, unique card information, PIN or // biometric information such as fingerprint, iris, vein, face recognition, that can be validated // in an access point typedef struct { BOOL Used; // used flag onvif_CredentialIdentifierType Type; // required, Contains the details of the credential identifier type. Is of type CredentialIdentifierType BOOL ExemptedFromAuthentication; // required, If set to true, this credential identifier is not considered for authentication char Value[2048]; // required, The value of the identifier in hexadecimal representation } onvif_CredentialIdentifier; typedef struct { onvif_CredentialIdentifierType Type; // required, Contains the details of the credential identifier type. Is of type CredentialIdentifierType char Value[2048]; // required, The value of the identifier in hexadecimal representation } onvif_CredentialIdentifierItem; typedef struct _CredentialIdentifierItemList { struct _CredentialIdentifierItemList * next; onvif_CredentialIdentifierItem Item; } CredentialIdentifierItemList; // The association between a credential and an access profile typedef struct { uint32 Used : 1; // used flag uint32 ValidFromFlag : 1; // Indicates whether the field ValidFrom is valid uint32 ValidToFlag : 1; // Indicates whether the field ValidTo is valid uint32 Reserved : 29; char AccessProfileToken[ONVIF_TOKEN_LEN]; // required, The reference token of the associated access profile char ValidFrom[64]; // optional, The start date/time of the validity for the association between the // credential and the access profile. If the ValiditySupportsTimeValue capability is set to // false, then only date is supported (time is ignored) char ValidTo[64]; // optional, The end date/time of the validity for the association between the // credential and the access profile. If the ValiditySupportsTimeValue capability is set to // false, then only date is supported (time is ignored) } onvif_CredentialAccessProfile; typedef struct { uint32 Used : 1; // used flag uint32 ValueFlag : 1; // Indicates whether the field Value is valid uint32 Reserved : 30; char Name[ONVIF_NAME_LEN]; // required, char Value[100]; // optional, } onvif_Attribute; // A Credential is a physical/tangible object, a piece of knowledge, or a facet of a person's // physical being, that enables an individual access to a given physical facility or computer-based // information system. A credential holds one or more credential identifiers. To gain access one or // more identifiers may be required typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 ValidFromFlag : 1; // Indicates whether the field ValidFrom is valid uint32 ValidToFlag : 1; // Indicates whether the field ValidTo is valid uint32 Reserved : 29; char token[ONVIF_TOKEN_LEN]; // required, char Description[1024]; // optional, User readable description for the credential. It shall be up to 1024 characters char CredentialHolderReference[ONVIF_TOKEN_LEN]; // required, An external reference to a person holding this credential. // The reference is a username or used ID in an external system, such as a directory // service char ValidFrom[64]; // optional, The start date/time validity of the credential. If the // ValiditySupportsTimeValue capability is set to false, then only date is // supported (time is ignored) char ValidTo[64]; // optional, The expiration date/time validity of the credential. If the // ValiditySupportsTimeValue capability is set to false, then only date is // supported (time is ignored) uint32 sizeCredentialIdentifier; // sequence of elements onvif_CredentialIdentifier CredentialIdentifier[CREDENTIAL_MAX_LIMIT]; // required, A list of credential identifier structures. At least one // credential identifier is required. Maximum one credential identifier structure // per type is allowed uint32 sizeCredentialAccessProfile; // sequence of elements onvif_CredentialAccessProfile CredentialAccessProfile[CREDENTIAL_MAX_LIMIT]; // optional, A list of credential access profile structures BOOL ExtendedGrantTime; // optional, A boolean indicating that the credential holder needs extra time to get through the door. // ExtendedReleaseTime will be added to ReleaseTime, and ExtendedOpenTime will be added to OpenTime uint32 sizeAttribute; // sequence of elements onvif_Attribute Attribute[CREDENTIAL_MAX_LIMIT]; // optional, A list of credential attributes as name value pairs. Key names // starting with the prefix pt: are reserved to define PACS specific attributes // following the "pt:" syntax } onvif_Credential; typedef struct { BOOL AntipassbackViolated; // required, Indicates if anti-passback is violated for the credential } onvif_AntipassbackState; // The CredentialState structure contains information about the state of the credential and // optionally the reason of why the credential was disabled typedef struct { uint32 ReasonFlag : 1; // Indicates whether the field Reason is valid uint32 AntipassbackStateFlag : 1; // Indicates whether the field AntipassbackState is valid uint32 Reserved : 30; BOOL Enabled; // required, True if the credential is enabled or false if the credential is disabled char Reason[100]; // optional, Predefined ONVIF reasons. For any other reason, free text can be used // pt:CredentialLockedOut // Access is denied due to credential locked out. // pt:CredentialBlocked // Access is denied because the credential has deliberately been blocked by the operator. // pt:CredentialLost // Access is denied due to the credential being reported as lost. // pt:CredentialStolen // Access is denied due to the credential being reported as stolen // pt:CredentialDamaged // Access is denied due to the credential being reported as damaged. // pt:CredentialDestroyed // Access is denied due to the credential being reported as destroyed // pt:CredentialInactivity // Access is denied due to credential inactivity // pt:CredentialExpired // Access is denied because the credential has expired // pt:CredentialRenewalNeeded // Access is denied because the credential requires a renewal (e.g. new PIN or // fingerprint enrollment). onvif_AntipassbackState AntipassbackState; // optional, A structure indicating the anti-passback state. This field shall be // supported if the ResetAntipassbackSupported capability is set to true } onvif_CredentialState; typedef struct { onvif_Credential Credential; // required, A format type supported by the device onvif_CredentialState CredentialState; // required, User readable description of the credential identifier format type } onvif_CredentialData; typedef struct { char FormatType[100]; // required, A format type supported by the device. A list of supported format types is // provided in [ISO 16484-5:2014-09 Annex P]. The BACnet type "CUSTOM" is not used. // Instead device manufacturers can define their own format types char Description[1024]; // required, User readable description of the credential identifier format type. It // shall be up to 1024 characters } onvif_CredentialIdentifierFormatTypeInfo; typedef struct _CredentialList { struct _CredentialList * next; onvif_Credential Credential; onvif_CredentialState State; } CredentialList; // Credential define end // Access Rules define begin typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required, char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, User readable description for the access profile. It shall be up to 1024 characters } onvif_AccessProfileInfo; typedef struct { uint32 EntityTypeFlag : 1; // Indicates whether the field EntityType is valid uint32 Reserved : 31; char ScheduleToken[ONVIF_TOKEN_LEN]; // required, Reference to the schedule used by the access policy char Entity[ONVIF_TOKEN_LEN]; // required, Reference to the entity used by the rule engine, // the entity type may be specified by the optional EntityType field // explained below but is typically an access point char EntityType[64]; // optional, Optional entity type; if missing, an access point type as defined // by the ONVIF Access Control service should be assumed. // This can also be represented by the QName value tac:AccessPoint // where tac is the namespace of Access Control Service Specification. // This field is provided for future extensions; // it will allow an access policy being extended to cover entity types // other than access points as well } onvif_AccessPolicy; typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required, char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, User readable description for the access profile. It shall be up to 1024 characters uint32 sizeAccessPolicy; // sequence of elements onvif_AccessPolicy AccessPolicy[ACCESSRULES_MAX_LIMIT]; // optional, A list of access policy structures, // where each access policy defines during which schedule an access point can be accessed } onvif_AccessProfile; typedef struct _AccessProfileList { struct _AccessProfileList * next; onvif_AccessProfile AccessProfile; } AccessProfileList; // Access Rules define end // Schedule define begin typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, User readable description for the schedule. It shall be up to 1024 characters } onvif_ScheduleInfo; typedef struct { uint32 UntilFlag : 1; // Indicates whether the field Until is valid uint32 Reserved : 31; char From[32]; // required, Indicates the start time char Until[32]; // optional, Indicates the end time. Is optional, if omitted, the period ends at midnight. // The end time is exclusive, meaning that that exact moment in time is not // part of the period. To determine if a moment in time (t) is part of a time period, // the formula StartTime ≤ t < EndTime is used. } onvif_TimePeriod; typedef struct { char GroupToken[ONVIF_TOKEN_LEN]; // required, Indicates the list of special days in a schedule uint32 sizeTimeRange; // sequence of elements onvif_TimePeriod TimeRange[SCHEDULE_MAX_LIMIT]; // optional, Indicates the alternate time periods for the list of special days // (overrides the regular schedule). For example, the regular schedule indicates // that it is active from 8AM to 5PM on Mondays. However, this particular // Monday is a special day, and the alternate time periods state that the // schedule is active from 9 AM to 11 AM and 1 PM to 4 PM. // If no time periods are defined, then no access is allowed. // Is of type TimePeriod } onvif_SpecialDaysSchedule; typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, User readable description for the schedule. It shall be up to 1024 characters char Standard[10*1024]; // required, An iCalendar structure that defines a number of events. Events // can be recurring or non-recurring. The events can, for instance, // be used to control when a camera should record or when a facility // is accessible. Some devices might not be able to fully support // all the features of iCalendar. Setting the service capability // ExtendedRecurrenceSupported to false will enable more devices // to be ONVIF compliant. Is of type string (but contains an iCalendar structure) uint32 sizeSpecialDays; // sequence of elements onvif_SpecialDaysSchedule SpecialDays[SCHEDULE_MAX_LIMIT]; // optional, For devices that are not able to support all the features of iCalendar, // supporting special days is essential. Each SpecialDaysSchedule // instance defines an alternate set of time periods that overrides // the regular schedule for a specified list of special days. // Is of type SpecialDaysSchedule } onvif_Schedule; typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 Reserved : 31; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, User readable description for the schedule. It shall be up to 1024 characters } onvif_SpecialDayGroupInfo; typedef struct { uint32 DescriptionFlag : 1; // Indicates whether the field Description is valid uint32 DaysFlag : 1; // Indicates whether the field Days is valid uint32 Reserved : 30; char token[ONVIF_TOKEN_LEN]; // required char Name[ONVIF_NAME_LEN]; // required, A user readable name. It shall be up to 64 characters char Description[1024]; // optional, User readable description for the schedule. It shall be up to 1024 characters char Days[4*1024]; // optional, An iCalendar structure that contains a group of special days. // Is of type string (containing an iCalendar structure) } onvif_SpecialDayGroup; typedef struct { uint32 SpecialDayFlag : 1; // Indicates whether the field SpecialDay is valid uint32 Reserved : 31; BOOL Active; // required, Indicates that the current time is within the boundaries of the schedule // or its special days schedules's time periods. For example, if this // schedule is being used for triggering automatic recording on a video source, // the Active flag will be true when the schedule-based recording is supposed to record BOOL SpecialDay; // optional, Indicates that the current time is within the boundaries of its special // days schedules's time periods. For example, if this schedule is being used // for recording at a lower frame rate on a video source during special days, // the SpecialDay flag will be true. If special days are not supported by the device, // this field may be omitted and interpreted as false by the client } onvif_ScheduleState; typedef struct _ScheduleList { struct _ScheduleList * next; onvif_Schedule Schedule; onvif_ScheduleState ScheduleState; #ifdef LIBICAL icalcomponent * comp; #endif } ScheduleList; typedef struct _SpecialDayGroupList { struct _SpecialDayGroupList * next; onvif_SpecialDayGroup SpecialDayGroup; #ifdef LIBICAL icalcomponent * comp; #endif } SpecialDayGroupList; // Schedule define end // Receiver define begin typedef struct { onvif_ReceiverMode Mode; // required, connection modes char MediaUri[256]; // required, Details of the URI to which the receiver should connect onvif_StreamSetup StreamSetup; // required, Stream connection parameters } onvif_ReceiverConfiguration; typedef struct { char Token[ONVIF_TOKEN_LEN]; // required, Unique identifier of the receiver onvif_ReceiverConfiguration Configuration; // required, Describes the configuration of the receiver } onvif_Receiver; typedef struct { onvif_ReceiverState State; // required, The connection state of the receiver BOOL AutoCreated; // required, Indicates whether or not the receiver was created automatically } onvif_ReceiverStateInformation; typedef struct _ReceiverList { struct _ReceiverList * next; onvif_Receiver Receiver; onvif_ReceiverStateInformation StateInformation; } ReceiverList; // Receiver define end // Provision define begin typedef struct { uint32 PanFlag : 1; // Indicates whether the field Pan is valid uint32 TiltFlag : 1; // Indicates whether the field Tilt is valid uint32 ZoomFlag : 1; // Indicates whether the field Zoom is valid uint32 RollFlag : 1; // Indicates whether the field Roll is valid uint32 FocusFlag : 1; // Indicates whether the field Focus is valid uint32 Reserved : 27; int Pan; // optional, The quantity of pan movement events over the life of the device int Tilt; // optional, The quantity of tilt movement events over the life of the device int Zoom; // optional, The quantity of zoom movement events over the life of the device int Roll; // optional, The quantity of roll movement events over the life of the device int Focus; // optional, The quantity of focus movement events over the life of the device } onvif_Usage; // Provision define end #ifdef __cplusplus extern "C" { #endif HT_API const char * onvif_CapabilityCategoryToString(onvif_CapabilityCategory category); HT_API onvif_CapabilityCategory onvif_StringToCapabilityCategory(const char * str); HT_API const char * onvif_FactoryDefaultTypeToString(onvif_FactoryDefaultType type); HT_API onvif_FactoryDefaultType onvif_StringToFactoryDefaultType(const char * str); HT_API const char * onvif_SystemLogTypeToString(onvif_SystemLogType type); HT_API onvif_SystemLogType onvif_StringToSystemLogType(const char * str); HT_API const char * onvif_VideoEncodingToString(onvif_VideoEncoding encoding); HT_API onvif_VideoEncoding onvif_StringToVideoEncoding(const char * str); HT_API const char * onvif_AudioEncodingToString(onvif_AudioEncoding encoding); HT_API onvif_AudioEncoding onvif_StringToAudioEncoding(const char * str); HT_API const char * onvif_H264ProfileToString(onvif_H264Profile profile); HT_API onvif_H264Profile onvif_StringToH264Profile(const char * str); HT_API const char * onvif_Mpeg4ProfileToString(onvif_Mpeg4Profile profile); HT_API onvif_Mpeg4Profile onvif_StringToMpeg4Profile(const char * str); HT_API const char * onvif_UserLevelToString(onvif_UserLevel level); HT_API onvif_UserLevel onvif_StringToUserLevel(const char * str); HT_API const char * onvif_MoveStatusToString(onvif_MoveStatus status); HT_API onvif_MoveStatus onvif_StringToMoveStatus(const char * str); HT_API const char * onvif_OSDTypeToString(onvif_OSDType type); HT_API onvif_OSDType onvif_StringToOSDType(const char * type); HT_API const char * onvif_OSDPosTypeToString(onvif_OSDPosType type); HT_API onvif_OSDPosType onvif_StringToOSDPosType(const char * type); HT_API const char * onvif_OSDTextTypeToString(onvif_OSDTextType type); HT_API onvif_OSDTextType onvif_StringToOSDTextType(const char * type); HT_API const char * onvif_BacklightCompensationModeToString(onvif_BacklightCompensationMode mode); HT_API onvif_BacklightCompensationMode onvif_StringToBacklightCompensationMode(const char * str); HT_API const char * onvif_ExposureModeToString(onvif_ExposureMode mode); HT_API onvif_ExposureMode onvif_StringToExposureMode(const char * str); HT_API const char * onvif_ExposurePriorityToString(onvif_ExposurePriority mode); HT_API onvif_ExposurePriority onvif_StringToExposurePriority(const char * str); HT_API const char * onvif_AutoFocusModeToString(onvif_AutoFocusMode mode); HT_API onvif_AutoFocusMode onvif_StringToAutoFocusMode(const char * str); HT_API const char * onvif_WideDynamicModeToString(onvif_WideDynamicMode mode); HT_API onvif_WideDynamicMode onvif_StringToWideDynamicMode(const char * str); HT_API const char * onvif_IrCutFilterModeToString(onvif_IrCutFilterMode mode); HT_API onvif_IrCutFilterMode onvif_StringToIrCutFilterMode(const char * str); HT_API const char * onvif_WhiteBalanceModeToString(onvif_WhiteBalanceMode mode); HT_API onvif_WhiteBalanceMode onvif_StringToWhiteBalanceMode(const char * str); HT_API const char * onvif_EFlipModeToString(onvif_EFlipMode mode); HT_API onvif_EFlipMode onvif_StringToEFlipMode(const char * str); HT_API const char * onvif_ReverseModeToString(onvif_ReverseMode mode); HT_API onvif_ReverseMode onvif_StringToReverseMode(const char * str); HT_API const char * onvif_DiscoveryModeToString(onvif_DiscoveryMode mode); HT_API onvif_DiscoveryMode onvif_StringToDiscoveryMode(const char * str); HT_API const char * onvif_SetDateTimeTypeToString(onvif_SetDateTimeType type); HT_API onvif_SetDateTimeType onvif_StringToSetDateTimeType(const char * str); HT_API const char * onvif_StreamTypeToString(onvif_StreamType type); HT_API onvif_StreamType onvif_StringToStreamType(const char * str); HT_API const char * onvif_TransportProtocolToString(onvif_TransportProtocol type); HT_API onvif_TransportProtocol onvif_StringToTransportProtocol(const char * str); HT_API const char * onvif_DynamicDNSTypeToString(onvif_DynamicDNSType type); HT_API onvif_DynamicDNSType onvif_StringToDynamicDNSType(const char * str); HT_API const char * onvif_TrackTypeToString(onvif_TrackType type); HT_API onvif_TrackType onvif_StringToTrackType(const char * str); HT_API const char * onvif_PropertyOperationToString(onvif_PropertyOperation type); HT_API onvif_PropertyOperation onvif_StringToPropertyOperation(const char * str); HT_API const char * onvif_RecordingStatusToString(onvif_RecordingStatus status); HT_API onvif_RecordingStatus onvif_StringToRecordingStatus(const char * str); HT_API const char * onvif_SearchStateToString(onvif_SearchState state); HT_API onvif_SearchState onvif_StringToSearchState(const char * str); HT_API const char * onvif_RotateModeToString(onvif_RotateMode mode); HT_API onvif_RotateMode onvif_StringToRotateMode(const char * str); HT_API const char * onvif_ScopeDefinitionToString(onvif_ScopeDefinition def); HT_API onvif_ScopeDefinition onvif_StringToScopeDefinition(const char * str); HT_API const char * onvif_Dot11AuthAndMangementSuiteToString(onvif_Dot11AuthAndMangementSuite req); HT_API onvif_Dot11AuthAndMangementSuite onvif_StringToDot11AuthAndMangementSuite(const char * str); HT_API const char * onvif_Dot11CipherToString(onvif_Dot11Cipher req); HT_API onvif_Dot11Cipher onvif_StringToDot11Cipher(const char * str); HT_API const char * onvif_Dot11SignalStrengthToString(onvif_Dot11SignalStrength req); HT_API onvif_Dot11SignalStrength onvif_StringToDot11SignalStrength(const char * str); HT_API const char * onvif_Dot11StationModeToString(onvif_Dot11StationMode req); HT_API onvif_Dot11StationMode onvif_StringToDot11StationMode(const char * str); HT_API const char * onvif_Dot11SecurityModeToString(onvif_Dot11SecurityMode req); HT_API onvif_Dot11SecurityMode onvif_StringToDot11SecurityMode(const char * str); HT_API const char * onvif_PTZPresetTourOperationToString(onvif_PTZPresetTourOperation op); HT_API onvif_PTZPresetTourOperation onvif_StringToPTZPresetTourOperation(const char * str); HT_API const char * onvif_PTZPresetTourStateToString(onvif_PTZPresetTourState st); HT_API onvif_PTZPresetTourState onvif_StringToPTZPresetTourState(const char * str); HT_API const char * onvif_PTZPresetTourDirectionToString(onvif_PTZPresetTourDirection dir); HT_API onvif_PTZPresetTourDirection onvif_StringToPTZPresetTourDirection(const char * str); HT_API const char * onvif_DoorPhysicalStateToString(onvif_DoorPhysicalState state); HT_API onvif_DoorPhysicalState onvif_StringToDoorPhysicalState(const char * str); HT_API const char * onvif_LockPhysicalStateToString(onvif_LockPhysicalState state); HT_API onvif_LockPhysicalState onvif_StringToLockPhysicalState(const char * str); HT_API const char * onvif_DoorAlarmStateToString(onvif_DoorAlarmState state); HT_API onvif_DoorAlarmState onvif_StringToDoorAlarmState(const char * str); HT_API const char * onvif_DoorTamperStateToString(onvif_DoorTamperState state); HT_API onvif_DoorTamperState onvif_StringToDoorTamperState(const char * str); HT_API const char * onvif_DoorFaultStateToString(onvif_DoorFaultState state); HT_API onvif_DoorFaultState onvif_StringToDoorFaultState(const char * str); HT_API const char * onvif_DoorModeToString(onvif_DoorMode mode); HT_API onvif_DoorMode onvif_StringToDoorMode(const char * str); HT_API const char * onvif_RelayModeToString(onvif_RelayMode mode); HT_API onvif_RelayMode onvif_StringToRelayMode(const char * str); HT_API const char * onvif_RelayIdleStateToString(onvif_RelayIdleState state); HT_API onvif_RelayIdleState onvif_StringToRelayIdleState(const char * str); HT_API const char * onvif_RelayLogicalStateToString(onvif_RelayLogicalState state); HT_API onvif_RelayLogicalState onvif_StringToRelayLogicalState(const char * str); HT_API const char * onvif_DigitalIdleStateToString(onvif_DigitalIdleState state); HT_API onvif_DigitalIdleState onvif_StringToDigitalIdleState(const char * str); HT_API const char * onvif_ParityBitToString(onvif_ParityBit type); HT_API onvif_ParityBit onvif_StringToParityBit(const char * str); HT_API const char * onvif_SerialPortTypeToString(onvif_SerialPortType type); HT_API onvif_SerialPortType onvif_StringToSerialPortType(const char * str); HT_API const char * onvif_PolarityToString(onvif_Polarity type); HT_API onvif_Polarity onvif_StringToPolarity(const char * str); HT_API const char * onvif_ReceiverModeToString(onvif_ReceiverMode mode); HT_API onvif_ReceiverMode onvif_StringToReceiverMode(const char * str); HT_API const char * onvif_ReceiverStateToString(onvif_ReceiverState state); HT_API onvif_ReceiverState onvif_StringToReceiverState(const char * str); HT_API const char * onvif_IPAddressFilterTypeToString(onvif_IPAddressFilterType type); HT_API onvif_IPAddressFilterType onvif_StringToIPAddressFilterType(const char * str); HT_API const char * onvif_PanDirectionToString(onvif_PanDirection dir); HT_API onvif_PanDirection onvif_StringToPanDirection(const char * str); HT_API const char * onvif_TiltDirectionToString(onvif_TiltDirection dir); HT_API onvif_TiltDirection onvif_StringToTiltDirection(const char * str); HT_API const char * onvif_ZoomDirectionToString(onvif_ZoomDirection dir); HT_API onvif_ZoomDirection onvif_StringToZoomDirection(const char * str); HT_API const char * onvif_RollDirectionToString(onvif_RollDirection dir); HT_API onvif_RollDirection onvif_StringToRollDirection(const char * str); HT_API const char * onvif_FocusDirectionToString(onvif_FocusDirection dir); HT_API onvif_FocusDirection onvif_StringToFocusDirection(const char * str); #ifdef __cplusplus } #endif #endif /* end of ONVIF_COMM_H */