refactor(synthetic): remove usless logic

src/mynteye/api/processor/root_camera_processor.cc

@@ -14,15 +14,21 @@
 #include "mynteye/api/processor/root_camera_processor.h"
 
 #include <utility>
+#include <vector>
 
 #include <opencv2/calib3d/calib3d.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
 #include "mynteye/logger.h"
+#include "mynteye/api/synthetic.h"
+#include "mynteye/device/device.h"
+#include "mynteye/api/data_tools.h"
 MYNTEYE_BEGIN_NAMESPACE
 const char RootProcessor::NAME[] = "RootProcessor";
 
-RootProcessor::RootProcessor(std::int32_t proc_period)
-    : Processor(std::move(proc_period)) {}
+RootProcessor::RootProcessor(std::shared_ptr<Device> device,
+    std::int32_t proc_period)
+    : Processor(std::move(proc_period)),
+    device_(device) {}
 RootProcessor::~RootProcessor() {
   VLOG(2) << __func__;
 }
@@ -31,13 +37,110 @@ std::string RootProcessor::Name() {
   return NAME;
 }
 
-Object *RootProcessor::OnCreateOutput() {
+s1s2Processor::s1s2Processor(std::shared_ptr<Device> device,
+    std::int32_t proc_period)
+    : RootProcessor(device, std::move(proc_period)) {}
+s1s2Processor::~s1s2Processor() {
+  VLOG(2) << __func__;
+}
+
+Object *s1s2Processor::OnCreateOutput() {
     return new ObjMat2();
 }
-bool RootProcessor::OnProcess(
+bool s1s2Processor::OnProcess(
     Object *const in, Object *const out,
     std::shared_ptr<Processor> const parent) {
+  const ObjMat2 *input = Object::Cast<ObjMat2>(in);
+  ObjMat2 *output = Object::Cast<ObjMat2>(out);
+  output->second = input->second;
+  output->first = input->first;
+  output->first_id = input->first_id;
+  output->first_data = input->first_data;
+  output->second_id = input->second_id;
+  output->second_data = input->second_data;
   MYNTEYE_UNUSED(parent)
   return true;
 }
+
+void s1s2Processor::ProcessNativeStream(
+    const Stream &stream, const api::StreamData &data) {
+  std::unique_lock<std::mutex> lk(mtx_left_right_ready_);
+  static api::StreamData left_data, right_data;
+  if (stream == Stream::LEFT) {
+    left_data = data;
+  } else if (stream == Stream::RIGHT) {
+    right_data = data;
+  }
+  if (left_data.img && right_data.img &&
+      left_data.img->frame_id == right_data.img->frame_id) {
+    Process(data_obj(left_data, right_data));
+  }
+  return;
+}
+
+void s1s2Processor::StartVideoStreaming() {
+  auto streams = getTargetStreams();
+  for (unsigned int j =0; j< streams.size(); j++) {
+    auto stream = streams[j].stream;
+    auto callback = streams[j].stream_callback;
+    device_->SetStreamCallback(
+      stream,
+      [this, stream, callback](const device::StreamData &data) {
+        auto &&stream_data = data2api(data);
+        ProcessNativeStream(stream, stream_data);
+        // Need mutex if set callback after start
+        if (callback) {
+          callback(stream_data);
+        }
+      },
+      true);
+  }
+  device_->Start(Source::VIDEO_STREAMING);
+}
+
+void s1s2Processor::StopVideoStreaming() {
+  auto streams = getTargetStreams();
+  for (unsigned int j =0; j< streams.size(); j++) {
+    auto stream = streams[j].stream;
+    device_->SetStreamCallback(stream, nullptr);
+  }
+  device_->Stop(Source::VIDEO_STREAMING);
+}
+
+api::StreamData s1s2Processor::GetStreamData(const Stream &stream) {
+  Synthetic::Mode enable_mode = Synthetic::MODE_LAST;
+  auto streams = getTargetStreams();
+  for (auto it_s : streams) {
+    if (it_s.stream == stream) {
+      enable_mode = it_s.enabled_mode_;
+      break;
+    }
+  }
+  if (enable_mode == Synthetic::MODE_SYNTHETIC) {
+    return data2api(device_->GetStreamData(stream));
+  }
+  LOG(ERROR) << "Failed to get device stream data of " << stream
+               << ", unsupported or disabled";
+  return {};
+}
+
+std::vector<api::StreamData> s1s2Processor::GetStreamDatas(
+    const Stream &stream) {
+  Synthetic::Mode enable_mode = Synthetic::MODE_LAST;
+  auto streams = getTargetStreams();
+  for (auto it_s : streams) {
+    if (it_s.stream == stream) {
+      enable_mode = it_s.enabled_mode_;
+      break;
+    }
+  }
+  if (enable_mode == Synthetic::MODE_SYNTHETIC) {
+    std::vector<api::StreamData> datas;
+    for (auto &&data : device_->GetStreamDatas(stream)) {
+      datas.push_back(data2api(data));
+    }
+    return datas;
+  }
+}
+
 MYNTEYE_END_NAMESPACE

src/mynteye/api/processor/root_camera_processor.h

@@ -28,16 +28,42 @@ class RootProcessor : public Processor {
  public:
   static const char NAME[];
 
-  explicit RootProcessor(std::int32_t proc_period = 0);
+  explicit RootProcessor(std::shared_ptr<Device> device,
+      std::int32_t proc_period = 0);
   virtual ~RootProcessor();
 
-  std::string Name() override;
+  virtual std::string Name();
 
+  virtual void StartVideoStreaming() = 0;
+  virtual void StopVideoStreaming() = 0;
+  virtual api::StreamData GetStreamData(const Stream &stream) = 0;
+  virtual std::vector<api::StreamData> GetStreamDatas(const Stream &stream) = 0; // NOLINT
+ protected:
+  virtual Object *OnCreateOutput() = 0;
+  virtual bool OnProcess(
+      Object *const in, Object *const out,
+      std::shared_ptr<Processor> const parent) = 0;
+  std::shared_ptr<Device> device_;
+};
+
+class s1s2Processor : public RootProcessor {
+ public:
+  explicit s1s2Processor(std::shared_ptr<Device> device,
+      std::int32_t proc_period = 0);
+  virtual ~s1s2Processor();
+  void StartVideoStreaming();
+  void StopVideoStreaming();
+  api::StreamData GetStreamData(const Stream &stream) override;
+  std::vector<api::StreamData> GetStreamDatas(const Stream &stream) override; // NOLINT
  protected:
   Object *OnCreateOutput() override;
   bool OnProcess(
       Object *const in, Object *const out,
       std::shared_ptr<Processor> const parent) override;
+ private:
+  void ProcessNativeStream(
+    const Stream &stream, const api::StreamData &data);
+  std::mutex mtx_left_right_ready_;
 };
 
 MYNTEYE_END_NAMESPACE