WPILibC++  2018.4.1-20180920010257-1187-gd2a5aaa
 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 void SetSourceConnectionStrategy(CS_Source source,
207  CS_ConnectionStrategy strategy,
208  CS_Status* status);
209 bool IsSourceConnected(CS_Source source, CS_Status* status);
210 bool IsSourceEnabled(CS_Source source, CS_Status* status);
211 CS_Property GetSourceProperty(CS_Source source, const wpi::Twine& name,
212  CS_Status* status);
213 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
214  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
215  CS_Status* status);
216 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
217 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
218  CS_Status* status);
219 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
220  CS_Status* status);
221 bool SetSourceResolution(CS_Source source, int width, int height,
222  CS_Status* status);
223 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
224 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
225  CS_Status* status);
226 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
228  CS_Status* status);
229 CS_Source CopySource(CS_Source source, CS_Status* status);
230 void ReleaseSource(CS_Source source, CS_Status* status);
237 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
238 int GetCameraBrightness(CS_Source source, CS_Status* status);
239 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
240 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
241 void SetCameraWhiteBalanceManual(CS_Source source, int value,
242  CS_Status* status);
243 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
244 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
245 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
252 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
259 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
260 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
261  CS_Status* status);
262 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
269 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
270 void NotifySourceError(CS_Source source, const wpi::Twine& msg,
271  CS_Status* status);
272 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
273 void SetSourceDescription(CS_Source source, const wpi::Twine& description,
274  CS_Status* status);
275 CS_Property CreateSourceProperty(CS_Source source, const wpi::Twine& name,
276  CS_PropertyKind kind, int minimum, int maximum,
277  int step, int defaultValue, int value,
278  CS_Status* status);
279 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
281  CS_Status* status);
288 CS_Sink CreateMjpegServer(const wpi::Twine& name,
289  const wpi::Twine& listenAddress, int port,
290  CS_Status* status);
291 CS_Sink CreateCvSink(const wpi::Twine& name, CS_Status* status);
292 CS_Sink CreateCvSinkCallback(const wpi::Twine& name,
293  std::function<void(uint64_t time)> processFrame,
294  CS_Status* status);
301 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
302 std::string GetSinkName(CS_Sink sink, CS_Status* status);
303 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
304  CS_Status* status);
305 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
306 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
307  CS_Status* status);
308 CS_Property GetSinkProperty(CS_Sink sink, const wpi::Twine& name,
309  CS_Status* status);
310 wpi::ArrayRef<CS_Property> EnumerateSinkProperties(
311  CS_Sink sink, wpi::SmallVectorImpl<CS_Property>& vec, CS_Status* status);
312 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
313 CS_Property GetSinkSourceProperty(CS_Sink sink, const wpi::Twine& name,
314  CS_Status* status);
315 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
316 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
317 void ReleaseSink(CS_Sink sink, CS_Status* status);
324 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
325 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
332 void SetSinkDescription(CS_Sink sink, const wpi::Twine& description,
333  CS_Status* status);
334 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
335 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
336  CS_Status* status);
337 std::string GetSinkError(CS_Sink sink, CS_Status* status);
338 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
339  CS_Status* status);
340 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
347 void SetListenerOnStart(std::function<void()> onStart);
348 void SetListenerOnExit(std::function<void()> onExit);
349 
350 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
351  int eventMask, bool immediateNotify, CS_Status* status);
352 
353 void RemoveListener(CS_Listener handle, CS_Status* status);
356 bool NotifierDestroyed();
357 
362 void SetTelemetryPeriod(double seconds);
363 double GetTelemetryElapsedTime();
364 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
365  CS_Status* status);
366 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
367  CS_Status* status);
374 typedef std::function<void(unsigned int level, const char* file,
375  unsigned int line, const char* msg)>
376  LogFunc;
377 void SetLogger(LogFunc func, unsigned int min_level);
378 void SetDefaultLogger(unsigned int min_level);
385 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
386 
387 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
388  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
389 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
390  CS_Status* status);
391 
392 std::string GetHostname();
393 
394 std::vector<std::string> GetNetworkInterfaces();
399 } // namespace cs
400 
407 extern "C" {
408 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
409 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
410  double timeout, CS_Status* status);
411 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
412 } // extern "C"
415 #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_ConnectionStrategy
Connection strategy.
Definition: cscore_c.h:182
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