Add streams & its request

src/internal/callbacks.h

@@ -2,7 +2,10 @@
 #define MYNTEYE_INTERNAL_CALLBACKS_H_
 #pragma once
 
+#include <cstdint>
 #include <functional>
+#include <memory>
+#include <vector>
 
 #include "mynteye/mynteye.h"
 #include "mynteye/types.h"
@@ -11,8 +14,48 @@ MYNTEYE_BEGIN_NAMESPACE
 
 namespace device {
 
+class Frame {
+ public:
+  using data_t = std::vector<std::uint8_t>;
+
+  Frame(const StreamRequest &request, const void *data)
+      : Frame(request.width, request.height, request.format, data) {}
+
+  Frame(
+      std::uint16_t width, std::uint16_t height, Format format,
+      const void *data)
+      : width_(width), height_(height), format_(format) {
+    const std::uint8_t *bytes = static_cast<const std::uint8_t *>(data);
+    data_ = data_t(bytes, bytes + (width * height) * bytes_per_pixel(format));
+  }
+
+  std::uint16_t width() const {
+    return width_;
+  }
+
+  std::uint16_t height() const {
+    return height_;
+  }
+
+  Format format() const {
+    return format_;
+  }
+
+  const data_t &data() const {
+    return data_;
+  }
+
+ private:
+  std::uint16_t width_;
+  std::uint16_t height_;
+  Format format_;
+
+  data_t data_;
+};
+
 struct MYNTEYE_API StreamData {
   ImgData img;
+  std::shared_ptr<Frame> frame;
 };
 
 struct MYNTEYE_API MotionData {

src/internal/config.cc

@@ -15,7 +15,9 @@ const std::map<Model, OptionSupports> option_supports_map = {
       Option::MAX_EXPOSURE_TIME, Option::DESIRED_BRIGHTNESS, Option::IR_CONTROL,
       Option::HDR_MODE, Option::ZERO_DRIFT_CALIBRATION, Option::ERASE_CHIP}}};
 
-const std::map<Model, StreamRequests> stream_requests_map = {
-    {Model::STANDARD, {{Capabilities::STEREO, {752, 480, Format::YUYV, 25}}}}};
+const std::map<Model, std::map<Capabilities, StreamRequests>>
+    stream_requests_map = {
+        {Model::STANDARD,
+         {{Capabilities::STEREO, {{752, 480, Format::YUYV, 25}}}}}};
 
 MYNTEYE_END_NAMESPACE

src/internal/config.h

@@ -19,9 +19,10 @@ extern const std::map<Model, StreamSupports> stream_supports_map;
 extern const std::map<Model, CapabilitiesSupports> capabilities_supports_map;
 extern const std::map<Model, OptionSupports> option_supports_map;
 
-using StreamRequests = std::map<Capabilities, StreamRequest>;
+using StreamRequests = std::vector<StreamRequest>;
 
-extern const std::map<Model, StreamRequests> stream_requests_map;
+extern const std::map<Model, std::map<Capabilities, StreamRequests>>
+    stream_requests_map;
 
 MYNTEYE_END_NAMESPACE
 

src/internal/streams.cc

@@ -0,0 +1,63 @@
+#include "internal/streams.h"
+
+#include <glog/logging.h>
+
+#include <algorithm>
+
+MYNTEYE_BEGIN_NAMESPACE
+
+Streams::Streams()
+    : stream_capabilities_(
+          {Capabilities::STEREO, Capabilities::COLOR, Capabilities::DEPTH,
+           Capabilities::POINTS, Capabilities::FISHEYE, Capabilities::INFRARED,
+           Capabilities::INFRARED2}) {
+  VLOG(2) << __func__;
+}
+
+Streams::~Streams() {
+  VLOG(2) << __func__;
+}
+
+void Streams::ConfigStream(
+    const Capabilities &capability, const StreamRequest &request) {
+  if (!IsStreamCapability(capability)) {
+    LOG(FATAL) << "Cannot config stream without stream capability";
+  }
+  stream_config_requests_[capability] = request;
+}
+
+void Streams::PushStream(const Capabilities &capability, const void *data) {
+  if (!HasStreamConfigRequest(capability)) {
+    LOG(FATAL) << "Cannot push stream without stream config request";
+  }
+  auto frame =
+      std::make_shared<frame_t>(GetStreamConfigRequest(capability), data);
+  // stream_datas_map_[Stream::LEFT];
+  // stream_datas_map_[Stream::RIGHT];
+}
+
+bool Streams::IsStreamCapability(const Capabilities &capability) const {
+  return std::find(
+             stream_capabilities_.begin(), stream_capabilities_.end(),
+             capability) != stream_capabilities_.end();
+}
+
+bool Streams::HasStreamConfigRequest(const Capabilities &capability) const {
+  return stream_config_requests_.find(capability) !=
+         stream_config_requests_.end();
+}
+
+const StreamRequest &Streams::GetStreamConfigRequest(
+    const Capabilities &capability) const {
+  return stream_config_requests_.at(capability);
+}
+
+bool Streams::HasStreamDatas(const Stream &stream) const {
+  return stream_datas_map_.find(stream) != stream_datas_map_.end();
+}
+
+Streams::stream_datas_t &Streams::GetStreamDatas(const Stream &stream) {
+  return stream_datas_map_[stream];
+}
+
+MYNTEYE_END_NAMESPACE

src/internal/streams.h

@@ -0,0 +1,60 @@
+#ifndef MYNTEYE_INTERNAL_STREAMS_H_  // NOLINT
+#define MYNTEYE_INTERNAL_STREAMS_H_
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "mynteye/mynteye.h"
+#include "mynteye/types.h"
+
+#include "internal/callbacks.h"
+
+MYNTEYE_BEGIN_NAMESPACE
+
+namespace streams {
+
+class Stream {
+ public:
+};
+
+}  // namesapce streams
+
+class Streams {
+ public:
+  using frame_t = device::Frame;
+  using stream_data_t = device::StreamData;
+  using stream_datas_t = std::vector<stream_data_t>;
+
+  Streams();
+  ~Streams();
+
+  void ConfigStream(
+      const Capabilities &capability, const StreamRequest &request);
+
+  void PushStream(const Capabilities &capability, const void *data);
+
+  // void WaitForStreams() const;
+
+  // std::vector<StreamData> GetStreamData(const Stream &stream) const;
+  // StreamData GetLatestStreamData(const Stream &stream) const;
+
+ private:
+  bool IsStreamCapability(const Capabilities &capability) const;
+  bool HasStreamConfigRequest(const Capabilities &capability) const;
+
+  const StreamRequest &GetStreamConfigRequest(
+      const Capabilities &capability) const;
+
+  bool HasStreamDatas(const Stream &stream) const;
+  stream_datas_t &GetStreamDatas(const Stream &stream);
+
+  std::vector<Capabilities> stream_capabilities_;
+  std::map<Capabilities, StreamRequest> stream_config_requests_;
+
+  std::map<Stream, stream_datas_t> stream_datas_map_;
+};
+
+MYNTEYE_END_NAMESPACE
+
+#endif  // MYNTEYE_INTERNAL_STREAMS_H_ NOLINT