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