WPILibC++  2018.4.1-20180729184725-1146-g6db5f80
 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 
29 namespace cs {
30 
44 struct UsbCameraInfo {
46  int dev;
48  std::string path;
50  std::string name;
51 };
52 
56 struct VideoMode : public CS_VideoMode {
57  enum PixelFormat {
58  kUnknown = CS_PIXFMT_UNKNOWN,
59  kMJPEG = CS_PIXFMT_MJPEG,
60  kYUYV = CS_PIXFMT_YUYV,
61  kRGB565 = CS_PIXFMT_RGB565,
62  kBGR = CS_PIXFMT_BGR,
63  kGray = CS_PIXFMT_GRAY
64  };
65  VideoMode() {
66  pixelFormat = 0;
67  width = 0;
68  height = 0;
69  fps = 0;
70  }
71  VideoMode(PixelFormat pixelFormat_, int width_, int height_, int fps_) {
72  pixelFormat = pixelFormat_;
73  width = width_;
74  height = height_;
75  fps = fps_;
76  }
77  explicit operator bool() const { return pixelFormat == kUnknown; }
78 };
79 
83 struct RawEvent {
84  enum Kind {
85  kSourceCreated = CS_SOURCE_CREATED,
86  kSourceDestroyed = CS_SOURCE_DESTROYED,
87  kSourceConnected = CS_SOURCE_CONNECTED,
88  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
89  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
90  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
91  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
92  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
93  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
94  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
95  kSinkCreated = CS_SINK_CREATED,
96  kSinkDestroyed = CS_SINK_DESTROYED,
97  kSinkEnabled = CS_SINK_ENABLED,
98  kSinkDisabled = CS_SINK_DISABLED,
99  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED,
100  kTelemetryUpdated = CS_TELEMETRY_UPDATED,
101  kSinkPropertyCreated = CS_SINK_PROPERTY_CREATED,
102  kSinkPropertyValueUpdated = CS_SINK_PROPERTY_VALUE_UPDATED,
103  kSinkPropertyChoicesUpdated = CS_SINK_PROPERTY_CHOICES_UPDATED
104  };
105 
106  RawEvent() = default;
107  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
108  RawEvent(const wpi::Twine& name_, CS_Handle handle_, RawEvent::Kind kind_)
109  : kind{kind_}, name{name_.str()} {
110  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
111  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
112  sinkHandle = handle_;
113  else
114  sourceHandle = handle_;
115  }
116  RawEvent(const wpi::Twine& name_, CS_Source source_, const VideoMode& mode_)
117  : kind{kSourceVideoModeChanged},
118  sourceHandle{source_},
119  name{name_.str()},
120  mode{mode_} {}
121  RawEvent(const wpi::Twine& name_, CS_Source source_, RawEvent::Kind kind_,
122  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
123  const wpi::Twine& valueStr_)
124  : kind{kind_},
125  sourceHandle{source_},
126  name{name_.str()},
127  propertyHandle{property_},
128  propertyKind{propertyKind_},
129  value{value_},
130  valueStr{valueStr_.str()} {}
131 
132  Kind kind;
133 
134  // Valid for kSource* and kSink* respectively
135  CS_Source sourceHandle = CS_INVALID_HANDLE;
136  CS_Sink sinkHandle = CS_INVALID_HANDLE;
137 
138  // Source/sink/property name
139  std::string name;
140 
141  // Fields for kSourceVideoModeChanged event
142  VideoMode mode;
143 
144  // Fields for kSourceProperty* events
145  CS_Property propertyHandle;
146  CS_PropertyKind propertyKind;
147  int value;
148  std::string valueStr;
149 };
150 
155 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
156 std::string GetPropertyName(CS_Property property, CS_Status* status);
157 wpi::StringRef GetPropertyName(CS_Property property,
159  CS_Status* status);
160 int GetProperty(CS_Property property, CS_Status* status);
161 void SetProperty(CS_Property property, int value, CS_Status* status);
162 int GetPropertyMin(CS_Property property, CS_Status* status);
163 int GetPropertyMax(CS_Property property, CS_Status* status);
164 int GetPropertyStep(CS_Property property, CS_Status* status);
165 int GetPropertyDefault(CS_Property property, CS_Status* status);
166 std::string GetStringProperty(CS_Property property, CS_Status* status);
167 wpi::StringRef GetStringProperty(CS_Property property,
169  CS_Status* status);
170 void SetStringProperty(CS_Property property, const wpi::Twine& value,
171  CS_Status* status);
172 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
173  CS_Status* status);
180 CS_Source CreateUsbCameraDev(const wpi::Twine& name, int dev,
181  CS_Status* status);
182 CS_Source CreateUsbCameraPath(const wpi::Twine& name, const wpi::Twine& path,
183  CS_Status* status);
184 CS_Source CreateHttpCamera(const wpi::Twine& name, const wpi::Twine& url,
185  CS_HttpCameraKind kind, CS_Status* status);
186 CS_Source CreateHttpCamera(const wpi::Twine& name,
188  CS_HttpCameraKind kind, CS_Status* status);
189 CS_Source CreateCvSource(const wpi::Twine& name, const VideoMode& mode,
190  CS_Status* status);
197 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
198 std::string GetSourceName(CS_Source source, CS_Status* status);
199 wpi::StringRef GetSourceName(CS_Source source, wpi::SmallVectorImpl<char>& buf,
200  CS_Status* status);
201 std::string GetSourceDescription(CS_Source source, CS_Status* status);
202 wpi::StringRef GetSourceDescription(CS_Source source,
204  CS_Status* status);
205 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
206 bool IsSourceConnected(CS_Source source, CS_Status* status);
207 CS_Property GetSourceProperty(CS_Source source, const wpi::Twine& name,
208  CS_Status* status);
209 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
210  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
211  CS_Status* status);
212 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
213 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
214  CS_Status* status);
215 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
216  CS_Status* status);
217 bool SetSourceResolution(CS_Source source, int width, int height,
218  CS_Status* status);
219 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
220 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
221  CS_Status* status);
222 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
224  CS_Status* status);
225 CS_Source CopySource(CS_Source source, CS_Status* status);
226 void ReleaseSource(CS_Source source, CS_Status* status);
233 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
234 int GetCameraBrightness(CS_Source source, CS_Status* status);
235 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
236 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
237 void SetCameraWhiteBalanceManual(CS_Source source, int value,
238  CS_Status* status);
239 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
240 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
241 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
248 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
255 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
256 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
257  CS_Status* status);
258 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
265 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
266 void NotifySourceError(CS_Source source, const wpi::Twine& msg,
267  CS_Status* status);
268 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
269 void SetSourceDescription(CS_Source source, const wpi::Twine& description,
270  CS_Status* status);
271 CS_Property CreateSourceProperty(CS_Source source, const wpi::Twine& name,
272  CS_PropertyKind kind, int minimum, int maximum,
273  int step, int defaultValue, int value,
274  CS_Status* status);
275 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
277  CS_Status* status);
284 CS_Sink CreateMjpegServer(const wpi::Twine& name,
285  const wpi::Twine& listenAddress, int port,
286  CS_Status* status);
287 CS_Sink CreateCvSink(const wpi::Twine& name, CS_Status* status);
288 CS_Sink CreateCvSinkCallback(const wpi::Twine& name,
289  std::function<void(uint64_t time)> processFrame,
290  CS_Status* status);
297 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
298 std::string GetSinkName(CS_Sink sink, CS_Status* status);
299 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
300  CS_Status* status);
301 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
302 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
303  CS_Status* status);
304 CS_Property GetSinkProperty(CS_Sink sink, const wpi::Twine& name,
305  CS_Status* status);
306 wpi::ArrayRef<CS_Property> EnumerateSinkProperties(
307  CS_Sink sink, wpi::SmallVectorImpl<CS_Property>& vec, CS_Status* status);
308 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
309 CS_Property GetSinkSourceProperty(CS_Sink sink, const wpi::Twine& name,
310  CS_Status* status);
311 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
312 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
313 void ReleaseSink(CS_Sink sink, CS_Status* status);
320 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
321 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
328 void SetSinkDescription(CS_Sink sink, const wpi::Twine& description,
329  CS_Status* status);
330 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
331 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
332  CS_Status* status);
333 std::string GetSinkError(CS_Sink sink, CS_Status* status);
334 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
335  CS_Status* status);
336 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
343 void SetListenerOnStart(std::function<void()> onStart);
344 void SetListenerOnExit(std::function<void()> onExit);
345 
346 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
347  int eventMask, bool immediateNotify, CS_Status* status);
348 
349 void RemoveListener(CS_Listener handle, CS_Status* status);
352 bool NotifierDestroyed();
353 
358 void SetTelemetryPeriod(double seconds);
359 double GetTelemetryElapsedTime();
360 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
361  CS_Status* status);
362 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
363  CS_Status* status);
370 typedef std::function<void(unsigned int level, const char* file,
371  unsigned int line, const char* msg)>
372  LogFunc;
373 void SetLogger(LogFunc func, unsigned int min_level);
374 void SetDefaultLogger(unsigned int min_level);
381 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
382 
383 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
384  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
385 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
386  CS_Status* status);
387 
388 std::string GetHostname();
389 
390 std::vector<std::string> GetNetworkInterfaces();
395 } // namespace cs
396 
403 extern "C" {
404 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
405 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
406  double timeout, CS_Status* status);
407 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
408 } // extern "C"
411 #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:83
Definition: cscore_cpp.h:24
std::string str() const
Return the twine contents as a std::string.
CS_SourceKind
Source kinds.
Definition: cscore_c.h:126
USB camera information.
Definition: cscore_cpp.h:44
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
int dev
Device number (e.g.
Definition: cscore_cpp.h:46
CS_PropertyKind
Property kinds.
Definition: cscore_c.h:115
std::string path
Path to device if available (e.g.
Definition: cscore_cpp.h:48
std::string name
Vendor/model name of the camera as provided by the USB driver.
Definition: cscore_cpp.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
Video mode.
Definition: cscore_cpp.h:56
Video mode.
Definition: cscore_c.h:105