WPILibC++  unspecified
cscore_cpp.h
1 /*----------------------------------------------------------------------------*/
2 /* Copyright (c) 2015-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_CPP_H_
9 #define CSCORE_CSCORE_CPP_H_
10 
11 #include <stdint.h>
12 
13 #include <functional>
14 #include <string>
15 #include <vector>
16 
17 #include <wpi/ArrayRef.h>
18 #include <wpi/SmallVector.h>
19 #include <wpi/StringRef.h>
20 
21 #include "cscore_c.h"
22 
23 namespace cv {
24 class Mat;
25 } // namespace cv
26 
27 namespace cs {
28 
29 //
30 // Handle-based interface for C++. Users are encouraged to use the
31 // object oriented interface instead; this interface is intended for use
32 // in applications such as JNI which require handle-based access.
33 //
34 
36 struct UsbCameraInfo {
38  int dev;
40  std::string path;
42  std::string name;
43 };
44 
46 struct VideoMode : public CS_VideoMode {
47  enum PixelFormat {
48  kUnknown = CS_PIXFMT_UNKNOWN,
49  kMJPEG = CS_PIXFMT_MJPEG,
50  kYUYV = CS_PIXFMT_YUYV,
51  kRGB565 = CS_PIXFMT_RGB565,
52  kBGR = CS_PIXFMT_BGR,
53  kGray = CS_PIXFMT_GRAY
54  };
55  VideoMode() {
56  pixelFormat = 0;
57  width = 0;
58  height = 0;
59  fps = 0;
60  }
61  VideoMode(PixelFormat pixelFormat_, int width_, int height_, int fps_) {
62  pixelFormat = pixelFormat_;
63  width = width_;
64  height = height_;
65  fps = fps_;
66  }
67  explicit operator bool() const { return pixelFormat == kUnknown; }
68 };
69 
71 struct RawEvent {
72  enum Kind {
73  kSourceCreated = CS_SOURCE_CREATED,
74  kSourceDestroyed = CS_SOURCE_DESTROYED,
75  kSourceConnected = CS_SOURCE_CONNECTED,
76  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
77  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
78  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
79  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
80  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
81  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
82  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
83  kSinkCreated = CS_SINK_CREATED,
84  kSinkDestroyed = CS_SINK_DESTROYED,
85  kSinkEnabled = CS_SINK_ENABLED,
86  kSinkDisabled = CS_SINK_DISABLED,
87  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED,
88  kTelemetryUpdated = CS_TELEMETRY_UPDATED
89  };
90 
91  RawEvent() = default;
92  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
93  RawEvent(wpi::StringRef name_, CS_Handle handle_, RawEvent::Kind kind_)
94  : kind{kind_}, name{name_} {
95  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
96  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
97  sinkHandle = handle_;
98  else
99  sourceHandle = handle_;
100  }
101  RawEvent(wpi::StringRef name_, CS_Source source_, const VideoMode& mode_)
102  : kind{kSourceVideoModeChanged},
103  sourceHandle{source_},
104  name{name_},
105  mode{mode_} {}
106  RawEvent(wpi::StringRef name_, CS_Source source_, RawEvent::Kind kind_,
107  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
108  wpi::StringRef valueStr_)
109  : kind{kind_},
110  sourceHandle{source_},
111  name{name_},
112  propertyHandle{property_},
113  propertyKind{propertyKind_},
114  value{value_},
115  valueStr{valueStr_} {}
116 
117  Kind kind;
118 
119  // Valid for kSource* and kSink* respectively
120  CS_Source sourceHandle = CS_INVALID_HANDLE;
121  CS_Sink sinkHandle = CS_INVALID_HANDLE;
122 
123  // Source/sink/property name
124  std::string name;
125 
126  // Fields for kSourceVideoModeChanged event
127  VideoMode mode;
128 
129  // Fields for kSourceProperty* events
130  CS_Property propertyHandle;
131  CS_PropertyKind propertyKind;
132  int value;
133  std::string valueStr;
134 };
135 
136 //
137 // Property Functions
138 //
139 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
140 std::string GetPropertyName(CS_Property property, CS_Status* status);
141 wpi::StringRef GetPropertyName(CS_Property property,
143  CS_Status* status);
144 int GetProperty(CS_Property property, CS_Status* status);
145 void SetProperty(CS_Property property, int value, CS_Status* status);
146 int GetPropertyMin(CS_Property property, CS_Status* status);
147 int GetPropertyMax(CS_Property property, CS_Status* status);
148 int GetPropertyStep(CS_Property property, CS_Status* status);
149 int GetPropertyDefault(CS_Property property, CS_Status* status);
150 std::string GetStringProperty(CS_Property property, CS_Status* status);
151 wpi::StringRef GetStringProperty(CS_Property property,
153  CS_Status* status);
154 void SetStringProperty(CS_Property property, wpi::StringRef value,
155  CS_Status* status);
156 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
157  CS_Status* status);
158 
159 //
160 // Source Creation Functions
161 //
162 CS_Source CreateUsbCameraDev(wpi::StringRef name, int dev, CS_Status* status);
163 CS_Source CreateUsbCameraPath(wpi::StringRef name, wpi::StringRef path,
164  CS_Status* status);
165 CS_Source CreateHttpCamera(wpi::StringRef name, wpi::StringRef url,
166  CS_HttpCameraKind kind, CS_Status* status);
167 CS_Source CreateHttpCamera(wpi::StringRef name, wpi::ArrayRef<std::string> urls,
168  CS_HttpCameraKind kind, CS_Status* status);
169 CS_Source CreateCvSource(wpi::StringRef name, const VideoMode& mode,
170  CS_Status* status);
171 
172 //
173 // Source Functions
174 //
175 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
176 std::string GetSourceName(CS_Source source, CS_Status* status);
177 wpi::StringRef GetSourceName(CS_Source source, wpi::SmallVectorImpl<char>& buf,
178  CS_Status* status);
179 std::string GetSourceDescription(CS_Source source, CS_Status* status);
180 wpi::StringRef GetSourceDescription(CS_Source source,
182  CS_Status* status);
183 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
184 bool IsSourceConnected(CS_Source source, CS_Status* status);
185 CS_Property GetSourceProperty(CS_Source source, wpi::StringRef name,
186  CS_Status* status);
187 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
188  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
189  CS_Status* status);
190 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
191 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
192  CS_Status* status);
193 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
194  CS_Status* status);
195 bool SetSourceResolution(CS_Source source, int width, int height,
196  CS_Status* status);
197 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
198 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
199  CS_Status* status);
200 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
202  CS_Status* status);
203 CS_Source CopySource(CS_Source source, CS_Status* status);
204 void ReleaseSource(CS_Source source, CS_Status* status);
205 
206 //
207 // Camera Source Common Property Fuctions
208 //
209 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
210 int GetCameraBrightness(CS_Source source, CS_Status* status);
211 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
212 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
213 void SetCameraWhiteBalanceManual(CS_Source source, int value,
214  CS_Status* status);
215 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
216 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
217 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
218 
219 //
220 // UsbCamera Source Functions
221 //
222 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
223 
224 //
225 // HttpCamera Source Functions
226 //
227 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
228 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
229  CS_Status* status);
230 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
231 
232 //
233 // OpenCV Source Functions
234 //
235 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
236 void NotifySourceError(CS_Source source, wpi::StringRef msg, CS_Status* status);
237 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
238 void SetSourceDescription(CS_Source source, wpi::StringRef description,
239  CS_Status* status);
240 CS_Property CreateSourceProperty(CS_Source source, wpi::StringRef name,
241  CS_PropertyKind kind, int minimum, int maximum,
242  int step, int defaultValue, int value,
243  CS_Status* status);
244 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
246  CS_Status* status);
247 
248 //
249 // Sink Creation Functions
250 //
251 CS_Sink CreateMjpegServer(wpi::StringRef name, wpi::StringRef listenAddress,
252  int port, CS_Status* status);
253 CS_Sink CreateCvSink(wpi::StringRef name, CS_Status* status);
254 CS_Sink CreateCvSinkCallback(wpi::StringRef name,
255  std::function<void(uint64_t time)> processFrame,
256  CS_Status* status);
257 
258 //
259 // Sink Functions
260 //
261 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
262 std::string GetSinkName(CS_Sink sink, CS_Status* status);
263 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
264  CS_Status* status);
265 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
266 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
267  CS_Status* status);
268 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
269 CS_Property GetSinkSourceProperty(CS_Sink sink, wpi::StringRef name,
270  CS_Status* status);
271 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
272 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
273 void ReleaseSink(CS_Sink sink, CS_Status* status);
274 
275 //
276 // MjpegServer Sink Functions
277 //
278 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
279 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
280 
281 //
282 // OpenCV Sink Functions
283 //
284 void SetSinkDescription(CS_Sink sink, wpi::StringRef description,
285  CS_Status* status);
286 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
287 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
288  CS_Status* status);
289 std::string GetSinkError(CS_Sink sink, CS_Status* status);
290 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
291  CS_Status* status);
292 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
293 
294 //
295 // Listener Functions
296 //
297 void SetListenerOnStart(std::function<void()> onStart);
298 void SetListenerOnExit(std::function<void()> onExit);
299 
300 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
301  int eventMask, bool immediateNotify, CS_Status* status);
302 
303 void RemoveListener(CS_Listener handle, CS_Status* status);
304 
305 bool NotifierDestroyed();
306 
307 //
308 // Telemetry Functions
309 //
310 void SetTelemetryPeriod(double seconds);
311 double GetTelemetryElapsedTime();
312 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
313  CS_Status* status);
314 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
315  CS_Status* status);
316 
317 //
318 // Logging Functions
319 //
320 typedef std::function<void(unsigned int level, const char* file,
321  unsigned int line, const char* msg)>
322  LogFunc;
323 void SetLogger(LogFunc func, unsigned int min_level);
324 void SetDefaultLogger(unsigned int min_level);
325 
326 //
327 // Utility Functions
328 //
329 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
330 
331 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
332  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
333 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
334  CS_Status* status);
335 
336 std::string GetHostname();
337 
338 std::vector<std::string> GetNetworkInterfaces();
339 
340 } // namespace cs
341 
342 // C functions taking a cv::Mat* for specific interop implementations
343 extern "C" {
344 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
345 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
346  double timeout, CS_Status* status);
347 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
348 } // extern "C"
349 
350 #endif // CSCORE_CSCORE_CPP_H_
Definition: CvSourceImpl.h:19
std::function< void(unsigned int level, const char *file, unsigned int line, const char *msg)> LogFunc
Log function.
Definition: ntcore_cpp.h:1379
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:41
Listener event.
Definition: cscore_cpp.h:71
Definition: cscore_cpp.h:23
void SetLogger(LogFunc func, unsigned int min_level)
Set logger callback function.
Definition: ntcore_cpp.cpp:958
USB camera information.
Definition: cscore_cpp.h:36
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
int dev
Device number (e.g. N in &#39;/dev/videoN&#39; on Linux)
Definition: cscore_cpp.h:38
std::string path
Path to device if available (e.g. &#39;/dev/video0&#39; on Linux)
Definition: cscore_cpp.h:40
std::string name
Vendor/model name of the camera as provided by the USB driver.
Definition: cscore_cpp.h:42
Video mode.
Definition: cscore_cpp.h:46
Definition: cscore_c.h:95