Can update options automatically, get notification of value change

src/CMakeLists.txt

@@ -175,6 +175,8 @@ target_sources(${LRS_TARGET}
         "${CMAKE_CURRENT_LIST_DIR}/small-heap.h"
         "${CMAKE_CURRENT_LIST_DIR}/basics.h"
         "${CMAKE_CURRENT_LIST_DIR}/feature-interface.h"
+        "${CMAKE_CURRENT_LIST_DIR}/syntethic-options-watcher.h"
+        "${CMAKE_CURRENT_LIST_DIR}/syntethic-options-watcher.cpp"
 )
 
 if(BUILD_WITH_DDS)

src/core/options-watcher.cpp

@@ -18,8 +18,10 @@ options_watcher::~options_watcher()
 {
     try
     {
-        std::lock_guard< std::mutex > lock( _mutex );
-        _options.clear();
+        {
+            std::lock_guard< std::mutex > lock( _mutex );
+            _options.clear();
+        }
         stop();
     }
     catch( ... )
@@ -76,17 +78,16 @@ void options_watcher::start()
 {
     if( ! _updater.joinable() ) // If not already started
     {
-        if( _should_query_for_first_time )
-        {
+        _updater = std::thread( [this]() {
             update_options();
-            _should_query_for_first_time = false;
-        }
-        _updater = std::thread( [this]() { thread_loop(); } );
+            thread_loop();
+        } );
     }
 }
 
 void options_watcher::stop()
 {
+    _stopping.notify_all();
     if( _updater.joinable() )
         _updater.join();
 }
@@ -108,7 +109,8 @@ void options_watcher::thread_loop()
         if(  should_stop() )
             break;
 
-        std::this_thread::sleep_for( _update_interval );
+        std::unique_lock< std::mutex > lock( _mutex );
+        _stopping.wait_for( lock, _update_interval );
     }
 }
 
@@ -118,6 +120,9 @@ std::map< rs2_option, std::shared_ptr< option > > options_watcher::update_option
 
     std::lock_guard< std::mutex > lock( _mutex );
 
+    if( should_stop() )
+        return updated_options;
+
     for( auto & opt : _options )
     {
         try

src/core/options-watcher.h

@@ -58,7 +58,7 @@ class options_watcher
     std::chrono::milliseconds _update_interval;
     std::thread _updater;
     std::mutex _mutex;
-    bool _should_query_for_first_time = true;
+    std::condition_variable _stopping;
 };
 
 

src/sensor.cpp

@@ -399,6 +399,7 @@ void log_callback_end( uint32_t fps,
                                         const std::map< uint32_t, rs2_stream > & fourcc_to_rs2_stream_map )
         : sensor_base( name, device )
         , _raw_sensor( raw_sensor )
+        , _options_watcher( _raw_sensor )
     {
         nlohmann::json const & settings = device->get_context()->get_settings();
         if( auto interval_j = rsutils::json::nested( settings, std::string( "options-update-interval", 23 ) ) )

src/sensor.h

@@ -7,7 +7,7 @@
 #include "source.h"
 #include "core/extension.h"
 #include "proc/formats-converter.h"
-#include <src/core/options-watcher.h>
+#include <src/syntethic-options-watcher.h>
 
 #include <rsutils/lazy.h>
 #include <rsutils/signal.h>
@@ -193,6 +193,11 @@ namespace librealsense
 
         std::shared_ptr< std::map< uint32_t, rs2_format > > & get_fourcc_to_rs2_format_map();
         std::shared_ptr< std::map< uint32_t, rs2_stream > > & get_fourcc_to_rs2_stream_map();
+
+        // Sometimes it is more efficient to prepare for large or repeating operations. Depending on the actual sensor
+        // type we might want to change power state or encapsulate small transactions into a large one.
+        virtual void prepare_for_bulk_operation() {};
+        virtual void finished_bulk_operation(){};
     };
 
     // A sensor pointer to another "raw sensor", usually UVC/HID
@@ -257,7 +262,7 @@ namespace librealsense
         formats_converter _formats_converter;
         std::vector<rs2_option> _cached_processing_blocks_options;
 
-        options_watcher _options_watcher;
+        syntethic_options_watcher _options_watcher;
     };
 
 

src/syntethic-options-watcher.cpp

@@ -0,0 +1,32 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+
+
+#include <src/syntethic-options-watcher.h>
+#include <src/sensor.h>
+
+
+namespace librealsense {
+
+
+syntethic_options_watcher::syntethic_options_watcher( const std::shared_ptr< raw_sensor_base > & raw_sensor )
+    : _raw_sensor( raw_sensor )
+{
+}
+
+std::map< rs2_option, std::shared_ptr< option > > syntethic_options_watcher::update_options()
+{
+    std::map< rs2_option, std::shared_ptr< option > > updated_options;
+
+    std::shared_ptr< raw_sensor_base > strong = _raw_sensor.lock();
+    if( ! strong )
+        return updated_options;
+
+    strong->prepare_for_bulk_operation();
+    updated_options = options_watcher::update_options();
+    strong->finished_bulk_operation();
+
+    return updated_options;
+}
+
+}  // namespace librealsense

src/syntethic-options-watcher.h

@@ -0,0 +1,26 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+#pragma once
+
+
+#include <src/core/options-watcher.h>
+
+
+namespace librealsense {
+
+class raw_sensor_base;
+
+// Used by syntethic sensor and uses the raw_sensor bulk operations.
+class syntethic_options_watcher : public options_watcher
+{
+public:
+    syntethic_options_watcher( const std::shared_ptr< raw_sensor_base > & raw_sensor );
+
+protected:
+    std::map< rs2_option, std::shared_ptr< option > > update_options() override;
+
+    std::weak_ptr< raw_sensor_base > _raw_sensor;
+};
+
+
+}  // namespace librealsense

src/uvc-sensor.cpp

@@ -343,6 +343,16 @@ void uvc_sensor::register_pu( rs2_option id )
 }
 
 
+void uvc_sensor::prepare_for_bulk_operation()
+{
+    acquire_power();
+}
+
+void uvc_sensor::finished_bulk_operation()
+{
+    release_power();
+}
+
 void uvc_sensor::register_xu( platform::extension_unit xu )
 {
     _xus.push_back( std::move( xu ) );

src/uvc-sensor.h

@@ -28,6 +28,9 @@ class uvc_sensor : public raw_sensor_base
     void register_xu( platform::extension_unit xu );
     void register_pu( rs2_option id );
 
+    virtual void prepare_for_bulk_operation() override;
+    virtual void finished_bulk_operation() override;
+
     std::vector< platform::stream_profile > get_configuration() const { return _internal_config; }
     std::shared_ptr< platform::uvc_device > get_uvc_device() { return _device; }
     platform::usb_spec get_usb_specification() const { return _device->get_usb_specification(); }