PR #12353 from Eran: refactor software-device, sensor.h, streaming.h

src/CMakeLists.txt

@@ -89,6 +89,8 @@ target_sources(${LRS_TARGET}
         "${CMAKE_CURRENT_LIST_DIR}/hid-sensor.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/uvc-sensor.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/software-device.cpp"
+        "${CMAKE_CURRENT_LIST_DIR}/software-device-info.cpp"
+        "${CMAKE_CURRENT_LIST_DIR}/software-sensor.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/source.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/stream.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/sync.cpp"
@@ -140,6 +142,8 @@ target_sources(${LRS_TARGET}
         "${CMAKE_CURRENT_LIST_DIR}/hid-sensor.h"
         "${CMAKE_CURRENT_LIST_DIR}/uvc-sensor.h"
         "${CMAKE_CURRENT_LIST_DIR}/software-device.h"
+        "${CMAKE_CURRENT_LIST_DIR}/software-device-info.h"
+        "${CMAKE_CURRENT_LIST_DIR}/software-sensor.h"
         "${CMAKE_CURRENT_LIST_DIR}/source.h"
         "${CMAKE_CURRENT_LIST_DIR}/stream.h"
         "${CMAKE_CURRENT_LIST_DIR}/sync.h"

src/archive.cpp

@@ -6,6 +6,8 @@
 #include "core/pose-frame.h"
 #include "core/motion-frame.h"
 #include "core/disparity-frame.h"
+#include "composite-frame.h"
+#include "points.h"
 
 
 namespace librealsense

src/archive.h

@@ -3,14 +3,15 @@
 
 #pragma once
 
-#include "types.h"
-#include "core/streaming.h"
+#include "core/stream-profile.h"
+#include "core/frame-additional-data.h"
 #include "callback-invocation.h"
 
 
 namespace librealsense
 {
-    struct frame_additional_data;
+    class frame_interface;
+    class sensor_interface;
 
     class archive_interface
     {

src/auto-calibrated-device.h

@@ -1,10 +1,11 @@
 // License: Apache 2.0. See LICENSE file in root directory.
 // Copyright(c) 2019 Intel Corporation. All Rights Reserved.
-
 #pragma once
 
 #include "types.h"
-#include "core/streaming.h"
+#include "core/extension.h"
+#include <vector>
+
 
 namespace librealsense
 {

src/backend-device-factory.cpp

@@ -13,6 +13,9 @@
 #include "fw-update/fw-update-factory.h"
 #include "platform-camera.h"
 
+#include <librealsense2/h/rs_context.h>
+
+#include <rsutils/easylogging/easyloggingpp.h>
 #include <rsutils/shared-ptr-singleton.h>
 #include <rsutils/signal.h>
 #include <rsutils/json.h>

src/core/CMakeLists.txt

@@ -2,7 +2,6 @@
 # Copyright(c) 2019 Intel Corporation. All Rights Reserved.
 target_sources(${LRS_TARGET}
     PRIVATE
-        "${CMAKE_CURRENT_LIST_DIR}/streaming.h"
         "${CMAKE_CURRENT_LIST_DIR}/debug.h"
         "${CMAKE_CURRENT_LIST_DIR}/advanced_mode.h"
         "${CMAKE_CURRENT_LIST_DIR}/enum-helpers.h"
@@ -29,7 +28,13 @@ target_sources(${LRS_TARGET}
         "${CMAKE_CURRENT_LIST_DIR}/extension.h"
         "${CMAKE_CURRENT_LIST_DIR}/pose-frame.h"
         "${CMAKE_CURRENT_LIST_DIR}/processing.h"
+        "${CMAKE_CURRENT_LIST_DIR}/processing-block-interface.h"
+        "${CMAKE_CURRENT_LIST_DIR}/recommended-proccesing-blocks-interface.h"
+        "${CMAKE_CURRENT_LIST_DIR}/recommended-proccesing-blocks-base.h"
+        "${CMAKE_CURRENT_LIST_DIR}/sensor-interface.h"
         "${CMAKE_CURRENT_LIST_DIR}/serialization.h"
+        "${CMAKE_CURRENT_LIST_DIR}/stream-interface.h"
         "${CMAKE_CURRENT_LIST_DIR}/stream-profile.h"
+        "${CMAKE_CURRENT_LIST_DIR}/stream-profile-interface.h"
         "${CMAKE_CURRENT_LIST_DIR}/tagged-profile.h"
 )

src/core/advanced_mode.h

@@ -4,10 +4,9 @@
 
 #include "ds/ds-private.h"
 #include "hw-monitor.h"
-#include "streaming.h"
 #include "option.h"
 #include "ds/advanced_mode/presets.h"
-#include "../../include/librealsense2/h/rs_advanced_mode_command.h"
+#include <librealsense2/h/rs_advanced_mode_command.h>
 #include "serializable-interface.h"
 #include <rsutils/lazy.h>
 

src/core/disparity-frame.h

@@ -3,6 +3,8 @@
 #pragma once
 
 #include "depth-frame.h"
+#include "sensor-interface.h"
+#include "depth-sensor.h"
 #include "extension.h"
 
 

src/core/matcher-factory.cpp

@@ -3,6 +3,7 @@
 
 #include "matcher-factory.h"
 #include "frame-holder.h"
+#include "stream-interface.h"
 
 #include <src/sync.h>
 

src/core/motion.h

@@ -2,8 +2,9 @@
 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
 #pragma once
 
+#include "stream-profile-interface.h"
+#include <src/types.h>
 
-#include "streaming.h"
 
 namespace librealsense
 {

src/core/processing-block-interface.h

@@ -0,0 +1,38 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+
+#pragma once
+
+#include "options.h"
+#include "info-interface.h"
+#include <src/types.h>
+
+#include <vector>
+#include <memory>
+
+
+namespace librealsense {
+
+
+class synthetic_source_interface;
+class frame_holder;
+
+
+class processing_block_interface
+    : public virtual options_interface
+    , public virtual info_interface
+{
+public:
+    virtual ~processing_block_interface() = default;
+
+    virtual void set_processing_callback( frame_processor_callback_ptr callback ) = 0;
+    virtual void set_output_callback( frame_callback_ptr callback ) = 0;
+    virtual void invoke( frame_holder frame ) = 0;
+    virtual synthetic_source_interface & get_source() = 0;
+};
+
+
+using processing_blocks = std::vector< std::shared_ptr< processing_block_interface > >;
+
+
+}  // namespace librealsense

src/core/processing.h

@@ -51,17 +51,6 @@ namespace librealsense
         virtual rs2_source* get_c_wrapper() = 0;
     };
 
-    class processing_block_interface : public virtual options_interface, public virtual info_interface
-    {
-    public:
-        virtual void set_processing_callback(frame_processor_callback_ptr callback) = 0;
-        virtual void set_output_callback(frame_callback_ptr callback) = 0;
-        virtual void invoke(frame_holder frame) = 0;
-        virtual synthetic_source_interface& get_source() = 0;
-
-        virtual ~processing_block_interface() = default;
-    };
-
     template<class T>
     class internal_frame_processor_callback : public rs2_frame_processor_callback
     {

src/core/recommended-proccesing-blocks-base.h

@@ -0,0 +1,32 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+#pragma once
+
+#include "recommended-proccesing-blocks-interface.h"
+#include "extension.h"
+
+
+namespace librealsense
+{
+    class recommended_proccesing_blocks_base : public virtual recommended_proccesing_blocks_interface, public virtual recordable<recommended_proccesing_blocks_interface>
+    {
+    public:
+        recommended_proccesing_blocks_base(recommended_proccesing_blocks_interface* owner)
+            :_owner(owner)
+        {}
+
+        virtual processing_blocks get_recommended_processing_blocks() const override { return _owner->get_recommended_processing_blocks(); };
+
+        virtual void create_snapshot(std::shared_ptr<recommended_proccesing_blocks_interface>& snapshot) const override
+        {
+            snapshot = std::make_shared<recommended_proccesing_blocks_snapshot>(get_recommended_processing_blocks());
+        }
+
+        virtual void enable_recording(std::function<void(const recommended_proccesing_blocks_interface&)> recording_function)  override {}
+
+    private:
+        recommended_proccesing_blocks_interface* _owner;
+    };
+
+
+}

src/core/recommended-proccesing-blocks-interface.h

@@ -0,0 +1,45 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+
+#pragma once
+
+#include "processing-block-interface.h"
+#include "extension.h"
+
+#include <functional>
+#include <vector>
+
+
+namespace librealsense {
+
+
+class recommended_proccesing_blocks_interface
+{
+public:
+    virtual ~recommended_proccesing_blocks_interface() = default;
+
+    virtual processing_blocks get_recommended_processing_blocks() const = 0;
+};
+
+MAP_EXTENSION( RS2_EXTENSION_RECOMMENDED_FILTERS, librealsense::recommended_proccesing_blocks_interface );
+
+
+class recommended_proccesing_blocks_snapshot
+    : public recommended_proccesing_blocks_interface
+    , public extension_snapshot
+{
+public:
+    recommended_proccesing_blocks_snapshot( const processing_blocks & blocks )
+        : _blocks( blocks )
+    {
+    }
+
+    virtual processing_blocks get_recommended_processing_blocks() const override { return _blocks; }
+
+    void update( std::shared_ptr< extension_snapshot > ext ) override {}
+
+    processing_blocks _blocks;
+};
+
+
+}  // namespace librealsense

src/core/sensor-interface.h

@@ -0,0 +1,57 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+
+#pragma once
+
+#include "info-interface.h"
+#include "options.h"
+#include "recommended-proccesing-blocks-interface.h"
+
+#include "tagged-profile.h"
+
+#include <vector>
+#include <memory>
+
+
+namespace librealsense {
+
+
+class stream_profile_interface;
+class device_interface;
+
+
+class sensor_interface
+    : public virtual info_interface
+    , public virtual options_interface
+    , public virtual recommended_proccesing_blocks_interface
+{
+public:
+    virtual ~sensor_interface() = default;
+
+    virtual device_interface & get_device() = 0;
+
+    using stream_profiles = std::vector< std::shared_ptr< stream_profile_interface > >;
+
+    virtual stream_profiles get_stream_profiles( int tag = profile_tag::PROFILE_TAG_ANY ) const = 0;
+    virtual stream_profiles get_active_streams() const = 0;
+    virtual stream_profiles const & get_raw_stream_profiles() const = 0;
+
+    virtual void open( const stream_profiles & requests ) = 0;
+    virtual void start( frame_callback_ptr callback ) = 0;
+    virtual void stop() = 0;
+    virtual void close() = 0;
+
+    virtual bool is_streaming() const = 0;
+
+    virtual notifications_callback_ptr get_notifications_callback() const = 0;
+    virtual void register_notifications_callback( notifications_callback_ptr callback ) = 0;
+
+    virtual int register_before_streaming_changes_callback( std::function< void( bool ) > callback ) = 0;
+    virtual void unregister_before_start_callback( int token ) = 0;
+
+    virtual frame_callback_ptr get_frames_callback() const = 0;
+    virtual void set_frames_callback( frame_callback_ptr cb ) = 0;
+};
+
+
+}  // namespace librealsense

src/core/serialization.h

@@ -8,12 +8,14 @@
 #include <vector>
 #include "../types.h"
 #include "extension.h"
-#include "streaming.h"
 #include "frame-holder.h"
+#include "stream-profile-interface.h"
 
 
 namespace librealsense
 {
+    class option;
+
     namespace device_serializer
     {
         struct sensor_identifier

src/core/stream-interface.h

@@ -0,0 +1,33 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+#pragma once
+
+#include <librealsense2/h/rs_sensor.h>
+#include <memory>
+#include <vector>
+
+
+namespace librealsense {
+
+
+class stream_interface : public std::enable_shared_from_this< stream_interface >
+{
+public:
+    virtual ~stream_interface() = default;
+
+    virtual int get_stream_index() const = 0;
+    virtual void set_stream_index( int index ) = 0;
+
+    virtual int get_unique_id() const = 0;
+    virtual void set_unique_id( int uid ) = 0;
+
+    virtual rs2_stream get_stream_type() const = 0;
+    virtual void set_stream_type( rs2_stream stream ) = 0;
+};
+
+
+// TODO this should be find_stream
+stream_interface * find_profile( rs2_stream stream, int index, std::vector< stream_interface * > const & profiles );
+
+
+}  // namespace librealsense