WPILibC++  2018.4.1-20180729040223-1137-g011f0ff
 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 
21 #include "cscore_c.h"
22 
23 namespace cv {
24 class Mat;
25 } // namespace cv
26 
27 namespace cs {
28 
42 struct UsbCameraInfo {
44  int dev;
46  std::string path;
48  std::string name;
49 };
50 
54 struct VideoMode : public CS_VideoMode {
55  enum PixelFormat {
56  kUnknown = CS_PIXFMT_UNKNOWN,
57  kMJPEG = CS_PIXFMT_MJPEG,
58  kYUYV = CS_PIXFMT_YUYV,
59  kRGB565 = CS_PIXFMT_RGB565,
60  kBGR = CS_PIXFMT_BGR,
61  kGray = CS_PIXFMT_GRAY
62  };
63  VideoMode() {
64  pixelFormat = 0;
65  width = 0;
66  height = 0;
67  fps = 0;
68  }
69  VideoMode(PixelFormat pixelFormat_, int width_, int height_, int fps_) {
70  pixelFormat = pixelFormat_;
71  width = width_;
72  height = height_;
73  fps = fps_;
74  }
75  explicit operator bool() const { return pixelFormat == kUnknown; }
76 };
77 
81 struct RawEvent {
82  enum Kind {
83  kSourceCreated = CS_SOURCE_CREATED,
84  kSourceDestroyed = CS_SOURCE_DESTROYED,
85  kSourceConnected = CS_SOURCE_CONNECTED,
86  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
87  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
88  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
89  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
90  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
91  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
92  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
93  kSinkCreated = CS_SINK_CREATED,
94  kSinkDestroyed = CS_SINK_DESTROYED,
95  kSinkEnabled = CS_SINK_ENABLED,
96  kSinkDisabled = CS_SINK_DISABLED,
97  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED,
98  kTelemetryUpdated = CS_TELEMETRY_UPDATED,
99  kSinkPropertyCreated = CS_SINK_PROPERTY_CREATED,
100  kSinkPropertyValueUpdated = CS_SINK_PROPERTY_VALUE_UPDATED,
101  kSinkPropertyChoicesUpdated = CS_SINK_PROPERTY_CHOICES_UPDATED
102  };
103 
104  RawEvent() = default;
105  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
106  RawEvent(wpi::StringRef name_, CS_Handle handle_, RawEvent::Kind kind_)
107  : kind{kind_}, name{name_} {
108  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
109  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
110  sinkHandle = handle_;
111  else
112  sourceHandle = handle_;
113  }
114  RawEvent(wpi::StringRef name_, CS_Source source_, const VideoMode& mode_)
115  : kind{kSourceVideoModeChanged},
116  sourceHandle{source_},
117  name{name_},
118  mode{mode_} {}
119  RawEvent(wpi::StringRef name_, CS_Source source_, RawEvent::Kind kind_,
120  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
121  wpi::StringRef valueStr_)
122  : kind{kind_},
123  sourceHandle{source_},
124  name{name_},
125  propertyHandle{property_},
126  propertyKind{propertyKind_},
127  value{value_},
128  valueStr{valueStr_} {}
129 
130  Kind kind;
131 
132  // Valid for kSource* and kSink* respectively
133  CS_Source sourceHandle = CS_INVALID_HANDLE;
134  CS_Sink sinkHandle = CS_INVALID_HANDLE;
135 
136  // Source/sink/property name
137  std::string name;
138 
139  // Fields for kSourceVideoModeChanged event
140  VideoMode mode;
141 
142  // Fields for kSourceProperty* events
143  CS_Property propertyHandle;
144  CS_PropertyKind propertyKind;
145  int value;
146  std::string valueStr;
147 };
148 
153 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
154 std::string GetPropertyName(CS_Property property, CS_Status* status);
155 wpi::StringRef GetPropertyName(CS_Property property,
157  CS_Status* status);
158 int GetProperty(CS_Property property, CS_Status* status);
159 void SetProperty(CS_Property property, int value, CS_Status* status);
160 int GetPropertyMin(CS_Property property, CS_Status* status);
161 int GetPropertyMax(CS_Property property, CS_Status* status);
162 int GetPropertyStep(CS_Property property, CS_Status* status);
163 int GetPropertyDefault(CS_Property property, CS_Status* status);
164 std::string GetStringProperty(CS_Property property, CS_Status* status);
165 wpi::StringRef GetStringProperty(CS_Property property,
167  CS_Status* status);
168 void SetStringProperty(CS_Property property, wpi::StringRef value,
169  CS_Status* status);
170 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
171  CS_Status* status);
178 CS_Source CreateUsbCameraDev(wpi::StringRef name, int dev, CS_Status* status);
179 CS_Source CreateUsbCameraPath(wpi::StringRef name, wpi::StringRef path,
180  CS_Status* status);
181 CS_Source CreateHttpCamera(wpi::StringRef name, wpi::StringRef url,
182  CS_HttpCameraKind kind, CS_Status* status);
183 CS_Source CreateHttpCamera(wpi::StringRef name, wpi::ArrayRef<std::string> urls,
184  CS_HttpCameraKind kind, CS_Status* status);
185 CS_Source CreateCvSource(wpi::StringRef name, const VideoMode& mode,
186  CS_Status* status);
193 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
194 std::string GetSourceName(CS_Source source, CS_Status* status);
195 wpi::StringRef GetSourceName(CS_Source source, wpi::SmallVectorImpl<char>& buf,
196  CS_Status* status);
197 std::string GetSourceDescription(CS_Source source, CS_Status* status);
198 wpi::StringRef GetSourceDescription(CS_Source source,
200  CS_Status* status);
201 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
202 bool IsSourceConnected(CS_Source source, CS_Status* status);
203 CS_Property GetSourceProperty(CS_Source source, wpi::StringRef name,
204  CS_Status* status);
205 wpi::ArrayRef<CS_Property> EnumerateSourceProperties(
206  CS_Source source, wpi::SmallVectorImpl<CS_Property>& vec,
207  CS_Status* status);
208 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
209 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
210  CS_Status* status);
211 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
212  CS_Status* status);
213 bool SetSourceResolution(CS_Source source, int width, int height,
214  CS_Status* status);
215 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
216 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
217  CS_Status* status);
218 wpi::ArrayRef<CS_Sink> EnumerateSourceSinks(CS_Source source,
220  CS_Status* status);
221 CS_Source CopySource(CS_Source source, CS_Status* status);
222 void ReleaseSource(CS_Source source, CS_Status* status);
229 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
230 int GetCameraBrightness(CS_Source source, CS_Status* status);
231 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
232 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
233 void SetCameraWhiteBalanceManual(CS_Source source, int value,
234  CS_Status* status);
235 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
236 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
237 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
244 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
251 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
252 void SetHttpCameraUrls(CS_Source source, wpi::ArrayRef<std::string> urls,
253  CS_Status* status);
254 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
261 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
262 void NotifySourceError(CS_Source source, wpi::StringRef msg, CS_Status* status);
263 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
264 void SetSourceDescription(CS_Source source, wpi::StringRef description,
265  CS_Status* status);
266 CS_Property CreateSourceProperty(CS_Source source, wpi::StringRef name,
267  CS_PropertyKind kind, int minimum, int maximum,
268  int step, int defaultValue, int value,
269  CS_Status* status);
270 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
272  CS_Status* status);
279 CS_Sink CreateMjpegServer(wpi::StringRef name, wpi::StringRef listenAddress,
280  int port, CS_Status* status);
281 CS_Sink CreateCvSink(wpi::StringRef name, CS_Status* status);
282 CS_Sink CreateCvSinkCallback(wpi::StringRef name,
283  std::function<void(uint64_t time)> processFrame,
284  CS_Status* status);
291 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
292 std::string GetSinkName(CS_Sink sink, CS_Status* status);
293 wpi::StringRef GetSinkName(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
294  CS_Status* status);
295 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
296 wpi::StringRef GetSinkDescription(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
297  CS_Status* status);
298 CS_Property GetSinkProperty(CS_Sink sink, wpi::StringRef name,
299  CS_Status* status);
300 wpi::ArrayRef<CS_Property> EnumerateSinkProperties(
301  CS_Sink sink, wpi::SmallVectorImpl<CS_Property>& vec, CS_Status* status);
302 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
303 CS_Property GetSinkSourceProperty(CS_Sink sink, wpi::StringRef name,
304  CS_Status* status);
305 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
306 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
307 void ReleaseSink(CS_Sink sink, CS_Status* status);
314 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
315 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
322 void SetSinkDescription(CS_Sink sink, wpi::StringRef description,
323  CS_Status* status);
324 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
325 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
326  CS_Status* status);
327 std::string GetSinkError(CS_Sink sink, CS_Status* status);
328 wpi::StringRef GetSinkError(CS_Sink sink, wpi::SmallVectorImpl<char>& buf,
329  CS_Status* status);
330 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
337 void SetListenerOnStart(std::function<void()> onStart);
338 void SetListenerOnExit(std::function<void()> onExit);
339 
340 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
341  int eventMask, bool immediateNotify, CS_Status* status);
342 
343 void RemoveListener(CS_Listener handle, CS_Status* status);
346 bool NotifierDestroyed();
347 
352 void SetTelemetryPeriod(double seconds);
353 double GetTelemetryElapsedTime();
354 int64_t GetTelemetryValue(CS_Handle handle, CS_TelemetryKind kind,
355  CS_Status* status);
356 double GetTelemetryAverageValue(CS_Handle handle, CS_TelemetryKind kind,
357  CS_Status* status);
364 typedef std::function<void(unsigned int level, const char* file,
365  unsigned int line, const char* msg)>
366  LogFunc;
367 void SetLogger(LogFunc func, unsigned int min_level);
368 void SetDefaultLogger(unsigned int min_level);
375 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
376 
377 wpi::ArrayRef<CS_Source> EnumerateSourceHandles(
378  wpi::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
379 wpi::ArrayRef<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec,
380  CS_Status* status);
381 
382 std::string GetHostname();
383 
384 std::vector<std::string> GetNetworkInterfaces();
389 } // namespace cs
390 
397 extern "C" {
398 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
399 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
400  double timeout, CS_Status* status);
401 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
402 } // extern "C"
405 #endif // CSCORE_CSCORE_CPP_H_
CS_TelemetryKind
Telemetry kinds.
Definition: cscore_c.h:176
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:81
Definition: cscore_cpp.h:23
CS_SourceKind
Source kinds.
Definition: cscore_c.h:126
USB camera information.
Definition: cscore_cpp.h:42
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
int dev
Device number (e.g.
Definition: cscore_cpp.h:44
CS_PropertyKind
Property kinds.
Definition: cscore_c.h:115
std::string path
Path to device if available (e.g.
Definition: cscore_cpp.h:46
std::string name
Vendor/model name of the camera as provided by the USB driver.
Definition: cscore_cpp.h:48
Video mode.
Definition: cscore_cpp.h:54
Video mode.
Definition: cscore_c.h:105