WPILibC++  2019.3.2-1-g99e4f7d
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
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 #include <wpi/Twine.h>
21 
22 #include "cscore_c.h"
23 
24 namespace cv {
25 class Mat;
26 } // namespace cv
27 
28 namespace wpi {
29 class json;
30 } // namespace wpi
31 
33 namespace cs {
34 
48 struct UsbCameraInfo {
50  int dev = -1;
52  std::string path;
54  std::string name;
56  std::vector<std::string> otherPaths;
57 };
58 
62 struct VideoMode : public CS_VideoMode {
63  enum PixelFormat {
64  kUnknown = CS_PIXFMT_UNKNOWN,
65  kMJPEG = CS_PIXFMT_MJPEG,
66  kYUYV = CS_PIXFMT_YUYV,
67  kRGB565 = CS_PIXFMT_RGB565,
68  kBGR = CS_PIXFMT_BGR,
69  kGray = CS_PIXFMT_GRAY
70  };
71  VideoMode() {
72  pixelFormat = 0;
73  width = 0;
74  height = 0;
75  fps = 0;
76  }
77  VideoMode(PixelFormat pixelFormat_, int width_, int height_, int fps_) {
78  pixelFormat = pixelFormat_;
79  width = width_;
80  height = height_;
81  fps = fps_;
82  }
83  explicit operator bool() const { return pixelFormat == kUnknown; }
84 
85  bool operator==(const VideoMode& other) const {
86  return pixelFormat == other.pixelFormat && width == other.width &&
87  height == other.height && fps == other.fps;
88  }
89 
90  bool operator!=(const VideoMode& other) const { return !(*this == other); }
91 };
92 
96 struct RawEvent {
97  enum Kind {
98  kSourceCreated = CS_SOURCE_CREATED,
99  kSourceDestroyed = CS_SOURCE_DESTROYED,
100  kSourceConnected = CS_SOURCE_CONNECTED,
101  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
102  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
103  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
104  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
105  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
106  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
107  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
108  kSinkCreated = CS_SINK_CREATED,
109  kSinkDestroyed = CS_SINK_DESTROYED,
110  kSinkEnabled = CS_SINK_ENABLED,
111  kSinkDisabled = CS_SINK_DISABLED,
112  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED,
113  kTelemetryUpdated = CS_TELEMETRY_UPDATED,
114  kSinkPropertyCreated = CS_SINK_PROPERTY_CREATED,
115  kSinkPropertyValueUpdated = CS_SINK_PROPERTY_VALUE_UPDATED,
116  kSinkPropertyChoicesUpdated = CS_SINK_PROPERTY_CHOICES_UPDATED
117  };
118 
119  RawEvent() = default;
120  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
121  RawEvent(const wpi::Twine& name_, CS_Handle handle_, RawEvent::Kind kind_)
122  : kind{kind_}, name{name_.str()} {
123  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
124  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
125  sinkHandle = handle_;
126  else
127  sourceHandle = handle_;
128  }
129  RawEvent(const wpi::Twine& name_, CS_Source source_, const VideoMode& mode_)
130  : kind{kSourceVideoModeChanged},
131  sourceHandle{source_},
132  name{name_.str()},
133  mode{mode_} {}
134  RawEvent(const wpi::Twine& name_, CS_Source source_, RawEvent::Kind kind_,
135  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
136  const wpi::Twine& valueStr_)
137  : kind{kind_},
138  sourceHandle{source_},
139  name{name_.str()},
140  propertyHandle{property_},
141  propertyKind{propertyKind_},
142  value{value_},
143  valueStr{valueStr_.str()} {}
144 
145  Kind kind;
146 
147  // Valid for kSource* and kSink* respectively
148  CS_Source sourceHandle = CS_INVALID_HANDLE;
149  CS_Sink sinkHandle = CS_INVALID_HANDLE;
150 
151  // Source/sink/property name
152  std::string name;
153 
154  // Fields for kSourceVideoModeChanged event
155  VideoMode mode;
156 
157  // Fields for kSourceProperty* events
158  CS_Property propertyHandle;
159  CS_PropertyKind propertyKind;
160  int value;
161  std::string valueStr;
162 };
163 
168 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
169 std::string GetPropertyName(CS_Property property, CS_Status* status);
170 wpi::StringRef GetPropertyName(CS_Property property,
172  CS_Status* status);
173 int GetProperty(CS_Property property, CS_Status* status);
174 void SetProperty(CS_Property property, int value, CS_Status* status);
175 int GetPropertyMin(CS_Property property, CS_Status* status);
176 int GetPropertyMax(CS_Property property, CS_Status* status);
177 int GetPropertyStep(CS_Property property, CS_Status* status);
178 int GetPropertyDefault(CS_Property property, CS_Status* status);
179 std::string GetStringProperty(CS_Property property, CS_Status* status);
180 wpi::StringRef GetStringProperty(CS_Property property,
182  CS_Status* status);
183 void SetStringProperty(CS_Property property, const wpi::Twine& value,
184  CS_Status* status);
185 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
186  CS_Status* status);
193 CS_Source CreateUsbCameraDev(const wpi::Twine& name, int dev,
194  CS_Status* status);
195 CS_Source CreateUsbCameraPath(const wpi::Twine& name, const wpi::Twine& path,
196  CS_Status* status);
197 CS_Source CreateHttpCamera(const wpi::Twine& name, const wpi::Twine& url,
198  CS_HttpCameraKind kind, CS_Status* status);
199 CS_Source CreateHttpCamera(const wpi::Twine& name,
201  CS_HttpCameraKind kind, CS_Status* status);
202 CS_Source CreateCvSource(const wpi::Twine& name, const VideoMode& mode,
203  CS_Status* status);
210 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
211 std::string GetSourceName(CS_Source source, CS_Status* status);
212 wpi::StringRef GetSourceName(CS_Source source, wpi::SmallVectorImpl<char>& buf,
213  CS_Status* status);
214 std::string GetSourceDescription(CS_Source source, CS_Status* status);
215 wpi::StringRef GetSourceDescription(CS_Source source,
217  CS_Status* status);
218 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
219 void SetSourceConnectionStrategy(CS_Source source,
220  CS_ConnectionStrategy strategy,
221  CS_Status* status);
222 bool IsSourceConnected(CS_Source source, CS_Status* status);
223 bool IsSourceEnabled(CS_Source source, CS_Status* status);
224 CS_Property GetSourceProperty(CS_Source source, const wpi::Twine& name,
225  CS_Status* status);
226 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
227  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
228  CS_Status* status);
229 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
230 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
231  CS_Status* status);
232 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
233  CS_Status* status);
234 bool SetSourceResolution(CS_Source source, int width, int height,
235  CS_Status* status);
236 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
237 bool SetSourceConfigJson(CS_Source source, wpi::StringRef config,
238  CS_Status* status);
239 bool SetSourceConfigJson(CS_Source source, const wpi::json& config,
240  CS_Status* status);
241 std::string GetSourceConfigJson(CS_Source source, CS_Status* status);
242 wpi::json GetSourceConfigJsonObject(CS_Source source, CS_Status* status);
243 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
244  CS_Status* status);
245 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
247  CS_Status* status);
248 CS_Source CopySource(CS_Source source, CS_Status* status);
249 void ReleaseSource(CS_Source source, CS_Status* status);
256 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
257 int GetCameraBrightness(CS_Source source, CS_Status* status);
258 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
259 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
260 void SetCameraWhiteBalanceManual(CS_Source source, int value,
261  CS_Status* status);
262 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
263 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
264 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
271 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
272 UsbCameraInfo GetUsbCameraInfo(CS_Source source, CS_Status* status);
279 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
280 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
281  CS_Status* status);
282 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
289 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
290 void NotifySourceError(CS_Source source, const wpi::Twine& msg,
291  CS_Status* status);
292 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
293 void SetSourceDescription(CS_Source source, const wpi::Twine& description,
294  CS_Status* status);
295 CS_Property CreateSourceProperty(CS_Source source, const wpi::Twine& name,
296  CS_PropertyKind kind, int minimum, int maximum,
297  int step, int defaultValue, int value,
298  CS_Status* status);
299 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
301  CS_Status* status);
308 CS_Sink CreateMjpegServer(const wpi::Twine& name,
309  const wpi::Twine& listenAddress, int port,
310  CS_Status* status);
311 CS_Sink CreateCvSink(const wpi::Twine& name, CS_Status* status);
312 CS_Sink CreateCvSinkCallback(const wpi::Twine& name,
313  std::function<void(uint64_t time)> processFrame,
314  CS_Status* status);
321 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
322 std::string GetSinkName(CS_Sink sink, CS_Status* status);
323 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
324  CS_Status* status);
325 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
326 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
327  CS_Status* status);
328 CS_Property GetSinkProperty(CS_Sink sink, const wpi::Twine& name,
329  CS_Status* status);
330 wpi::ArrayRef<CS_Property> EnumerateSinkProperties(
331  CS_Sink sink, wpi::SmallVectorImpl<CS_Property>& vec, CS_Status* status);
332 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
333 CS_Property GetSinkSourceProperty(CS_Sink sink, const wpi::Twine& name,
334  CS_Status* status);
335 bool SetSinkConfigJson(CS_Sink sink, wpi::StringRef config, CS_Status* status);
336 bool SetSinkConfigJson(CS_Sink sink, const wpi::json& config,
337  CS_Status* status);
338 std::string GetSinkConfigJson(CS_Sink sink, CS_Status* status);
339 wpi::json GetSinkConfigJsonObject(CS_Sink sink, CS_Status* status);
340 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
341 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
342 void ReleaseSink(CS_Sink sink, CS_Status* status);
349 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
350 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
357 void SetSinkDescription(CS_Sink sink, const wpi::Twine& description,
358  CS_Status* status);
359 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
360 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
361  CS_Status* status);
362 std::string GetSinkError(CS_Sink sink, CS_Status* status);
363 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
364  CS_Status* status);
365 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
372 void SetListenerOnStart(std::function<void()> onStart);
373 void SetListenerOnExit(std::function<void()> onExit);
374 
375 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
376  int eventMask, bool immediateNotify, CS_Status* status);
377 
378 void RemoveListener(CS_Listener handle, CS_Status* status);
381 bool NotifierDestroyed();
382 
387 void SetTelemetryPeriod(double seconds);
388 double GetTelemetryElapsedTime();
389 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
390  CS_Status* status);
391 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
392  CS_Status* status);
399 using LogFunc = std::function<void(unsigned int level, const char* file,
400  unsigned int line, const char* msg)>;
401 void SetLogger(LogFunc func, unsigned int min_level);
402 void SetDefaultLogger(unsigned int min_level);
409 void Shutdown();
416 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
417 
418 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
419  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
420 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
421  CS_Status* status);
422 
423 std::string GetHostname();
424 
425 std::vector<std::string> GetNetworkInterfaces();
430 } // namespace cs
431 
438 extern "C" {
439 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
440 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
441  double timeout, CS_Status* status);
442 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
443 } // extern "C"
446 #endif // CSCORE_CSCORE_CPP_H_
CS_TelemetryKind
Telemetry kinds.
Definition: cscore_c.h:177
CameraServer (cscore) namespace.
Definition: cscore_oo.inl:11
CS_HttpCameraKind
HTTP Camera kinds.
Definition: cscore_c.h:137
CS_SinkKind
Sink kinds.
Definition: cscore_c.h:147
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:96
Definition: cscore_cpp.h:24
WPILib C++ utilities (wpiutil) namespace.
Definition: SmallString.h:21
std::vector< std::string > otherPaths
Other path aliases to device (e.g.
Definition: cscore_cpp.h:56
std::string str() const
Return the twine contents as a std::string.
CS_ConnectionStrategy
Connection strategy.
Definition: cscore_c.h:183
CS_SourceKind
Source kinds.
Definition: cscore_c.h:127
USB camera information.
Definition: cscore_cpp.h:48
a class to store JSON values
Definition: json.h:2714
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
int dev
Device number (e.g.
Definition: cscore_cpp.h:50
CS_PropertyKind
Property kinds.
Definition: cscore_c.h:116
std::string path
Path to device if available (e.g.
Definition: cscore_cpp.h:52
std::string name
Vendor/model name of the camera as provided by the USB driver.
Definition: cscore_cpp.h:54
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
Video mode.
Definition: cscore_cpp.h:62
Video mode.
Definition: cscore_c.h:106