WPILibC++  2019.1.1-beta-2-17-g6f0c185
 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;
52  std::string path;
54  std::string name;
55 };
56 
60 struct VideoMode : public CS_VideoMode {
61  enum PixelFormat {
62  kUnknown = CS_PIXFMT_UNKNOWN,
63  kMJPEG = CS_PIXFMT_MJPEG,
64  kYUYV = CS_PIXFMT_YUYV,
65  kRGB565 = CS_PIXFMT_RGB565,
66  kBGR = CS_PIXFMT_BGR,
67  kGray = CS_PIXFMT_GRAY
68  };
69  VideoMode() {
70  pixelFormat = 0;
71  width = 0;
72  height = 0;
73  fps = 0;
74  }
75  VideoMode(PixelFormat pixelFormat_, int width_, int height_, int fps_) {
76  pixelFormat = pixelFormat_;
77  width = width_;
78  height = height_;
79  fps = fps_;
80  }
81  explicit operator bool() const { return pixelFormat == kUnknown; }
82 
83  bool operator==(const VideoMode& other) const {
84  return pixelFormat == other.pixelFormat && width == other.width &&
85  height == other.height && fps == other.fps;
86  }
87 
88  bool operator!=(const VideoMode& other) const { return !(*this == other); }
89 };
90 
94 struct RawEvent {
95  enum Kind {
96  kSourceCreated = CS_SOURCE_CREATED,
97  kSourceDestroyed = CS_SOURCE_DESTROYED,
98  kSourceConnected = CS_SOURCE_CONNECTED,
99  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
100  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
101  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
102  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
103  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
104  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
105  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
106  kSinkCreated = CS_SINK_CREATED,
107  kSinkDestroyed = CS_SINK_DESTROYED,
108  kSinkEnabled = CS_SINK_ENABLED,
109  kSinkDisabled = CS_SINK_DISABLED,
110  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED,
111  kTelemetryUpdated = CS_TELEMETRY_UPDATED,
112  kSinkPropertyCreated = CS_SINK_PROPERTY_CREATED,
113  kSinkPropertyValueUpdated = CS_SINK_PROPERTY_VALUE_UPDATED,
114  kSinkPropertyChoicesUpdated = CS_SINK_PROPERTY_CHOICES_UPDATED
115  };
116 
117  RawEvent() = default;
118  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
119  RawEvent(const wpi::Twine& name_, CS_Handle handle_, RawEvent::Kind kind_)
120  : kind{kind_}, name{name_.str()} {
121  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
122  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
123  sinkHandle = handle_;
124  else
125  sourceHandle = handle_;
126  }
127  RawEvent(const wpi::Twine& name_, CS_Source source_, const VideoMode& mode_)
128  : kind{kSourceVideoModeChanged},
129  sourceHandle{source_},
130  name{name_.str()},
131  mode{mode_} {}
132  RawEvent(const wpi::Twine& name_, CS_Source source_, RawEvent::Kind kind_,
133  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
134  const wpi::Twine& valueStr_)
135  : kind{kind_},
136  sourceHandle{source_},
137  name{name_.str()},
138  propertyHandle{property_},
139  propertyKind{propertyKind_},
140  value{value_},
141  valueStr{valueStr_.str()} {}
142 
143  Kind kind;
144 
145  // Valid for kSource* and kSink* respectively
146  CS_Source sourceHandle = CS_INVALID_HANDLE;
147  CS_Sink sinkHandle = CS_INVALID_HANDLE;
148 
149  // Source/sink/property name
150  std::string name;
151 
152  // Fields for kSourceVideoModeChanged event
153  VideoMode mode;
154 
155  // Fields for kSourceProperty* events
156  CS_Property propertyHandle;
157  CS_PropertyKind propertyKind;
158  int value;
159  std::string valueStr;
160 };
161 
166 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
167 std::string GetPropertyName(CS_Property property, CS_Status* status);
168 wpi::StringRef GetPropertyName(CS_Property property,
170  CS_Status* status);
171 int GetProperty(CS_Property property, CS_Status* status);
172 void SetProperty(CS_Property property, int value, CS_Status* status);
173 int GetPropertyMin(CS_Property property, CS_Status* status);
174 int GetPropertyMax(CS_Property property, CS_Status* status);
175 int GetPropertyStep(CS_Property property, CS_Status* status);
176 int GetPropertyDefault(CS_Property property, CS_Status* status);
177 std::string GetStringProperty(CS_Property property, CS_Status* status);
178 wpi::StringRef GetStringProperty(CS_Property property,
180  CS_Status* status);
181 void SetStringProperty(CS_Property property, const wpi::Twine& value,
182  CS_Status* status);
183 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
184  CS_Status* status);
191 CS_Source CreateUsbCameraDev(const wpi::Twine& name, int dev,
192  CS_Status* status);
193 CS_Source CreateUsbCameraPath(const wpi::Twine& name, const wpi::Twine& path,
194  CS_Status* status);
195 CS_Source CreateHttpCamera(const wpi::Twine& name, const wpi::Twine& url,
196  CS_HttpCameraKind kind, CS_Status* status);
197 CS_Source CreateHttpCamera(const wpi::Twine& name,
199  CS_HttpCameraKind kind, CS_Status* status);
200 CS_Source CreateCvSource(const wpi::Twine& name, const VideoMode& mode,
201  CS_Status* status);
208 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
209 std::string GetSourceName(CS_Source source, CS_Status* status);
210 wpi::StringRef GetSourceName(CS_Source source, wpi::SmallVectorImpl<char>& buf,
211  CS_Status* status);
212 std::string GetSourceDescription(CS_Source source, CS_Status* status);
213 wpi::StringRef GetSourceDescription(CS_Source source,
215  CS_Status* status);
216 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
217 void SetSourceConnectionStrategy(CS_Source source,
218  CS_ConnectionStrategy strategy,
219  CS_Status* status);
220 bool IsSourceConnected(CS_Source source, CS_Status* status);
221 bool IsSourceEnabled(CS_Source source, CS_Status* status);
222 CS_Property GetSourceProperty(CS_Source source, const wpi::Twine& name,
223  CS_Status* status);
224 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
225  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
226  CS_Status* status);
227 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
228 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
229  CS_Status* status);
230 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
231  CS_Status* status);
232 bool SetSourceResolution(CS_Source source, int width, int height,
233  CS_Status* status);
234 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
235 bool SetSourceConfigJson(CS_Source source, wpi::StringRef config,
236  CS_Status* status);
237 bool SetSourceConfigJson(CS_Source source, const wpi::json& config,
238  CS_Status* status);
239 std::string GetSourceConfigJson(CS_Source source, CS_Status* status);
240 wpi::json GetSourceConfigJsonObject(CS_Source source, CS_Status* status);
241 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
242  CS_Status* status);
243 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
245  CS_Status* status);
246 CS_Source CopySource(CS_Source source, CS_Status* status);
247 void ReleaseSource(CS_Source source, CS_Status* status);
254 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
255 int GetCameraBrightness(CS_Source source, CS_Status* status);
256 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
257 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
258 void SetCameraWhiteBalanceManual(CS_Source source, int value,
259  CS_Status* status);
260 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
261 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
262 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
269 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
276 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
277 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
278  CS_Status* status);
279 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
286 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
287 void NotifySourceError(CS_Source source, const wpi::Twine& msg,
288  CS_Status* status);
289 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
290 void SetSourceDescription(CS_Source source, const wpi::Twine& description,
291  CS_Status* status);
292 CS_Property CreateSourceProperty(CS_Source source, const wpi::Twine& name,
293  CS_PropertyKind kind, int minimum, int maximum,
294  int step, int defaultValue, int value,
295  CS_Status* status);
296 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
298  CS_Status* status);
305 CS_Sink CreateMjpegServer(const wpi::Twine& name,
306  const wpi::Twine& listenAddress, int port,
307  CS_Status* status);
308 CS_Sink CreateCvSink(const wpi::Twine& name, CS_Status* status);
309 CS_Sink CreateCvSinkCallback(const wpi::Twine& name,
310  std::function<void(uint64_t time)> processFrame,
311  CS_Status* status);
318 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
319 std::string GetSinkName(CS_Sink sink, CS_Status* status);
320 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
321  CS_Status* status);
322 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
323 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
324  CS_Status* status);
325 CS_Property GetSinkProperty(CS_Sink sink, const wpi::Twine& name,
326  CS_Status* status);
327 wpi::ArrayRef<CS_Property> EnumerateSinkProperties(
328  CS_Sink sink, wpi::SmallVectorImpl<CS_Property>& vec, CS_Status* status);
329 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
330 CS_Property GetSinkSourceProperty(CS_Sink sink, const wpi::Twine& name,
331  CS_Status* status);
332 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
333 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
334 void ReleaseSink(CS_Sink sink, CS_Status* status);
341 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
342 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
349 void SetSinkDescription(CS_Sink sink, const wpi::Twine& description,
350  CS_Status* status);
351 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
352 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
353  CS_Status* status);
354 std::string GetSinkError(CS_Sink sink, CS_Status* status);
355 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
356  CS_Status* status);
357 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
364 void SetListenerOnStart(std::function<void()> onStart);
365 void SetListenerOnExit(std::function<void()> onExit);
366 
367 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
368  int eventMask, bool immediateNotify, CS_Status* status);
369 
370 void RemoveListener(CS_Listener handle, CS_Status* status);
373 bool NotifierDestroyed();
374 
379 void SetTelemetryPeriod(double seconds);
380 double GetTelemetryElapsedTime();
381 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
382  CS_Status* status);
383 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
384  CS_Status* status);
391 using LogFunc = std::function<void(unsigned int level, const char* file,
392  unsigned int line, const char* msg)>;
393 void SetLogger(LogFunc func, unsigned int min_level);
394 void SetDefaultLogger(unsigned int min_level);
401 void Shutdown();
408 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
409 
410 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
411  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
412 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
413  CS_Status* status);
414 
415 std::string GetHostname();
416 
417 std::vector<std::string> GetNetworkInterfaces();
422 } // namespace cs
423 
430 extern "C" {
431 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
432 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
433  double timeout, CS_Status* status);
434 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
435 } // extern "C"
438 #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:94
Definition: cscore_cpp.h:24
WPILib C++ utilities (wpiutil) namespace.
Definition: SmallString.h:21
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:60
Video mode.
Definition: cscore_c.h:106