WPILibC++  2019.1.1-beta-2-8-g9207d78
 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 
87 struct RawEvent {
88  enum Kind {
89  kSourceCreated = CS_SOURCE_CREATED,
90  kSourceDestroyed = CS_SOURCE_DESTROYED,
91  kSourceConnected = CS_SOURCE_CONNECTED,
92  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
93  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
94  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
95  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
96  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
97  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
98  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
99  kSinkCreated = CS_SINK_CREATED,
100  kSinkDestroyed = CS_SINK_DESTROYED,
101  kSinkEnabled = CS_SINK_ENABLED,
102  kSinkDisabled = CS_SINK_DISABLED,
103  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED,
104  kTelemetryUpdated = CS_TELEMETRY_UPDATED,
105  kSinkPropertyCreated = CS_SINK_PROPERTY_CREATED,
106  kSinkPropertyValueUpdated = CS_SINK_PROPERTY_VALUE_UPDATED,
107  kSinkPropertyChoicesUpdated = CS_SINK_PROPERTY_CHOICES_UPDATED
108  };
109 
110  RawEvent() = default;
111  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
112  RawEvent(const wpi::Twine& name_, CS_Handle handle_, RawEvent::Kind kind_)
113  : kind{kind_}, name{name_.str()} {
114  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
115  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
116  sinkHandle = handle_;
117  else
118  sourceHandle = handle_;
119  }
120  RawEvent(const wpi::Twine& name_, CS_Source source_, const VideoMode& mode_)
121  : kind{kSourceVideoModeChanged},
122  sourceHandle{source_},
123  name{name_.str()},
124  mode{mode_} {}
125  RawEvent(const wpi::Twine& name_, CS_Source source_, RawEvent::Kind kind_,
126  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
127  const wpi::Twine& valueStr_)
128  : kind{kind_},
129  sourceHandle{source_},
130  name{name_.str()},
131  propertyHandle{property_},
132  propertyKind{propertyKind_},
133  value{value_},
134  valueStr{valueStr_.str()} {}
135 
136  Kind kind;
137 
138  // Valid for kSource* and kSink* respectively
139  CS_Source sourceHandle = CS_INVALID_HANDLE;
140  CS_Sink sinkHandle = CS_INVALID_HANDLE;
141 
142  // Source/sink/property name
143  std::string name;
144 
145  // Fields for kSourceVideoModeChanged event
146  VideoMode mode;
147 
148  // Fields for kSourceProperty* events
149  CS_Property propertyHandle;
150  CS_PropertyKind propertyKind;
151  int value;
152  std::string valueStr;
153 };
154 
159 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
160 std::string GetPropertyName(CS_Property property, CS_Status* status);
161 wpi::StringRef GetPropertyName(CS_Property property,
163  CS_Status* status);
164 int GetProperty(CS_Property property, CS_Status* status);
165 void SetProperty(CS_Property property, int value, CS_Status* status);
166 int GetPropertyMin(CS_Property property, CS_Status* status);
167 int GetPropertyMax(CS_Property property, CS_Status* status);
168 int GetPropertyStep(CS_Property property, CS_Status* status);
169 int GetPropertyDefault(CS_Property property, CS_Status* status);
170 std::string GetStringProperty(CS_Property property, CS_Status* status);
171 wpi::StringRef GetStringProperty(CS_Property property,
173  CS_Status* status);
174 void SetStringProperty(CS_Property property, const wpi::Twine& value,
175  CS_Status* status);
176 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
177  CS_Status* status);
184 CS_Source CreateUsbCameraDev(const wpi::Twine& name, int dev,
185  CS_Status* status);
186 CS_Source CreateUsbCameraPath(const wpi::Twine& name, const wpi::Twine& path,
187  CS_Status* status);
188 CS_Source CreateHttpCamera(const wpi::Twine& name, const wpi::Twine& url,
189  CS_HttpCameraKind kind, CS_Status* status);
190 CS_Source CreateHttpCamera(const wpi::Twine& name,
192  CS_HttpCameraKind kind, CS_Status* status);
193 CS_Source CreateCvSource(const wpi::Twine& name, const VideoMode& mode,
194  CS_Status* status);
201 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
202 std::string GetSourceName(CS_Source source, CS_Status* status);
203 wpi::StringRef GetSourceName(CS_Source source, wpi::SmallVectorImpl<char>& buf,
204  CS_Status* status);
205 std::string GetSourceDescription(CS_Source source, CS_Status* status);
206 wpi::StringRef GetSourceDescription(CS_Source source,
208  CS_Status* status);
209 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
210 void SetSourceConnectionStrategy(CS_Source source,
211  CS_ConnectionStrategy strategy,
212  CS_Status* status);
213 bool IsSourceConnected(CS_Source source, CS_Status* status);
214 bool IsSourceEnabled(CS_Source source, CS_Status* status);
215 CS_Property GetSourceProperty(CS_Source source, const wpi::Twine& name,
216  CS_Status* status);
217 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
218  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
219  CS_Status* status);
220 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
221 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
222  CS_Status* status);
223 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
224  CS_Status* status);
225 bool SetSourceResolution(CS_Source source, int width, int height,
226  CS_Status* status);
227 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
228 bool SetSourceConfigJson(CS_Source source, wpi::StringRef config,
229  CS_Status* status);
230 bool SetSourceConfigJson(CS_Source source, const wpi::json& config,
231  CS_Status* status);
232 std::string GetSourceConfigJson(CS_Source source, CS_Status* status);
233 wpi::json GetSourceConfigJsonObject(CS_Source source, CS_Status* status);
234 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
235  CS_Status* status);
236 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
238  CS_Status* status);
239 CS_Source CopySource(CS_Source source, CS_Status* status);
240 void ReleaseSource(CS_Source source, CS_Status* status);
247 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
248 int GetCameraBrightness(CS_Source source, CS_Status* status);
249 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
250 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
251 void SetCameraWhiteBalanceManual(CS_Source source, int value,
252  CS_Status* status);
253 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
254 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
255 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
262 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
269 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
270 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
271  CS_Status* status);
272 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
279 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
280 void NotifySourceError(CS_Source source, const wpi::Twine& msg,
281  CS_Status* status);
282 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
283 void SetSourceDescription(CS_Source source, const wpi::Twine& description,
284  CS_Status* status);
285 CS_Property CreateSourceProperty(CS_Source source, const wpi::Twine& name,
286  CS_PropertyKind kind, int minimum, int maximum,
287  int step, int defaultValue, int value,
288  CS_Status* status);
289 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
291  CS_Status* status);
298 CS_Sink CreateMjpegServer(const wpi::Twine& name,
299  const wpi::Twine& listenAddress, int port,
300  CS_Status* status);
301 CS_Sink CreateCvSink(const wpi::Twine& name, CS_Status* status);
302 CS_Sink CreateCvSinkCallback(const wpi::Twine& name,
303  std::function<void(uint64_t time)> processFrame,
304  CS_Status* status);
311 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
312 std::string GetSinkName(CS_Sink sink, CS_Status* status);
313 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
314  CS_Status* status);
315 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
316 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
317  CS_Status* status);
318 CS_Property GetSinkProperty(CS_Sink sink, const wpi::Twine& name,
319  CS_Status* status);
320 wpi::ArrayRef<CS_Property> EnumerateSinkProperties(
321  CS_Sink sink, wpi::SmallVectorImpl<CS_Property>& vec, CS_Status* status);
322 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
323 CS_Property GetSinkSourceProperty(CS_Sink sink, const wpi::Twine& name,
324  CS_Status* status);
325 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
326 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
327 void ReleaseSink(CS_Sink sink, CS_Status* status);
334 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
335 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
342 void SetSinkDescription(CS_Sink sink, const wpi::Twine& description,
343  CS_Status* status);
344 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
345 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
346  CS_Status* status);
347 std::string GetSinkError(CS_Sink sink, CS_Status* status);
348 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
349  CS_Status* status);
350 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
357 void SetListenerOnStart(std::function<void()> onStart);
358 void SetListenerOnExit(std::function<void()> onExit);
359 
360 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
361  int eventMask, bool immediateNotify, CS_Status* status);
362 
363 void RemoveListener(CS_Listener handle, CS_Status* status);
366 bool NotifierDestroyed();
367 
372 void SetTelemetryPeriod(double seconds);
373 double GetTelemetryElapsedTime();
374 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
375  CS_Status* status);
376 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
377  CS_Status* status);
384 using LogFunc = std::function<void(unsigned int level, const char* file,
385  unsigned int line, const char* msg)>;
386 void SetLogger(LogFunc func, unsigned int min_level);
387 void SetDefaultLogger(unsigned int min_level);
394 void Shutdown();
401 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
402 
403 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
404  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
405 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
406  CS_Status* status);
407 
408 std::string GetHostname();
409 
410 std::vector<std::string> GetNetworkInterfaces();
415 } // namespace cs
416 
423 extern "C" {
424 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
425 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
426  double timeout, CS_Status* status);
427 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
428 } // extern "C"
431 #endif // CSCORE_CSCORE_CPP_H_
CS_TelemetryKind
Telemetry kinds.
Definition: cscore_c.h:176
CameraServer (cscore) namespace.
Definition: cscore_oo.inl:11
CS_HttpCameraKind
HTTP Camera kinds.
Definition: cscore_c.h:136
CS_SinkKind
Sink kinds.
Definition: cscore_c.h:146
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:87
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:182
CS_SourceKind
Source kinds.
Definition: cscore_c.h:126
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:115
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:105