WPILibC++  unspecified
cscore_cpp.h
1 /*----------------------------------------------------------------------------*/
2 /* Copyright (c) 2015-2017 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 <llvm/ArrayRef.h>
18 #include <llvm/SmallVector.h>
19 #include <llvm/StringRef.h>
20 
21 #include "cscore_c.h"
22 
23 namespace cv {
24 class Mat;
25 } // namespace cv
26 
27 namespace cs {
28 
29 //
30 // Handle-based interface for C++. Users are encouraged to use the
31 // object oriented interface instead; this interface is intended for use
32 // in applications such as JNI which require handle-based access.
33 //
34 
36 struct UsbCameraInfo {
38  int dev;
40  std::string path;
42  std::string name;
43 };
44 
46 struct VideoMode : public CS_VideoMode {
47  enum PixelFormat {
48  kUnknown = CS_PIXFMT_UNKNOWN,
49  kMJPEG = CS_PIXFMT_MJPEG,
50  kYUYV = CS_PIXFMT_YUYV,
51  kRGB565 = CS_PIXFMT_RGB565,
52  kBGR = CS_PIXFMT_BGR,
53  kGray = CS_PIXFMT_GRAY
54  };
55  VideoMode() {
56  pixelFormat = 0;
57  width = 0;
58  height = 0;
59  fps = 0;
60  }
61  VideoMode(PixelFormat pixelFormat_, int width_, int height_, int fps_) {
62  pixelFormat = pixelFormat_;
63  width = width_;
64  height = height_;
65  fps = fps_;
66  }
67  explicit operator bool() const { return pixelFormat == kUnknown; }
68 };
69 
71 struct RawEvent {
72  enum Kind {
73  kSourceCreated = CS_SOURCE_CREATED,
74  kSourceDestroyed = CS_SOURCE_DESTROYED,
75  kSourceConnected = CS_SOURCE_CONNECTED,
76  kSourceDisconnected = CS_SOURCE_DISCONNECTED,
77  kSourceVideoModesUpdated = CS_SOURCE_VIDEOMODES_UPDATED,
78  kSourceVideoModeChanged = CS_SOURCE_VIDEOMODE_CHANGED,
79  kSourcePropertyCreated = CS_SOURCE_PROPERTY_CREATED,
80  kSourcePropertyValueUpdated = CS_SOURCE_PROPERTY_VALUE_UPDATED,
81  kSourcePropertyChoicesUpdated = CS_SOURCE_PROPERTY_CHOICES_UPDATED,
82  kSinkSourceChanged = CS_SINK_SOURCE_CHANGED,
83  kSinkCreated = CS_SINK_CREATED,
84  kSinkDestroyed = CS_SINK_DESTROYED,
85  kSinkEnabled = CS_SINK_ENABLED,
86  kSinkDisabled = CS_SINK_DISABLED,
87  kNetworkInterfacesChanged = CS_NETWORK_INTERFACES_CHANGED
88  };
89 
90  RawEvent() = default;
91  explicit RawEvent(RawEvent::Kind kind_) : kind{kind_} {}
92  RawEvent(llvm::StringRef name_, CS_Handle handle_, RawEvent::Kind kind_)
93  : kind{kind_}, name{name_} {
94  if (kind_ == kSinkCreated || kind_ == kSinkDestroyed ||
95  kind_ == kSinkEnabled || kind_ == kSinkDisabled)
96  sinkHandle = handle_;
97  else
98  sourceHandle = handle_;
99  }
100  RawEvent(llvm::StringRef name_, CS_Source source_, const VideoMode& mode_)
101  : kind{kSourceVideoModeChanged},
102  sourceHandle{source_},
103  name{name_},
104  mode{mode_} {}
105  RawEvent(llvm::StringRef name_, CS_Source source_, RawEvent::Kind kind_,
106  CS_Property property_, CS_PropertyKind propertyKind_, int value_,
107  llvm::StringRef valueStr_)
108  : kind{kind_},
109  sourceHandle{source_},
110  name{name_},
111  propertyHandle{property_},
112  propertyKind{propertyKind_},
113  value{value_},
114  valueStr{valueStr_} {}
115 
116  Kind kind;
117 
118  // Valid for kSource* and kSink* respectively
119  CS_Source sourceHandle = CS_INVALID_HANDLE;
120  CS_Sink sinkHandle = CS_INVALID_HANDLE;
121 
122  // Source/sink/property name
123  std::string name;
124 
125  // Fields for kSourceVideoModeChanged event
126  VideoMode mode;
127 
128  // Fields for kSourceProperty* events
129  CS_Property propertyHandle;
130  CS_PropertyKind propertyKind;
131  int value;
132  std::string valueStr;
133 };
134 
135 //
136 // Property Functions
137 //
138 CS_PropertyKind GetPropertyKind(CS_Property property, CS_Status* status);
139 std::string GetPropertyName(CS_Property property, CS_Status* status);
140 llvm::StringRef GetPropertyName(CS_Property property,
142  CS_Status* status);
143 int GetProperty(CS_Property property, CS_Status* status);
144 void SetProperty(CS_Property property, int value, CS_Status* status);
145 int GetPropertyMin(CS_Property property, CS_Status* status);
146 int GetPropertyMax(CS_Property property, CS_Status* status);
147 int GetPropertyStep(CS_Property property, CS_Status* status);
148 int GetPropertyDefault(CS_Property property, CS_Status* status);
149 std::string GetStringProperty(CS_Property property, CS_Status* status);
150 llvm::StringRef GetStringProperty(CS_Property property,
152  CS_Status* status);
153 void SetStringProperty(CS_Property property, llvm::StringRef value,
154  CS_Status* status);
155 std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
156  CS_Status* status);
157 
158 //
159 // Source Creation Functions
160 //
161 CS_Source CreateUsbCameraDev(llvm::StringRef name, int dev, CS_Status* status);
162 CS_Source CreateUsbCameraPath(llvm::StringRef name, llvm::StringRef path,
163  CS_Status* status);
164 CS_Source CreateHttpCamera(llvm::StringRef name, llvm::StringRef url,
165  CS_HttpCameraKind kind, CS_Status* status);
166 CS_Source CreateHttpCamera(llvm::StringRef name,
168  CS_HttpCameraKind kind, CS_Status* status);
169 CS_Source CreateCvSource(llvm::StringRef name, const VideoMode& mode,
170  CS_Status* status);
171 
172 //
173 // Source Functions
174 //
175 CS_SourceKind GetSourceKind(CS_Source source, CS_Status* status);
176 std::string GetSourceName(CS_Source source, CS_Status* status);
177 llvm::StringRef GetSourceName(CS_Source source,
179  CS_Status* status);
180 std::string GetSourceDescription(CS_Source source, CS_Status* status);
181 llvm::StringRef GetSourceDescription(CS_Source source,
183  CS_Status* status);
184 uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status);
185 bool IsSourceConnected(CS_Source source, CS_Status* status);
186 CS_Property GetSourceProperty(CS_Source source, llvm::StringRef name,
187  CS_Status* status);
188 llvm::ArrayRef<CS_Property> EnumerateSourceProperties(
189  CS_Source source, llvm::SmallVectorImpl<CS_Property>& vec,
190  CS_Status* status);
191 VideoMode GetSourceVideoMode(CS_Source source, CS_Status* status);
192 bool SetSourceVideoMode(CS_Source source, const VideoMode& mode,
193  CS_Status* status);
194 bool SetSourcePixelFormat(CS_Source source, VideoMode::PixelFormat pixelFormat,
195  CS_Status* status);
196 bool SetSourceResolution(CS_Source source, int width, int height,
197  CS_Status* status);
198 bool SetSourceFPS(CS_Source source, int fps, CS_Status* status);
199 std::vector<VideoMode> EnumerateSourceVideoModes(CS_Source source,
200  CS_Status* status);
201 llvm::ArrayRef<CS_Sink> EnumerateSourceSinks(
202  CS_Source source, llvm::SmallVectorImpl<CS_Sink>& vec, CS_Status* status);
203 CS_Source CopySource(CS_Source source, CS_Status* status);
204 void ReleaseSource(CS_Source source, CS_Status* status);
205 
206 //
207 // Camera Source Common Property Fuctions
208 //
209 void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status);
210 int GetCameraBrightness(CS_Source source, CS_Status* status);
211 void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status);
212 void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status);
213 void SetCameraWhiteBalanceManual(CS_Source source, int value,
214  CS_Status* status);
215 void SetCameraExposureAuto(CS_Source source, CS_Status* status);
216 void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status);
217 void SetCameraExposureManual(CS_Source source, int value, CS_Status* status);
218 
219 //
220 // UsbCamera Source Functions
221 //
222 std::string GetUsbCameraPath(CS_Source source, CS_Status* status);
223 
224 //
225 // HttpCamera Source Functions
226 //
227 CS_HttpCameraKind GetHttpCameraKind(CS_Source source, CS_Status* status);
228 void SetHttpCameraUrls(CS_Source source, llvm::ArrayRef<std::string> urls,
229  CS_Status* status);
230 std::vector<std::string> GetHttpCameraUrls(CS_Source source, CS_Status* status);
231 
232 //
233 // OpenCV Source Functions
234 //
235 void PutSourceFrame(CS_Source source, cv::Mat& image, CS_Status* status);
236 void NotifySourceError(CS_Source source, llvm::StringRef msg,
237  CS_Status* status);
238 void SetSourceConnected(CS_Source source, bool connected, CS_Status* status);
239 void SetSourceDescription(CS_Source source, llvm::StringRef description,
240  CS_Status* status);
241 CS_Property CreateSourceProperty(CS_Source source, llvm::StringRef name,
242  CS_PropertyKind kind, int minimum, int maximum,
243  int step, int defaultValue, int value,
244  CS_Status* status);
245 void SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
247  CS_Status* status);
248 
249 //
250 // Sink Creation Functions
251 //
252 CS_Sink CreateMjpegServer(llvm::StringRef name, llvm::StringRef listenAddress,
253  int port, CS_Status* status);
254 CS_Sink CreateCvSink(llvm::StringRef name, CS_Status* status);
255 CS_Sink CreateCvSinkCallback(llvm::StringRef name,
256  std::function<void(uint64_t time)> processFrame,
257  CS_Status* status);
258 
259 //
260 // Sink Functions
261 //
262 CS_SinkKind GetSinkKind(CS_Sink sink, CS_Status* status);
263 std::string GetSinkName(CS_Sink sink, CS_Status* status);
264 llvm::StringRef GetSinkName(CS_Sink sink, llvm::SmallVectorImpl<char>& buf,
265  CS_Status* status);
266 std::string GetSinkDescription(CS_Sink sink, CS_Status* status);
267 llvm::StringRef GetSinkDescription(CS_Sink sink,
269  CS_Status* status);
270 void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status);
271 CS_Property GetSinkSourceProperty(CS_Sink sink, llvm::StringRef name,
272  CS_Status* status);
273 CS_Source GetSinkSource(CS_Sink sink, CS_Status* status);
274 CS_Sink CopySink(CS_Sink sink, CS_Status* status);
275 void ReleaseSink(CS_Sink sink, CS_Status* status);
276 
277 //
278 // MjpegServer Sink Functions
279 //
280 std::string GetMjpegServerListenAddress(CS_Sink sink, CS_Status* status);
281 int GetMjpegServerPort(CS_Sink sink, CS_Status* status);
282 
283 //
284 // OpenCV Sink Functions
285 //
286 void SetSinkDescription(CS_Sink sink, llvm::StringRef description,
287  CS_Status* status);
288 uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat& image, CS_Status* status);
289 uint64_t GrabSinkFrameTimeout(CS_Sink sink, cv::Mat& image, double timeout,
290  CS_Status* status);
291 std::string GetSinkError(CS_Sink sink, CS_Status* status);
292 llvm::StringRef GetSinkError(CS_Sink sink, llvm::SmallVectorImpl<char>& buf,
293  CS_Status* status);
294 void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status);
295 
296 //
297 // Listener Functions
298 //
299 void SetListenerOnStart(std::function<void()> onStart);
300 void SetListenerOnExit(std::function<void()> onExit);
301 
302 CS_Listener AddListener(std::function<void(const RawEvent& event)> callback,
303  int eventMask, bool immediateNotify, CS_Status* status);
304 
305 void RemoveListener(CS_Listener handle, CS_Status* status);
306 
307 bool NotifierDestroyed();
308 
309 //
310 // Logging Functions
311 //
312 typedef std::function<void(unsigned int level, const char* file,
313  unsigned int line, const char* msg)>
314  LogFunc;
315 void SetLogger(LogFunc func, unsigned int min_level);
316 void SetDefaultLogger(unsigned int min_level);
317 
318 //
319 // Utility Functions
320 //
321 std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status);
322 
323 llvm::ArrayRef<CS_Source> EnumerateSourceHandles(
324  llvm::SmallVectorImpl<CS_Source>& vec, CS_Status* status);
325 llvm::ArrayRef<CS_Sink> EnumerateSinkHandles(
326  llvm::SmallVectorImpl<CS_Sink>& vec, CS_Status* status);
327 
328 std::string GetHostname();
329 
330 std::vector<std::string> GetNetworkInterfaces();
331 
332 } // namespace cs
333 
334 // C functions taking a cv::Mat* for specific interop implementations
335 extern "C" {
336 uint64_t CS_GrabSinkFrameCpp(CS_Sink sink, cv::Mat* image, CS_Status* status);
337 uint64_t CS_GrabSinkFrameTimeoutCpp(CS_Sink sink, cv::Mat* image,
338  double timeout, CS_Status* status);
339 void CS_PutSourceFrameCpp(CS_Source source, cv::Mat* image, CS_Status* status);
340 } // extern "C"
341 
342 #endif // CSCORE_CSCORE_CPP_H_
Definition: SinkImpl.h:19
std::function< void(unsigned int level, const char *file, unsigned int line, const char *msg)> LogFunc
Log function.
Definition: ntcore_cpp.h:1369
Listener event.
Definition: cscore_cpp.h:71
Definition: cscore_cpp.h:23
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:32
void SetLogger(LogFunc func, unsigned int min_level)
Set logger callback function.
Definition: ntcore_cpp.cpp:955
USB camera information.
Definition: cscore_cpp.h:36
int dev
Device number (e.g. N in &#39;/dev/videoN&#39; on Linux)
Definition: cscore_cpp.h:38
std::string path
Path to device if available (e.g. &#39;/dev/video0&#39; on Linux)
Definition: cscore_cpp.h:40
std::string name
Vendor/model name of the camera as provided by the USB driver.
Definition: cscore_cpp.h:42
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:42
Video mode.
Definition: cscore_cpp.h:46
Definition: cscore_c.h:90