WPILibC++  2019.1.1-beta-4-32-g6bdd7ce
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
cscore_c.h
1 /*----------------------------------------------------------------------------*/
2 /* Copyright (c) 2016-2018 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 
23 struct CvMat;
24 
48 typedef int CS_Bool;
49 typedef int CS_Status;
50 
51 typedef int CS_Handle;
52 typedef CS_Handle CS_Property;
53 typedef CS_Handle CS_Listener;
54 typedef CS_Handle CS_Sink;
55 typedef CS_Handle CS_Source;
62  CS_PROPERTY_WRITE_FAILED = 2000,
63  CS_OK = 0,
64  CS_INVALID_HANDLE = -2000, // handle was invalid (does not exist)
65  CS_WRONG_HANDLE_SUBTYPE = -2001,
66  CS_INVALID_PROPERTY = -2002,
67  CS_WRONG_PROPERTY_TYPE = -2003,
68  CS_READ_FAILED = -2004,
69  CS_SOURCE_IS_DISCONNECTED = -2005,
70  CS_EMPTY_VALUE = -2006,
71  CS_BAD_URL = -2007,
72  CS_TELEMETRY_NOT_ENABLED = -2008,
73  CS_UNSUPPORTED_MODE = -2009
74 };
75 
80  CS_LOG_CRITICAL = 50,
81  CS_LOG_ERROR = 40,
82  CS_LOG_WARNING = 30,
83  CS_LOG_INFO = 20,
84  CS_LOG_DEBUG = 10,
85  CS_LOG_DEBUG1 = 9,
86  CS_LOG_DEBUG2 = 8,
87  CS_LOG_DEBUG3 = 7,
88  CS_LOG_DEBUG4 = 6
89 };
90 
95  CS_PIXFMT_UNKNOWN = 0,
96  CS_PIXFMT_MJPEG,
97  CS_PIXFMT_YUYV,
98  CS_PIXFMT_RGB565,
99  CS_PIXFMT_BGR,
100  CS_PIXFMT_GRAY
101 };
102 
106 typedef struct CS_VideoMode {
107  int pixelFormat;
108  int width;
109  int height;
110  int fps;
111 } CS_VideoMode;
112 
117  CS_PROP_NONE = 0,
118  CS_PROP_BOOLEAN = 1,
119  CS_PROP_INTEGER = 2,
120  CS_PROP_STRING = 4,
121  CS_PROP_ENUM = 8
122 };
123 
128  CS_SOURCE_UNKNOWN = 0,
129  CS_SOURCE_USB = 1,
130  CS_SOURCE_HTTP = 2,
131  CS_SOURCE_CV = 4
132 };
133 
138  CS_HTTP_UNKNOWN = 0,
139  CS_HTTP_MJPGSTREAMER = 1,
140  CS_HTTP_CSCORE = 2,
141  CS_HTTP_AXIS = 3
142 };
143 
147 enum CS_SinkKind { CS_SINK_UNKNOWN = 0, CS_SINK_MJPEG = 2, CS_SINK_CV = 4 };
148 
153  CS_SOURCE_CREATED = 0x0001,
154  CS_SOURCE_DESTROYED = 0x0002,
155  CS_SOURCE_CONNECTED = 0x0004,
156  CS_SOURCE_DISCONNECTED = 0x0008,
157  CS_SOURCE_VIDEOMODES_UPDATED = 0x0010,
158  CS_SOURCE_VIDEOMODE_CHANGED = 0x0020,
159  CS_SOURCE_PROPERTY_CREATED = 0x0040,
160  CS_SOURCE_PROPERTY_VALUE_UPDATED = 0x0080,
161  CS_SOURCE_PROPERTY_CHOICES_UPDATED = 0x0100,
162  CS_SINK_SOURCE_CHANGED = 0x0200,
163  CS_SINK_CREATED = 0x0400,
164  CS_SINK_DESTROYED = 0x0800,
165  CS_SINK_ENABLED = 0x1000,
166  CS_SINK_DISABLED = 0x2000,
167  CS_NETWORK_INTERFACES_CHANGED = 0x4000,
168  CS_TELEMETRY_UPDATED = 0x8000,
169  CS_SINK_PROPERTY_CREATED = 0x10000,
170  CS_SINK_PROPERTY_VALUE_UPDATED = 0x20000,
171  CS_SINK_PROPERTY_CHOICES_UPDATED = 0x40000
172 };
173 
178  CS_SOURCE_BYTES_RECEIVED = 1,
179  CS_SOURCE_FRAMES_RECEIVED = 2
180 };
181 
189 
195 
201 };
202 
206 struct CS_Event {
207  enum CS_EventKind kind;
208 
209  // Valid for CS_SOURCE_* and CS_SINK_* respectively
210  CS_Source source;
211  CS_Sink sink;
212 
213  // Source/sink/property name
214  const char* name;
215 
216  // Fields for CS_SOURCE_VIDEOMODE_CHANGED event
217  CS_VideoMode mode;
218 
219  // Fields for CS_SOURCE_PROPERTY_* events
220  CS_Property property;
221  enum CS_PropertyKind propertyKind;
222  int value;
223  const char* valueStr;
224 };
225 
229 typedef struct CS_UsbCameraInfo {
230  int dev;
231  char* path;
232  char* name;
233  int otherPathsCount;
234  char** otherPaths;
236 
241 enum CS_PropertyKind CS_GetPropertyKind(CS_Property property,
242  CS_Status* status);
243 char* CS_GetPropertyName(CS_Property property, CS_Status* status);
244 int CS_GetProperty(CS_Property property, CS_Status* status);
245 void CS_SetProperty(CS_Property property, int value, CS_Status* status);
246 int CS_GetPropertyMin(CS_Property property, CS_Status* status);
247 int CS_GetPropertyMax(CS_Property property, CS_Status* status);
248 int CS_GetPropertyStep(CS_Property property, CS_Status* status);
249 int CS_GetPropertyDefault(CS_Property property, CS_Status* status);
250 char* CS_GetStringProperty(CS_Property property, CS_Status* status);
251 void CS_SetStringProperty(CS_Property property, const char* value,
252  CS_Status* status);
253 char** CS_GetEnumPropertyChoices(CS_Property property, int* count,
254  CS_Status* status);
261 CS_Source CS_CreateUsbCameraDev(const char* name, int dev, CS_Status* status);
262 CS_Source CS_CreateUsbCameraPath(const char* name, const char* path,
263  CS_Status* status);
264 CS_Source CS_CreateHttpCamera(const char* name, const char* url,
265  enum CS_HttpCameraKind kind, CS_Status* status);
266 CS_Source CS_CreateHttpCameraMulti(const char* name, const char** urls,
267  int count, enum CS_HttpCameraKind kind,
268  CS_Status* status);
269 CS_Source CS_CreateCvSource(const char* name, const CS_VideoMode* mode,
270  CS_Status* status);
277 enum CS_SourceKind CS_GetSourceKind(CS_Source source, CS_Status* status);
278 char* CS_GetSourceName(CS_Source source, CS_Status* status);
279 char* CS_GetSourceDescription(CS_Source source, CS_Status* status);
280 uint64_t CS_GetSourceLastFrameTime(CS_Source source, CS_Status* status);
281 void CS_SetSourceConnectionStrategy(CS_Source source,
282  enum CS_ConnectionStrategy strategy,
283  CS_Status* status);
284 CS_Bool CS_IsSourceConnected(CS_Source source, CS_Status* status);
285 CS_Bool CS_IsSourceEnabled(CS_Source source, CS_Status* status);
286 CS_Property CS_GetSourceProperty(CS_Source source, const char* name,
287  CS_Status* status);
288 CS_Property* CS_EnumerateSourceProperties(CS_Source source, int* count,
289  CS_Status* status);
290 void CS_GetSourceVideoMode(CS_Source source, CS_VideoMode* mode,
291  CS_Status* status);
292 CS_Bool CS_SetSourceVideoMode(CS_Source source, const CS_VideoMode* mode,
293  CS_Status* status);
294 CS_Bool CS_SetSourceVideoModeDiscrete(CS_Source source,
295  enum CS_PixelFormat pixelFormat,
296  int width, int height, int fps,
297  CS_Status* status);
298 CS_Bool CS_SetSourcePixelFormat(CS_Source source,
299  enum CS_PixelFormat pixelFormat,
300  CS_Status* status);
301 CS_Bool CS_SetSourceResolution(CS_Source source, int width, int height,
302  CS_Status* status);
303 CS_Bool CS_SetSourceFPS(CS_Source source, int fps, CS_Status* status);
304 CS_Bool CS_SetSourceConfigJson(CS_Source source, const char* config,
305  CS_Status* status);
306 char* CS_GetSourceConfigJson(CS_Source source, CS_Status* status);
307 CS_VideoMode* CS_EnumerateSourceVideoModes(CS_Source source, int* count,
308  CS_Status* status);
309 CS_Sink* CS_EnumerateSourceSinks(CS_Source source, int* count,
310  CS_Status* status);
311 CS_Source CS_CopySource(CS_Source source, CS_Status* status);
312 void CS_ReleaseSource(CS_Source source, CS_Status* status);
319 void CS_SetCameraBrightness(CS_Source source, int brightness,
320  CS_Status* status);
321 int CS_GetCameraBrightness(CS_Source source, CS_Status* status);
322 void CS_SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
323 void CS_SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
324 void CS_SetCameraWhiteBalanceManual(CS_Source source, int value,
325  CS_Status* status);
326 void CS_SetCameraExposureAuto(CS_Source source, CS_Status* status);
327 void CS_SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
328 void CS_SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
335 char* CS_GetUsbCameraPath(CS_Source source, CS_Status* status);
336 CS_UsbCameraInfo* CS_GetUsbCameraInfo(CS_Source source, CS_Status* status);
343 enum CS_HttpCameraKind CS_GetHttpCameraKind(CS_Source source,
344  CS_Status* status);
345 void CS_SetHttpCameraUrls(CS_Source source, const char** urls, int count,
346  CS_Status* status);
347 char** CS_GetHttpCameraUrls(CS_Source source, int* count, CS_Status* status);
354 void CS_PutSourceFrame(CS_Source source, struct CvMat* image,
355  CS_Status* status);
356 void CS_NotifySourceError(CS_Source source, const char* msg, CS_Status* status);
357 void CS_SetSourceConnected(CS_Source source, CS_Bool connected,
358  CS_Status* status);
359 void CS_SetSourceDescription(CS_Source source, const char* description,
360  CS_Status* status);
361 CS_Property CS_CreateSourceProperty(CS_Source source, const char* name,
362  enum CS_PropertyKind kind, int minimum,
363  int maximum, int step, int defaultValue,
364  int value, CS_Status* status);
365 void CS_SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
366  const char** choices, int count,
367  CS_Status* status);
374 CS_Sink CS_CreateMjpegServer(const char* name, const char* listenAddress,
375  int port, CS_Status* status);
376 CS_Sink CS_CreateCvSink(const char* name, CS_Status* status);
377 CS_Sink CS_CreateCvSinkCallback(const char* name, void* data,
378  void (*processFrame)(void* data, uint64_t time),
379  CS_Status* status);
386 enum CS_SinkKind CS_GetSinkKind(CS_Sink sink, CS_Status* status);
387 char* CS_GetSinkName(CS_Sink sink, CS_Status* status);
388 char* CS_GetSinkDescription(CS_Sink sink, CS_Status* status);
389 CS_Property CS_GetSinkProperty(CS_Sink sink, const char* name,
390  CS_Status* status);
391 CS_Property* CS_EnumerateSinkProperties(CS_Sink sink, int* count,
392  CS_Status* status);
393 void CS_SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
394 CS_Property CS_GetSinkSourceProperty(CS_Sink sink, const char* name,
395  CS_Status* status);
396 CS_Source CS_GetSinkSource(CS_Sink sink, CS_Status* status);
397 CS_Sink CS_CopySink(CS_Sink sink, CS_Status* status);
398 void CS_ReleaseSink(CS_Sink sink, CS_Status* status);
405 char* CS_GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
406 int CS_GetMjpegServerPort(CS_Sink sink, CS_Status* status);
413 void CS_SetSinkDescription(CS_Sink sink, const char* description,
414  CS_Status* status);
415 uint64_t CS_GrabSinkFrame(CS_Sink sink, struct CvMat* image, CS_Status* status);
416 uint64_t CS_GrabSinkFrameTimeout(CS_Sink sink, struct CvMat* image,
417  double timeout, CS_Status* status);
418 char* CS_GetSinkError(CS_Sink sink, CS_Status* status);
419 void CS_SetSinkEnabled(CS_Sink sink, CS_Bool enabled, CS_Status* status);
426 void CS_SetListenerOnStart(void (*onStart)(void* data), void* data);
427 void CS_SetListenerOnExit(void (*onExit)(void* data), void* data);
428 CS_Listener CS_AddListener(
429  void* data, void (*callback)(void* data, const struct CS_Event* event),
430  int eventMask, int immediateNotify, CS_Status* status);
431 
432 void CS_RemoveListener(CS_Listener handle, CS_Status* status);
435 int CS_NotifierDestroyed(void);
436 
441 void CS_SetTelemetryPeriod(double seconds);
442 double CS_GetTelemetryElapsedTime(void);
443 int64_t CS_GetTelemetryValue(CS_Handle handle, enum CS_TelemetryKind kind,
444  CS_Status* status);
445 double CS_GetTelemetryAverageValue(CS_Handle handle, enum CS_TelemetryKind kind,
446  CS_Status* status);
453 typedef void (*CS_LogFunc)(unsigned int level, const char* file,
454  unsigned int line, const char* msg);
455 void CS_SetLogger(CS_LogFunc func, unsigned int min_level);
456 void CS_SetDefaultLogger(unsigned int min_level);
463 void CS_Shutdown(void);
471 CS_UsbCameraInfo* CS_EnumerateUsbCameras(int* count, CS_Status* status);
472 void CS_FreeEnumeratedUsbCameras(CS_UsbCameraInfo* cameras, int count);
473 
474 CS_Source* CS_EnumerateSources(int* count, CS_Status* status);
475 void CS_ReleaseEnumeratedSources(CS_Source* sources, int count);
476 
477 CS_Sink* CS_EnumerateSinks(int* count, CS_Status* status);
478 void CS_ReleaseEnumeratedSinks(CS_Sink* sinks, int count);
479 
480 void CS_FreeString(char* str);
481 void CS_FreeEnumPropertyChoices(char** choices, int count);
482 void CS_FreeUsbCameraInfo(CS_UsbCameraInfo* info);
483 void CS_FreeHttpCameraUrls(char** urls, int count);
484 
485 void CS_FreeEnumeratedProperties(CS_Property* properties, int count);
486 void CS_FreeEnumeratedVideoModes(CS_VideoMode* modes, int count);
487 
488 char* CS_GetHostname();
489 
490 char** CS_GetNetworkInterfaces(int* count);
491 void CS_FreeNetworkInterfaces(char** interfaces, int count);
496 #ifdef __cplusplus
497 } // extern "C"
498 #endif
499 
500 #endif // CSCORE_CSCORE_C_H_
CS_StatusValue
Status values.
Definition: cscore_c.h:61
CS_PixelFormat
Pixel formats.
Definition: cscore_c.h:94
CS_TelemetryKind
Telemetry kinds.
Definition: cscore_c.h:177
Try to keep the connection open regardless of whether any sinks are connected.
Definition: cscore_c.h:194
CS_LogLevel
Logging levels.
Definition: cscore_c.h:79
struct CS_VideoMode CS_VideoMode
Video mode.
CS_HttpCameraKind
HTTP Camera kinds.
Definition: cscore_c.h:137
CS_SinkKind
Sink kinds.
Definition: cscore_c.h:147
USB camera infomation.
Definition: cscore_c.h:229
Never open the connection.
Definition: cscore_c.h:200
Automatically connect or disconnect based on whether any sinks are connected to this source...
Definition: cscore_c.h:188
CS_ConnectionStrategy
Connection strategy.
Definition: cscore_c.h:183
CS_SourceKind
Source kinds.
Definition: cscore_c.h:127
CS_PropertyKind
Property kinds.
Definition: cscore_c.h:116
CS_EventKind
Listener event kinds.
Definition: cscore_c.h:152
Listener event.
Definition: cscore_c.h:206
struct CS_UsbCameraInfo CS_UsbCameraInfo
USB camera infomation.
Video mode.
Definition: cscore_c.h:106