WPILibC++  2020.3.2
cscore_c.h
1 /*----------------------------------------------------------------------------*/
2 /* Copyright (c) 2016-2019 FIRST. All Rights Reserved. */
3 /* Open Source Software - may be modified and shared by FRC teams. The code */
4 /* must be accompanied by the FIRST BSD license file in the root directory of */
5 /* the project. */
6 /*----------------------------------------------------------------------------*/
7 
8 #ifndef CSCORE_CSCORE_C_H_
9 #define CSCORE_CSCORE_C_H_
10 
11 #include <stdint.h>
12 
13 #ifdef __cplusplus
14 #include <cstddef>
15 #else
16 #include <stddef.h>
17 #endif
18 
19 #ifdef __cplusplus
20 extern "C" {
21 #endif
22 
46 typedef int CS_Bool;
47 typedef int CS_Status;
48 
49 typedef int CS_Handle;
50 typedef CS_Handle CS_Property;
51 typedef CS_Handle CS_Listener;
52 typedef CS_Handle CS_Sink;
53 typedef CS_Handle CS_Source;
60  CS_PROPERTY_WRITE_FAILED = 2000,
61  CS_OK = 0,
62  CS_INVALID_HANDLE = -2000, // handle was invalid (does not exist)
63  CS_WRONG_HANDLE_SUBTYPE = -2001,
64  CS_INVALID_PROPERTY = -2002,
65  CS_WRONG_PROPERTY_TYPE = -2003,
66  CS_READ_FAILED = -2004,
67  CS_SOURCE_IS_DISCONNECTED = -2005,
68  CS_EMPTY_VALUE = -2006,
69  CS_BAD_URL = -2007,
70  CS_TELEMETRY_NOT_ENABLED = -2008,
71  CS_UNSUPPORTED_MODE = -2009
72 };
73 
78  CS_LOG_CRITICAL = 50,
79  CS_LOG_ERROR = 40,
80  CS_LOG_WARNING = 30,
81  CS_LOG_INFO = 20,
82  CS_LOG_DEBUG = 10,
83  CS_LOG_DEBUG1 = 9,
84  CS_LOG_DEBUG2 = 8,
85  CS_LOG_DEBUG3 = 7,
86  CS_LOG_DEBUG4 = 6
87 };
88 
93  CS_PIXFMT_UNKNOWN = 0,
94  CS_PIXFMT_MJPEG,
95  CS_PIXFMT_YUYV,
96  CS_PIXFMT_RGB565,
97  CS_PIXFMT_BGR,
98  CS_PIXFMT_GRAY
99 };
100 
104 typedef struct CS_VideoMode {
105  int pixelFormat;
106  int width;
107  int height;
108  int fps;
109 } CS_VideoMode;
110 
115  CS_PROP_NONE = 0,
116  CS_PROP_BOOLEAN = 1,
117  CS_PROP_INTEGER = 2,
118  CS_PROP_STRING = 4,
119  CS_PROP_ENUM = 8
120 };
121 
126  CS_SOURCE_UNKNOWN = 0,
127  CS_SOURCE_USB = 1,
128  CS_SOURCE_HTTP = 2,
129  CS_SOURCE_CV = 4,
130  CS_SOURCE_RAW = 8,
131 };
132 
137  CS_HTTP_UNKNOWN = 0,
138  CS_HTTP_MJPGSTREAMER = 1,
139  CS_HTTP_CSCORE = 2,
140  CS_HTTP_AXIS = 3
141 };
142 
147  CS_SINK_UNKNOWN = 0,
148  CS_SINK_MJPEG = 2,
149  CS_SINK_CV = 4,
150  CS_SINK_RAW = 8
151 };
152 
157  CS_SOURCE_CREATED = 0x0001,
158  CS_SOURCE_DESTROYED = 0x0002,
159  CS_SOURCE_CONNECTED = 0x0004,
160  CS_SOURCE_DISCONNECTED = 0x0008,
161  CS_SOURCE_VIDEOMODES_UPDATED = 0x0010,
162  CS_SOURCE_VIDEOMODE_CHANGED = 0x0020,
163  CS_SOURCE_PROPERTY_CREATED = 0x0040,
164  CS_SOURCE_PROPERTY_VALUE_UPDATED = 0x0080,
165  CS_SOURCE_PROPERTY_CHOICES_UPDATED = 0x0100,
166  CS_SINK_SOURCE_CHANGED = 0x0200,
167  CS_SINK_CREATED = 0x0400,
168  CS_SINK_DESTROYED = 0x0800,
169  CS_SINK_ENABLED = 0x1000,
170  CS_SINK_DISABLED = 0x2000,
171  CS_NETWORK_INTERFACES_CHANGED = 0x4000,
172  CS_TELEMETRY_UPDATED = 0x8000,
173  CS_SINK_PROPERTY_CREATED = 0x10000,
174  CS_SINK_PROPERTY_VALUE_UPDATED = 0x20000,
175  CS_SINK_PROPERTY_CHOICES_UPDATED = 0x40000
176 };
177 
182  CS_SOURCE_BYTES_RECEIVED = 1,
183  CS_SOURCE_FRAMES_RECEIVED = 2
184 };
185 
193 
199 
205 };
206 
210 struct CS_Event {
211  enum CS_EventKind kind;
212 
213  // Valid for CS_SOURCE_* and CS_SINK_* respectively
214  CS_Source source;
215  CS_Sink sink;
216 
217  // Source/sink/property name
218  const char* name;
219 
220  // Fields for CS_SOURCE_VIDEOMODE_CHANGED event
221  CS_VideoMode mode;
222 
223  // Fields for CS_SOURCE_PROPERTY_* events
224  CS_Property property;
225  enum CS_PropertyKind propertyKind;
226  int value;
227  const char* valueStr;
228 };
229 
233 typedef struct CS_UsbCameraInfo {
234  int dev;
235  char* path;
236  char* name;
237  int otherPathsCount;
238  char** otherPaths;
239  int vendorId;
240  int productId;
242 
247 enum CS_PropertyKind CS_GetPropertyKind(CS_Property property,
248  CS_Status* status);
249 char* CS_GetPropertyName(CS_Property property, CS_Status* status);
250 int CS_GetProperty(CS_Property property, CS_Status* status);
251 void CS_SetProperty(CS_Property property, int value, CS_Status* status);
252 int CS_GetPropertyMin(CS_Property property, CS_Status* status);
253 int CS_GetPropertyMax(CS_Property property, CS_Status* status);
254 int CS_GetPropertyStep(CS_Property property, CS_Status* status);
255 int CS_GetPropertyDefault(CS_Property property, CS_Status* status);
256 char* CS_GetStringProperty(CS_Property property, CS_Status* status);
257 void CS_SetStringProperty(CS_Property property, const char* value,
258  CS_Status* status);
259 char** CS_GetEnumPropertyChoices(CS_Property property, int* count,
260  CS_Status* status);
267 CS_Source CS_CreateUsbCameraDev(const char* name, int dev, CS_Status* status);
268 CS_Source CS_CreateUsbCameraPath(const char* name, const char* path,
269  CS_Status* status);
270 CS_Source CS_CreateHttpCamera(const char* name, const char* url,
271  enum CS_HttpCameraKind kind, CS_Status* status);
272 CS_Source CS_CreateHttpCameraMulti(const char* name, const char** urls,
273  int count, enum CS_HttpCameraKind kind,
274  CS_Status* status);
275 CS_Source CS_CreateCvSource(const char* name, const CS_VideoMode* mode,
276  CS_Status* status);
283 enum CS_SourceKind CS_GetSourceKind(CS_Source source, CS_Status* status);
284 char* CS_GetSourceName(CS_Source source, CS_Status* status);
285 char* CS_GetSourceDescription(CS_Source source, CS_Status* status);
286 uint64_t CS_GetSourceLastFrameTime(CS_Source source, CS_Status* status);
287 void CS_SetSourceConnectionStrategy(CS_Source source,
288  enum CS_ConnectionStrategy strategy,
289  CS_Status* status);
290 CS_Bool CS_IsSourceConnected(CS_Source source, CS_Status* status);
291 CS_Bool CS_IsSourceEnabled(CS_Source source, CS_Status* status);
292 CS_Property CS_GetSourceProperty(CS_Source source, const char* name,
293  CS_Status* status);
294 CS_Property* CS_EnumerateSourceProperties(CS_Source source, int* count,
295  CS_Status* status);
296 void CS_GetSourceVideoMode(CS_Source source, CS_VideoMode* mode,
297  CS_Status* status);
298 CS_Bool CS_SetSourceVideoMode(CS_Source source, const CS_VideoMode* mode,
299  CS_Status* status);
300 CS_Bool CS_SetSourceVideoModeDiscrete(CS_Source source,
301  enum CS_PixelFormat pixelFormat,
302  int width, int height, int fps,
303  CS_Status* status);
304 CS_Bool CS_SetSourcePixelFormat(CS_Source source,
305  enum CS_PixelFormat pixelFormat,
306  CS_Status* status);
307 CS_Bool CS_SetSourceResolution(CS_Source source, int width, int height,
308  CS_Status* status);
309 CS_Bool CS_SetSourceFPS(CS_Source source, int fps, CS_Status* status);
310 CS_Bool CS_SetSourceConfigJson(CS_Source source, const char* config,
311  CS_Status* status);
312 char* CS_GetSourceConfigJson(CS_Source source, CS_Status* status);
313 CS_VideoMode* CS_EnumerateSourceVideoModes(CS_Source source, int* count,
314  CS_Status* status);
315 CS_Sink* CS_EnumerateSourceSinks(CS_Source source, int* count,
316  CS_Status* status);
317 CS_Source CS_CopySource(CS_Source source, CS_Status* status);
318 void CS_ReleaseSource(CS_Source source, CS_Status* status);
325 void CS_SetCameraBrightness(CS_Source source, int brightness,
326  CS_Status* status);
327 int CS_GetCameraBrightness(CS_Source source, CS_Status* status);
328 void CS_SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
329 void CS_SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
330 void CS_SetCameraWhiteBalanceManual(CS_Source source, int value,
331  CS_Status* status);
332 void CS_SetCameraExposureAuto(CS_Source source, CS_Status* status);
333 void CS_SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
334 void CS_SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
341 char* CS_GetUsbCameraPath(CS_Source source, CS_Status* status);
342 CS_UsbCameraInfo* CS_GetUsbCameraInfo(CS_Source source, CS_Status* status);
349 enum CS_HttpCameraKind CS_GetHttpCameraKind(CS_Source source,
350  CS_Status* status);
351 void CS_SetHttpCameraUrls(CS_Source source, const char** urls, int count,
352  CS_Status* status);
353 char** CS_GetHttpCameraUrls(CS_Source source, int* count, CS_Status* status);
360 void CS_NotifySourceError(CS_Source source, const char* msg, CS_Status* status);
361 void CS_SetSourceConnected(CS_Source source, CS_Bool connected,
362  CS_Status* status);
363 void CS_SetSourceDescription(CS_Source source, const char* description,
364  CS_Status* status);
365 CS_Property CS_CreateSourceProperty(CS_Source source, const char* name,
366  enum CS_PropertyKind kind, int minimum,
367  int maximum, int step, int defaultValue,
368  int value, CS_Status* status);
369 void CS_SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
370  const char** choices, int count,
371  CS_Status* status);
378 CS_Sink CS_CreateMjpegServer(const char* name, const char* listenAddress,
379  int port, CS_Status* status);
380 CS_Sink CS_CreateCvSink(const char* name, CS_Status* status);
381 CS_Sink CS_CreateCvSinkCallback(const char* name, void* data,
382  void (*processFrame)(void* data, uint64_t time),
383  CS_Status* status);
390 enum CS_SinkKind CS_GetSinkKind(CS_Sink sink, CS_Status* status);
391 char* CS_GetSinkName(CS_Sink sink, CS_Status* status);
392 char* CS_GetSinkDescription(CS_Sink sink, CS_Status* status);
393 CS_Property CS_GetSinkProperty(CS_Sink sink, const char* name,
394  CS_Status* status);
395 CS_Property* CS_EnumerateSinkProperties(CS_Sink sink, int* count,
396  CS_Status* status);
397 void CS_SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
398 CS_Property CS_GetSinkSourceProperty(CS_Sink sink, const char* name,
399  CS_Status* status);
400 CS_Bool CS_SetSinkConfigJson(CS_Sink sink, const char* config,
401  CS_Status* status);
402 char* CS_GetSinkConfigJson(CS_Sink sink, CS_Status* status);
403 CS_Source CS_GetSinkSource(CS_Sink sink, CS_Status* status);
404 CS_Sink CS_CopySink(CS_Sink sink, CS_Status* status);
405 void CS_ReleaseSink(CS_Sink sink, CS_Status* status);
412 char* CS_GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
413 int CS_GetMjpegServerPort(CS_Sink sink, CS_Status* status);
420 void CS_SetSinkDescription(CS_Sink sink, const char* description,
421  CS_Status* status);
422 char* CS_GetSinkError(CS_Sink sink, CS_Status* status);
423 void CS_SetSinkEnabled(CS_Sink sink, CS_Bool enabled, CS_Status* status);
430 void CS_SetListenerOnStart(void (*onStart)(void* data), void* data);
431 void CS_SetListenerOnExit(void (*onExit)(void* data), void* data);
432 CS_Listener CS_AddListener(
433  void* data, void (*callback)(void* data, const struct CS_Event* event),
434  int eventMask, int immediateNotify, CS_Status* status);
435 
436 void CS_RemoveListener(CS_Listener handle, CS_Status* status);
439 int CS_NotifierDestroyed(void);
440 
445 void CS_SetTelemetryPeriod(double seconds);
446 double CS_GetTelemetryElapsedTime(void);
447 int64_t CS_GetTelemetryValue(CS_Handle handle, enum CS_TelemetryKind kind,
448  CS_Status* status);
449 double CS_GetTelemetryAverageValue(CS_Handle handle, enum CS_TelemetryKind kind,
450  CS_Status* status);
457 typedef void (*CS_LogFunc)(unsigned int level, const char* file,
458  unsigned int line, const char* msg);
459 void CS_SetLogger(CS_LogFunc func, unsigned int min_level);
460 void CS_SetDefaultLogger(unsigned int min_level);
467 void CS_Shutdown(void);
475 CS_UsbCameraInfo* CS_EnumerateUsbCameras(int* count, CS_Status* status);
476 void CS_FreeEnumeratedUsbCameras(CS_UsbCameraInfo* cameras, int count);
477 
478 CS_Source* CS_EnumerateSources(int* count, CS_Status* status);
479 void CS_ReleaseEnumeratedSources(CS_Source* sources, int count);
480 
481 CS_Sink* CS_EnumerateSinks(int* count, CS_Status* status);
482 void CS_ReleaseEnumeratedSinks(CS_Sink* sinks, int count);
483 
484 void CS_FreeString(char* str);
485 void CS_FreeEnumPropertyChoices(char** choices, int count);
486 void CS_FreeUsbCameraInfo(CS_UsbCameraInfo* info);
487 void CS_FreeHttpCameraUrls(char** urls, int count);
488 
489 void CS_FreeEnumeratedProperties(CS_Property* properties, int count);
490 void CS_FreeEnumeratedVideoModes(CS_VideoMode* modes, int count);
491 
492 char* CS_GetHostname();
493 
494 char** CS_GetNetworkInterfaces(int* count);
495 void CS_FreeNetworkInterfaces(char** interfaces, int count);
500 #ifdef __cplusplus
501 } // extern "C"
502 #endif
503 
504 #endif // CSCORE_CSCORE_C_H_
CS_TelemetryKind
CS_TelemetryKind
Telemetry kinds.
Definition: cscore_c.h:181
CS_LogLevel
CS_LogLevel
Logging levels.
Definition: cscore_c.h:77
CS_VideoMode
struct CS_VideoMode CS_VideoMode
Video mode.
CS_VideoMode
Video mode.
Definition: cscore_c.h:104
CS_CONNECTION_KEEP_OPEN
Try to keep the connection open regardless of whether any sinks are connected.
Definition: cscore_c.h:198
CS_HttpCameraKind
CS_HttpCameraKind
HTTP Camera kinds.
Definition: cscore_c.h:136
CS_Event
Listener event.
Definition: cscore_c.h:210
CS_SinkKind
CS_SinkKind
Sink kinds.
Definition: cscore_c.h:146
CS_CONNECTION_AUTO_MANAGE
Automatically connect or disconnect based on whether any sinks are connected to this source.
Definition: cscore_c.h:192
CS_ConnectionStrategy
CS_ConnectionStrategy
Connection strategy.
Definition: cscore_c.h:187
CS_SourceKind
CS_SourceKind
Source kinds.
Definition: cscore_c.h:125
CS_CONNECTION_FORCE_CLOSE
Never open the connection.
Definition: cscore_c.h:204
CS_UsbCameraInfo
USB camera infomation.
Definition: cscore_c.h:233
CS_PropertyKind
CS_PropertyKind
Property kinds.
Definition: cscore_c.h:114
CS_EventKind
CS_EventKind
Listener event kinds.
Definition: cscore_c.h:156
CS_UsbCameraInfo
struct CS_UsbCameraInfo CS_UsbCameraInfo
USB camera infomation.
CS_StatusValue
CS_StatusValue
Status values.
Definition: cscore_c.h:59
CS_PixelFormat
CS_PixelFormat
Pixel formats.
Definition: cscore_c.h:92