WPILibC++  unspecified
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 
25 //
26 // The C API is handle-based. Sources and sinks are reference counted
27 // internally to the library. Any time a source or sink handle is returned
28 // or provided to a callback, the reference count is incremented.
29 // Calling CS_ReleaseSource() or CS_ReleaseSink() decrements the reference
30 // count, and when the reference count reaches zero, the object is destroyed.
31 // Connecting a source to a sink increments the reference count of the source,
32 // and when the sink is destroyed (its reference count reaches zero), the
33 // source reference count is decremented.
34 //
35 
36 //
37 // Typedefs
38 //
39 typedef int CS_Bool;
40 typedef int CS_Status;
41 
42 typedef int CS_Handle;
43 typedef CS_Handle CS_Property;
44 typedef CS_Handle CS_Listener;
45 typedef CS_Handle CS_Sink;
46 typedef CS_Handle CS_Source;
47 
48 //
49 // Status values
50 //
51 enum CS_StatusValue {
52  CS_PROPERTY_WRITE_FAILED = 2000,
53  CS_OK = 0,
54  CS_INVALID_HANDLE = -2000, // handle was invalid (does not exist)
55  CS_WRONG_HANDLE_SUBTYPE = -2001,
56  CS_INVALID_PROPERTY = -2002,
57  CS_WRONG_PROPERTY_TYPE = -2003,
58  CS_READ_FAILED = -2004,
59  CS_SOURCE_IS_DISCONNECTED = -2005,
60  CS_EMPTY_VALUE = -2006,
61  CS_BAD_URL = -2007,
62  CS_TELEMETRY_NOT_ENABLED = -2008
63 };
64 
65 //
66 // Logging levels
67 //
68 enum CS_LogLevel {
69  CS_LOG_CRITICAL = 50,
70  CS_LOG_ERROR = 40,
71  CS_LOG_WARNING = 30,
72  CS_LOG_INFO = 20,
73  CS_LOG_DEBUG = 10,
74  CS_LOG_DEBUG1 = 9,
75  CS_LOG_DEBUG2 = 8,
76  CS_LOG_DEBUG3 = 7,
77  CS_LOG_DEBUG4 = 6
78 };
79 
80 //
81 // Pixel formats
82 //
83 enum CS_PixelFormat {
84  CS_PIXFMT_UNKNOWN = 0,
85  CS_PIXFMT_MJPEG,
86  CS_PIXFMT_YUYV,
87  CS_PIXFMT_RGB565,
88  CS_PIXFMT_BGR,
89  CS_PIXFMT_GRAY
90 };
91 
92 //
93 // Frame formats
94 //
95 typedef struct CS_VideoMode {
96  int pixelFormat;
97  int width;
98  int height;
99  int fps;
100 } CS_VideoMode;
101 
102 //
103 // Property kinds
104 //
105 enum CS_PropertyKind {
106  CS_PROP_NONE = 0,
107  CS_PROP_BOOLEAN = 1,
108  CS_PROP_INTEGER = 2,
109  CS_PROP_STRING = 4,
110  CS_PROP_ENUM = 8
111 };
112 
113 //
114 // Source kinds
115 //
116 enum CS_SourceKind {
117  CS_SOURCE_UNKNOWN = 0,
118  CS_SOURCE_USB = 1,
119  CS_SOURCE_HTTP = 2,
120  CS_SOURCE_CV = 4
121 };
122 
123 //
124 // HTTP Camera kinds
125 //
126 enum CS_HttpCameraKind {
127  CS_HTTP_UNKNOWN = 0,
128  CS_HTTP_MJPGSTREAMER = 1,
129  CS_HTTP_CSCORE = 2,
130  CS_HTTP_AXIS = 3
131 };
132 
133 //
134 // Sink kinds
135 //
136 enum CS_SinkKind { CS_SINK_UNKNOWN = 0, CS_SINK_MJPEG = 2, CS_SINK_CV = 4 };
137 
138 //
139 // Listener event kinds
140 //
141 enum CS_EventKind {
142  CS_SOURCE_CREATED = 0x0001,
143  CS_SOURCE_DESTROYED = 0x0002,
144  CS_SOURCE_CONNECTED = 0x0004,
145  CS_SOURCE_DISCONNECTED = 0x0008,
146  CS_SOURCE_VIDEOMODES_UPDATED = 0x0010,
147  CS_SOURCE_VIDEOMODE_CHANGED = 0x0020,
148  CS_SOURCE_PROPERTY_CREATED = 0x0040,
149  CS_SOURCE_PROPERTY_VALUE_UPDATED = 0x0080,
150  CS_SOURCE_PROPERTY_CHOICES_UPDATED = 0x0100,
151  CS_SINK_SOURCE_CHANGED = 0x0200,
152  CS_SINK_CREATED = 0x0400,
153  CS_SINK_DESTROYED = 0x0800,
154  CS_SINK_ENABLED = 0x1000,
155  CS_SINK_DISABLED = 0x2000,
156  CS_NETWORK_INTERFACES_CHANGED = 0x4000,
157  CS_TELEMETRY_UPDATED = 0x8000
158 };
159 
160 //
161 // Telemetry kinds
162 //
163 enum CS_TelemetryKind {
164  CS_SOURCE_BYTES_RECEIVED = 1,
165  CS_SOURCE_FRAMES_RECEIVED = 2
166 };
167 
168 //
169 // Listener event
170 //
171 struct CS_Event {
172  CS_EventKind kind;
173 
174  // Valid for CS_SOURCE_* and CS_SINK_* respectively
175  CS_Source source;
176  CS_Sink sink;
177 
178  // Source/sink/property name
179  const char* name;
180 
181  // Fields for CS_SOURCE_VIDEOMODE_CHANGED event
182  CS_VideoMode mode;
183 
184  // Fields for CS_SOURCE_PROPERTY_* events
185  CS_Property property;
186  CS_PropertyKind propertyKind;
187  int value;
188  const char* valueStr;
189 };
190 
191 //
192 // Property Functions
193 //
194 enum CS_PropertyKind CS_GetPropertyKind(CS_Property property,
195  CS_Status* status);
196 char* CS_GetPropertyName(CS_Property property, CS_Status* status);
197 int CS_GetProperty(CS_Property property, CS_Status* status);
198 void CS_SetProperty(CS_Property property, int value, CS_Status* status);
199 int CS_GetPropertyMin(CS_Property property, CS_Status* status);
200 int CS_GetPropertyMax(CS_Property property, CS_Status* status);
201 int CS_GetPropertyStep(CS_Property property, CS_Status* status);
202 int CS_GetPropertyDefault(CS_Property property, CS_Status* status);
203 char* CS_GetStringProperty(CS_Property property, CS_Status* status);
204 void CS_SetStringProperty(CS_Property property, const char* value,
205  CS_Status* status);
206 char** CS_GetEnumPropertyChoices(CS_Property property, int* count,
207  CS_Status* status);
208 
209 //
210 // Source Creation Functions
211 //
212 CS_Source CS_CreateUsbCameraDev(const char* name, int dev, CS_Status* status);
213 CS_Source CS_CreateUsbCameraPath(const char* name, const char* path,
214  CS_Status* status);
215 CS_Source CS_CreateHttpCamera(const char* name, const char* url,
216  enum CS_HttpCameraKind kind, CS_Status* status);
217 CS_Source CS_CreateHttpCameraMulti(const char* name, const char** urls,
218  int count, enum CS_HttpCameraKind kind,
219  CS_Status* status);
220 CS_Source CS_CreateCvSource(const char* name, const CS_VideoMode* mode,
221  CS_Status* status);
222 
223 //
224 // Source Functions
225 //
226 CS_SourceKind CS_GetSourceKind(CS_Source source, CS_Status* status);
227 char* CS_GetSourceName(CS_Source source, CS_Status* status);
228 char* CS_GetSourceDescription(CS_Source source, CS_Status* status);
229 uint64_t CS_GetSourceLastFrameTime(CS_Source source, CS_Status* status);
230 CS_Bool CS_IsSourceConnected(CS_Source source, CS_Status* status);
231 CS_Property CS_GetSourceProperty(CS_Source source, const char* name,
232  CS_Status* status);
233 CS_Property* CS_EnumerateSourceProperties(CS_Source source, int* count,
234  CS_Status* status);
235 void CS_GetSourceVideoMode(CS_Source source, CS_VideoMode* mode,
236  CS_Status* status);
237 CS_Bool CS_SetSourceVideoMode(CS_Source source, const CS_VideoMode* mode,
238  CS_Status* status);
239 CS_Bool CS_SetSourceVideoModeDiscrete(CS_Source source,
240  enum CS_PixelFormat pixelFormat,
241  int width, int height, int fps,
242  CS_Status* status);
243 CS_Bool CS_SetSourcePixelFormat(CS_Source source,
244  enum CS_PixelFormat pixelFormat,
245  CS_Status* status);
246 CS_Bool CS_SetSourceResolution(CS_Source source, int width, int height,
247  CS_Status* status);
248 CS_Bool CS_SetSourceFPS(CS_Source source, int fps, CS_Status* status);
249 CS_VideoMode* CS_EnumerateSourceVideoModes(CS_Source source, int* count,
250  CS_Status* status);
251 CS_Sink* CS_EnumerateSourceSinks(CS_Source source, int* count,
252  CS_Status* status);
253 CS_Source CS_CopySource(CS_Source source, CS_Status* status);
254 void CS_ReleaseSource(CS_Source source, CS_Status* status);
255 
256 //
257 // Camera Source Common Property Fuctions
258 //
259 void CS_SetCameraBrightness(CS_Source source, int brightness,
260  CS_Status* status);
261 int CS_GetCameraBrightness(CS_Source source, CS_Status* status);
262 void CS_SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
263 void CS_SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
264 void CS_SetCameraWhiteBalanceManual(CS_Source source, int value,
265  CS_Status* status);
266 void CS_SetCameraExposureAuto(CS_Source source, CS_Status* status);
267 void CS_SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
268 void CS_SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
269 
270 //
271 // UsbCamera Source Functions
272 //
273 char* CS_GetUsbCameraPath(CS_Source source, CS_Status* status);
274 
275 //
276 // HttpCamera Source Functions
277 //
278 CS_HttpCameraKind CS_GetHttpCameraKind(CS_Source source, CS_Status* status);
279 void CS_SetHttpCameraUrls(CS_Source source, const char** urls, int count,
280  CS_Status* status);
281 char** CS_GetHttpCameraUrls(CS_Source source, int* count, CS_Status* status);
282 
283 //
284 // OpenCV Source Functions
285 //
286 void CS_PutSourceFrame(CS_Source source, struct CvMat* image,
287  CS_Status* status);
288 void CS_NotifySourceError(CS_Source source, const char* msg, CS_Status* status);
289 void CS_SetSourceConnected(CS_Source source, CS_Bool connected,
290  CS_Status* status);
291 void CS_SetSourceDescription(CS_Source source, const char* description,
292  CS_Status* status);
293 CS_Property CS_CreateSourceProperty(CS_Source source, const char* name,
294  enum CS_PropertyKind kind, int minimum,
295  int maximum, int step, int defaultValue,
296  int value, CS_Status* status);
297 void CS_SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
298  const char** choices, int count,
299  CS_Status* status);
300 
301 //
302 // Sink Creation Functions
303 //
304 CS_Sink CS_CreateMjpegServer(const char* name, const char* listenAddress,
305  int port, CS_Status* status);
306 CS_Sink CS_CreateCvSink(const char* name, CS_Status* status);
307 CS_Sink CS_CreateCvSinkCallback(const char* name, void* data,
308  void (*processFrame)(void* data, uint64_t time),
309  CS_Status* status);
310 
311 //
312 // Sink Functions
313 //
314 CS_SinkKind CS_GetSinkKind(CS_Sink sink, CS_Status* status);
315 char* CS_GetSinkName(CS_Sink sink, CS_Status* status);
316 char* CS_GetSinkDescription(CS_Sink sink, CS_Status* status);
317 void CS_SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
318 CS_Property CS_GetSinkSourceProperty(CS_Sink sink, const char* name,
319  CS_Status* status);
320 CS_Source CS_GetSinkSource(CS_Sink sink, CS_Status* status);
321 CS_Sink CS_CopySink(CS_Sink sink, CS_Status* status);
322 void CS_ReleaseSink(CS_Sink sink, CS_Status* status);
323 
324 //
325 // MjpegServer Sink Functions
326 //
327 char* CS_GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
328 int CS_GetMjpegServerPort(CS_Sink sink, CS_Status* status);
329 
330 //
331 // OpenCV Sink Functions
332 //
333 void CS_SetSinkDescription(CS_Sink sink, const char* description,
334  CS_Status* status);
335 uint64_t CS_GrabSinkFrame(CS_Sink sink, struct CvMat* image, CS_Status* status);
336 uint64_t CS_GrabSinkFrameTimeout(CS_Sink sink, struct CvMat* image,
337  double timeout, CS_Status* status);
338 char* CS_GetSinkError(CS_Sink sink, CS_Status* status);
339 void CS_SetSinkEnabled(CS_Sink sink, CS_Bool enabled, CS_Status* status);
340 
341 //
342 // Listener Functions
343 //
344 void CS_SetListenerOnStart(void (*onStart)(void* data), void* data);
345 void CS_SetListenerOnExit(void (*onExit)(void* data), void* data);
346 CS_Listener CS_AddListener(void* data,
347  void (*callback)(void* data, const CS_Event* event),
348  int eventMask, int immediateNotify,
349  CS_Status* status);
350 
351 void CS_RemoveListener(CS_Listener handle, CS_Status* status);
352 
353 int CS_NotifierDestroyed(void);
354 
355 //
356 // Telemetry Functions
357 //
358 void CS_SetTelemetryPeriod(double seconds);
359 double CS_GetTelemetryElapsedTime(void);
360 int64_t CS_GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
361  CS_Status* status);
362 double CS_GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
363  CS_Status* status);
364 
365 //
366 // Logging Functions
367 //
368 typedef void (*CS_LogFunc)(unsigned int level, const char* file,
369  unsigned int line, const char* msg);
370 void CS_SetLogger(CS_LogFunc func, unsigned int min_level);
371 void CS_SetDefaultLogger(unsigned int min_level);
372 
373 //
374 // Utility Functions
375 //
376 typedef struct CS_UsbCameraInfo {
377  int dev;
378  char* path;
379  char* name;
381 
382 CS_UsbCameraInfo* CS_EnumerateUsbCameras(int* count, CS_Status* status);
383 void CS_FreeEnumeratedUsbCameras(CS_UsbCameraInfo* cameras, int count);
384 
385 CS_Source* CS_EnumerateSources(int* count, CS_Status* status);
386 void CS_ReleaseEnumeratedSources(CS_Source* sources, int count);
387 
388 CS_Sink* CS_EnumerateSinks(int* count, CS_Status* status);
389 void CS_ReleaseEnumeratedSinks(CS_Sink* sinks, int count);
390 
391 void CS_FreeString(char* str);
392 void CS_FreeEnumPropertyChoices(char** choices, int count);
393 void CS_FreeHttpCameraUrls(char** urls, int count);
394 
395 void CS_FreeEnumeratedProperties(CS_Property* properties, int count);
396 void CS_FreeEnumeratedVideoModes(CS_VideoMode* modes, int count);
397 
398 char* CS_GetHostname();
399 
400 char** CS_GetNetworkInterfaces(int* count);
401 void CS_FreeNetworkInterfaces(char** interfaces, int count);
402 
403 #ifdef __cplusplus
404 } // extern "C"
405 #endif
406 
407 #endif // CSCORE_CSCORE_C_H_
Definition: cscore_c.h:376
Definition: cscore_c.h:171
Definition: cscore_c.h:95