Update types & add callbacks

src/device/device.cc

@@ -13,6 +13,7 @@ MYNTEYE_BEGIN_NAMESPACE
 Device::Device(const Model &model, std::shared_ptr<uvc::device> device)
     : model_(model), device_(device) {
   VLOG(2) << __func__;
+  ReadDeviceInfo();
 }
 
 Device::~Device() {
@@ -79,4 +80,61 @@ std::string Device::GetInfo(const Info &info) const {
   }
 }
 
+ImgIntrinsics Device::GetImgIntrinsics() const {
+  return img_intrinsics_;
+}
+
+ImgExtrinsics Device::GetImgExtrinsics() const {
+  return img_extrinsics_;
+}
+
+ImuIntrinsics Device::GetImuIntrinsics() const {
+  return imu_intrinsics_;
+}
+
+ImuExtrinsics Device::GetImuExtrinsics() const {
+  return imu_extrinsics_;
+}
+
+void Device::SetStreamCallback(
+    const Stream &stream, stream_callback_t callback) {
+  if (!Supports(stream)) {
+    LOG(WARNING) << "Unsupported stream: " << to_string(stream);
+    return;
+  }
+  if (callback) {
+    stream_callbacks_[stream] = callback;
+  } else {
+    stream_callbacks_.erase(stream);
+  }
+}
+
+void Device::SetMotionCallback(motion_callback_t callback) {
+  motion_callback_ = callback;
+}
+
+void Device::ReadDeviceInfo() {
+  // TODO(JohnZhao): Read device info
+}
+
+void Device::WriteImgIntrinsics(const ImgIntrinsics &intrinsics) {
+  // TODO(JohnZhao): Write img intrinsics
+  UNUSED(intrinsics);
+}
+
+void Device::WriteImgExtrinsics(const ImgExtrinsics &extrinsics) {
+  // TODO(JohnZhao): Write img extrinsics
+  UNUSED(extrinsics);
+}
+
+void Device::WriteImuIntrinsics(const ImuIntrinsics &intrinsics) {
+  // TODO(JohnZhao): Write imu intrinsics
+  UNUSED(intrinsics);
+}
+
+void Device::WriteImuExtrinsics(const ImuExtrinsics &extrinsics) {
+  // TODO(JohnZhao): Write imu extrinsics
+  UNUSED(extrinsics);
+}
+
 MYNTEYE_END_NAMESPACE

src/device/device.h

@@ -2,12 +2,15 @@
 #define MYNTEYE_DEVICE_H_
 #pragma once
 
+#include <map>
 #include <memory>
 #include <string>
 
 #include "mynteye/mynteye.h"
 #include "mynteye/types.h"
 
+#include "internal/callbacks.h"
+
 MYNTEYE_BEGIN_NAMESPACE
 
 namespace uvc {
@@ -20,12 +23,21 @@ struct DeviceInfo;
 
 class Device {
  public:
+  using stream_callback_t = device::StreamCallback;
+  using motion_callback_t = device::MotionCallback;
+
+  using stream_callbacks_t = std::map<Stream, stream_callback_t>;
+
   Device(const Model &model, std::shared_ptr<uvc::device> device);
   virtual ~Device();
 
   static std::shared_ptr<Device> Create(
       const std::string &name, std::shared_ptr<uvc::device> device);
 
+  Model GetModel() const {
+    return model_;
+  }
+
   bool Supports(const Stream &stream) const;
   bool Supports(const Capabilities &capability) const;
   bool Supports(const Option &option) const;
@@ -33,19 +45,46 @@ class Device {
   std::shared_ptr<DeviceInfo> GetInfo() const;
   std::string GetInfo(const Info &info) const;
 
-  Model model() const {
-    return model_;
-  }
+  ImgIntrinsics GetImgIntrinsics() const;
+  ImgExtrinsics GetImgExtrinsics() const;
+
+  ImuIntrinsics GetImuIntrinsics() const;
+  ImuExtrinsics GetImuExtrinsics() const;
+
+  void SetStreamCallback(const Stream &stream, stream_callback_t callback);
+  void SetMotionCallback(motion_callback_t callback);
 
  protected:
   std::shared_ptr<uvc::device> device() const {
     return device_;
   }
 
+  std::shared_ptr<DeviceInfo> device_info() const {
+    return device_info_;
+  }
+
  private:
   Model model_;
   std::shared_ptr<uvc::device> device_;
   std::shared_ptr<DeviceInfo> device_info_;
+
+  ImgIntrinsics img_intrinsics_;
+  ImgExtrinsics img_extrinsics_;
+  ImuIntrinsics imu_intrinsics_;
+  ImuExtrinsics imu_extrinsics_;
+
+  stream_callbacks_t stream_callbacks_;
+  motion_callback_t motion_callback_;
+
+  void ReadDeviceInfo();
+
+  void WriteImgIntrinsics(const ImgIntrinsics &intrinsics);
+  void WriteImgExtrinsics(const ImgExtrinsics &extrinsics);
+
+  void WriteImuIntrinsics(const ImuIntrinsics &intrinsics);
+  void WriteImuExtrinsics(const ImuExtrinsics &extrinsics);
+
+  // friend DeviceWriter;
 };
 
 MYNTEYE_END_NAMESPACE

src/internal/callbacks.h

@@ -0,0 +1,29 @@
+#ifndef MYNTEYE_INTERNAL_CALLBACKS_H_  // NOLINT
+#define MYNTEYE_INTERNAL_CALLBACKS_H_
+#pragma once
+
+#include <functional>
+
+#include "mynteye/mynteye.h"
+#include "mynteye/types.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+namespace device {
+
+struct MYNTEYE_API StreamData {
+  ImgData img;
+};
+
+struct MYNTEYE_API MotionData {
+  ImuData imu;
+};
+
+using StreamCallback = std::function<void(const StreamData &data)>;
+using MotionCallback = std::function<void(const MotionData &data)>;
+
+}  // namespace device
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_INTERNAL_CALLBACKS_H_ NOLINT

src/internal/types.h

@@ -12,20 +12,6 @@
 
 MYNTEYE_BEGIN_NAMESPACE
 
-#define MYNTEYE_FOURCC(a, b, c, d)                  \
-  ((std::uint32_t)(a) | ((std::uint32_t)(b) << 8) | \
-   ((std::uint32_t)(c) << 16) | ((std::uint32_t)(d) << 24))  // NOLINT
-
-/**
- * @ingroup enumerations
- * @brief Formats define how each stream can be encoded.
- */
-enum class Format : std::uint32_t {
-  YUYV = MYNTEYE_FOURCC('Y', 'U', 'Y', 'V'),
-};
-
-#undef MYNTEYE_FOURCC
-
 #define MYNTEYE_PROPERTY(TYPE, NAME) \
  public:                             \
   void set_##NAME(TYPE NAME) {       \

src/public/types.cc

@@ -102,4 +102,16 @@ const char *to_string(const Option &value) {
 #undef CASE
 }
 
+const char *to_string(const Format &value) {
+#define CASE(X)   \
+  case Format::X: \
+    return "Format::" #X;
+  switch (value) {
+    CASE(YUYV)
+    default:
+      return "Format::UNKNOWN";
+  }
+#undef CASE
+}
+
 MYNTEYE_END_NAMESPACE