Update viewer panel and mock example to the new composite-option API surface

- realsense-viewer's HKR Temporal Filter DPP panel now goes through
  sub->s->option_ref(RS2_OPTION_HKR_TEMPORAL_FILTER_DPP).is/as<rs2::composite_option>()
  instead of the removed rs2::composite_option_sensor, and casts to/from the now-
  public rs2_temporal_filter_dpp_config struct instead of a viewer-local copy of it.
- The standalone mock example no longer bypasses into an internal transport class
  (xu_structured_control) directly - it now drives the mechanism through the real
  public entry points: rs2_set_composite_option/rs2_get_composite_option (C) and
  option_ref()/is<rs2::composite_option>()/as<rs2::composite_option>() (C++), backed
  by a minimal fake librealsense::option + composite_option_interface +
  options_interface standing in for a real device. Round-trip correctness and
  exactly-one-set+one-get atomicity are asserted across both API paths. Since it now
  needs the real public API/DLL entry points, it links against realsense2 like any
  other example instead of compiling an isolated internal source file directly.

Author: Evgeni Raikhel

common/device-model.cpp

@@ -29,25 +29,6 @@ using namespace rs400;
 using rsutils::json;
 using namespace rs2::sw_update;
 
-namespace {
-
-// PROTOTYPE / DEMO: this viewer's OWN local struct matching the wire layout documented as a
-// comment on RS2_COMPOSITE_OPTION_HKR_TEMPORAL_FILTER_DPP in
-// include/librealsense2/h/rs_composite_option.h. The SDK ships no public type for composite
-// options - every caller (this viewer, the mock example under examples/) independently
-// defines its own copy of this struct matching the documented byte layout.
-#pragma pack( push, 1 )
-struct hkr_temporal_filter_dpp_layout
-{
-    int32_t enabled;           // 0 = Off, 1 = On
-    float smooth_alpha;        // range [0,1], default 0.4, step 0.01
-    int32_t smooth_delta;      // range [1,100], default 20, step 1
-    int32_t persistency_index; // range [0,8], default 3, step 1
-};
-#pragma pack( pop )
-
-}  // namespace
-
 namespace rs2
 {
     // RAII guard pairing BeginDisabled/EndDisabled: keeps them balanced even if an exception is
@@ -2791,19 +2772,20 @@ namespace rs2
                 }
 
                 // PROTOTYPE / DEMO: HKR Temporal Filter DPP "structured API" panel. Only
-                // rendered for a sensor that actually exposes composite options (gated the
-                // same way as other per-sensor extension features in this loop, e.g.
-                // depth_sensor above). Goes through the GENERIC rs2::composite_option_sensor
-                // get_composite_option/set_composite_option entry points, keyed by
-                // RS2_COMPOSITE_OPTION_HKR_TEMPORAL_FILTER_DPP. The SDK ships no struct for
-                // this - this viewer casts the raw bytes to/from its own local
-                // hkr_temporal_filter_dpp_layout (defined above), matching the layout
-                // documented as a comment on the enumerator. All fields are sent together in
-                // ONE atomic UVC transaction when "Apply" is clicked - never as separate
-                // per-field option writes.
-                if (sub->s->is<rs2::composite_option_sensor>())
-                {
-                    auto composite_sensor = sub->s->as<rs2::composite_option_sensor>();
+                // rendered for a sensor that actually exposes RS2_OPTION_HKR_TEMPORAL_FILTER_DPP
+                // as a composite option. Goes through the GENERIC option_ref()/is<T>()/as<T>()
+                // C++ path (mirrors rs2::frame's is<T>()/as<T>() dispatch) to obtain an
+                // rs2::composite_option, then its get()/set() - which call
+                // rs2_get_composite_option/rs2_set_composite_option under the hood. The SDK
+                // ships a public struct for this one prototype control
+                // (rs2_temporal_filter_dpp_config, see rs_hkr_temporal_filter_dpp.h) that this
+                // viewer casts the raw bytes to/from. All fields are sent together in ONE atomic
+                // UVC transaction when "Apply" is clicked - never as separate per-field option
+                // writes.
+                auto temporal_filter_dpp_handle = sub->s->option_ref(RS2_OPTION_HKR_TEMPORAL_FILTER_DPP);
+                if (temporal_filter_dpp_handle.is<rs2::composite_option>())
+                {
+                    auto composite_opt = temporal_filter_dpp_handle.as<rs2::composite_option>();
 
                     label = rsutils::string::from() << "HKR Temporal Filter DPP (prototype)##" << id;
                     if (ImGui::TreeNode(label.c_str()))
@@ -2812,11 +2794,11 @@ namespace rs2
                         {
                             if (!sub->temporal_filter_dpp_populated)
                             {
-                                auto bytes = composite_sensor.get_composite_option(RS2_COMPOSITE_OPTION_HKR_TEMPORAL_FILTER_DPP);
-                                if (bytes.size() != sizeof(hkr_temporal_filter_dpp_layout))
+                                auto bytes = composite_opt.get();
+                                if (bytes.size() != sizeof(rs2_temporal_filter_dpp_config))
                                     throw std::runtime_error("HKR Temporal Filter DPP: unexpected payload size from get_composite_option");
 
-                                hkr_temporal_filter_dpp_layout cfg{};
+                                rs2_temporal_filter_dpp_config cfg{};
                                 memcpy(&cfg, bytes.data(), sizeof(cfg));
                                 sub->temporal_filter_dpp_enabled = cfg.enabled;
                                 sub->temporal_filter_dpp_smooth_alpha = cfg.smooth_alpha;
@@ -2842,12 +2824,12 @@ namespace rs2
                             label = rsutils::string::from() << "Send##temporal_filter_dpp_send" << id;
                             if (ImGui::Button(label.c_str()))
                             {
-                                hkr_temporal_filter_dpp_layout cfg{};
+                                rs2_temporal_filter_dpp_config cfg{};
                                 cfg.enabled = sub->temporal_filter_dpp_enabled;
                                 cfg.smooth_alpha = sub->temporal_filter_dpp_smooth_alpha;
                                 cfg.smooth_delta = sub->temporal_filter_dpp_smooth_delta;
                                 cfg.persistency_index = sub->temporal_filter_dpp_persistency_index;
-                                composite_sensor.set_composite_option(RS2_COMPOSITE_OPTION_HKR_TEMPORAL_FILTER_DPP, &cfg, sizeof(cfg));
+                                composite_opt.set(&cfg, sizeof(cfg));
                             }
                         }
                         catch (const error& e)

common/subdevice-model.h

@@ -230,9 +230,10 @@ namespace rs2
         bool embedded_filters_enabled = true;
 
         // PROTOTYPE / DEMO: UI state for the HKR Temporal Filter DPP "structured API" panel
-        // (gated on sub->s->is<rs2::composite_option_sensor>() - see device-model.cpp).
-        // Widget values only change locally until "Apply" is pressed; that single click issues
-        // one set_composite_option() call, i.e. one atomic UVC transaction.
+        // (gated on sub->s->option_ref(RS2_OPTION_HKR_TEMPORAL_FILTER_DPP).is<rs2::composite_option>()
+        // - see device-model.cpp). Widget values only change locally until "Apply" is pressed;
+        // that single click issues one composite_option::set() call, i.e. one atomic UVC
+        // transaction.
         bool temporal_filter_dpp_populated = false;
         int temporal_filter_dpp_enabled = 0;
         float temporal_filter_dpp_smooth_alpha = 0.4f;

examples/hkr-temporal-filter-dpp-mock/CMakeLists.txt

@@ -5,19 +5,18 @@ cmake_minimum_required(VERSION 3.10)
 project(RealsenseExamplesHkrTemporalFilterDppMock)
 
 # PROTOTYPE / DEMO test scaffolding: proves the atomicity + round-trip behavior of the generic
-# "composite option" mechanism (src/ds/structured-xu-control.*) as applied to the HKR Temporal
-# Filter DPP control, against a fake in-memory platform::uvc_device standing in for real
-# HKR/D555 hardware, which is not present on this dev machine. This executable deliberately
-# does NOT link against the realsense2 library/DLL: the control class under test is
-# transport-agnostic (it only needs a platform::uvc_device&), so it can be exercised directly
-# without a live backend/uvc_sensor stack. It compiles the real production source file
-# directly so it is testing actual SDK code, not a reimplementation.
+# "composite option" mechanism (include/librealsense2/h/rs_composite_option.h,
+# src/composite-option-interface.h) as applied to RS2_OPTION_HKR_TEMPORAL_FILTER_DPP, against a
+# fake in-memory librealsense::option/composite_option_interface implementation standing in for
+# real HKR/D555 hardware (librealsense::composite_xu_option, src/ds/composite-xu-option.h), which
+# is not present on this dev machine. Unlike the earlier iteration, this drives the mechanism
+# through the REAL PUBLIC ENTRY POINTS (rs2_set_composite_option/rs2_get_composite_option and the
+# option_ref()/is<T>()/as<T>() C++ path) rather than bypassing into an internal transport class
+# directly, so it links against realsense2 like any other example.
 add_executable(rs-hkr-temporal-filter-dpp-mock
     rs-hkr-temporal-filter-dpp-mock.cpp
-    ${CMAKE_SOURCE_DIR}/src/ds/structured-xu-control.cpp
 )
 set_property(TARGET rs-hkr-temporal-filter-dpp-mock PROPERTY CXX_STANDARD 14)
-target_include_directories(rs-hkr-temporal-filter-dpp-mock PRIVATE ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(rs-hkr-temporal-filter-dpp-mock PRIVATE rsutils)
+target_link_libraries(rs-hkr-temporal-filter-dpp-mock PRIVATE ${LRS_TARGET})
 set_target_properties (rs-hkr-temporal-filter-dpp-mock PROPERTIES FOLDER Examples)
 install(TARGETS rs-hkr-temporal-filter-dpp-mock RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})