update OrbbecSDK version to 2.9.2

orbbec_camera/SDK/include/libobsensor/hpp/ApplicationConfig.hpp

@@ -184,6 +184,20 @@ public:
         return std::make_shared<ApplicationConfig>(handle);
     }
 
+    /**
+     * @brief Get the application config carried by an externally imported preset, by preset name.
+     * @return nullptr for built-in presets or presets that carry no application config.
+     */
+    static std::shared_ptr<ApplicationConfig> get(const std::shared_ptr<Device> &device, const std::string &presetName) {
+        ob_error *error  = nullptr;
+        auto      handle = ob_device_get_application_config_by_preset(device->getImpl(), presetName.c_str(), &error);
+        Error::handle(&error);
+        if(!handle) {
+            return nullptr;
+        }
+        return std::make_shared<ApplicationConfig>(handle);
+    }
+
     explicit ApplicationConfig(ob_application_config *handle) : handle_(handle) {}
 
     ~ApplicationConfig() noexcept {

orbbec_camera/SDK/include/libobsensor/hpp/Device.hpp

@@ -302,6 +302,51 @@ public:
         Error::handle(&error);
     }
 
+    /**
+     * @brief Check whether the device supports license authorization.
+     *
+     * @return true if the device supports license authorization, false otherwise.
+     */
+    bool isLicenseAuthorizationSupported() const {
+        ob_error *error = nullptr;
+        auto      res   = ob_device_is_license_authorization_supported(impl_, &error);
+        Error::handle(&error);
+        return res;
+    }
+
+    /**
+     * @brief Write signed device license information.
+     *
+     * @param[in] licenseInfo SDK license_info JSON string
+     */
+    void writeLicenseInfo(const std::string &licenseInfo) const {
+        ob_error *error = nullptr;
+        ob_device_write_license_info(impl_, licenseInfo.c_str(), static_cast<uint32_t>(licenseInfo.size()), &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Clear license information stored on the device.
+     */
+    void clearLicenseInfo() const {
+        ob_error *error = nullptr;
+        ob_device_clear_license_info(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Read signed device license information as SDK license_info JSON.
+     *
+     * @return std::string SDK license_info JSON string
+     */
+    std::string readLicenseInfo() const {
+        ob_error *error     = nullptr;
+        char      buf[4096] = {};
+        ob_device_read_license_info(impl_, buf, sizeof(buf), &error);
+        Error::handle(&error);
+        return std::string(buf);
+    }
+
     /**
      * @brief Set the customer data type of a device property
      *
@@ -393,6 +438,8 @@ public:
     /**
      * @brief Update the device firmware
      *
+     * @attention Only one firmware/preset update may run per device at a time
+     *
      * @param[in] filePath Firmware path
      * @param[in] callback Firmware Update progress and status callback
      * @param[in] async Whether to execute asynchronously
@@ -407,6 +454,8 @@ public:
     /**
      * @brief Update the device firmware from data
      *
+     * @attention Only one firmware/preset update may run per device at a time
+     *
      * @param[in] firmwareData Firmware data
      * @param[in] firmwareDataSize Firmware data size
      * @param[in] callback Firmware Update progress and status callback
@@ -422,6 +471,8 @@ public:
     /**
      * @brief Update the device optional depth presets
      *
+     * @attention Only one firmware/preset update may run per device at a time
+     *
      * @param[in] filePathList A list(2D array) of preset file paths, each up to OB_PATH_MAX characters.
      * @param[in] pathCount The number of the preset file paths.
      * @param[in] callback Preset update progress and status callback
@@ -433,6 +484,27 @@ public:
         Error::handle(&error);
     }
 
+    /**
+     * @brief Update the device optional depth presets from data loaded in memory
+     *
+     * @attention Only one firmware/preset update may run per device at a time
+     *
+     * @param[in] dataList A list of preset data blocks, each holding the raw bytes of one preset.
+     * @param[in] callback Preset update progress and status callback
+     */
+    void updateOptionalDepthPresets(const std::vector<std::vector<uint8_t>> &dataList, DeviceFwUpdateCallback callback) {
+        ob_error                      *error = nullptr;
+        std::vector<OBDataView> presets;
+        presets.reserve(dataList.size());
+        for(const auto &data: dataList) {
+            presets.push_back({data.data(), static_cast<uint32_t>(data.size())});
+        }
+        fwUpdateCallback_ = callback;
+        auto count        = static_cast<uint8_t>(presets.size());
+        ob_device_update_optional_depth_presets_from_data(impl_, presets.data(), count, &Device::firmwareUpdateCallback, this, &error);
+        Error::handle(&error);
+    }
+
     /**
      * @brief Set the device state changed callbacks
      *
@@ -620,6 +692,18 @@ public:
         Error::handle(&error);
     }
 
+    /**
+     * @brief Check whether the device firmware log is enabled.
+     *
+     * @return bool Whether the firmware log is enabled.
+     */
+    bool isFirmwareLogEnabled() const {
+        ob_error *error  = nullptr;
+        bool      enable = ob_device_is_firmware_log_enabled(impl_, &error);
+        Error::handle(&error);
+        return enable;
+    }
+
     /**
      * @brief Get the supported multi device sync mode bitmap of the device.
      * @brief For example, if the return value is 0b00001100, it means the device supports @ref OB_MULTI_DEVICE_SYNC_MODE_PRIMARY and @ref
@@ -1449,9 +1533,9 @@ public:
      *
      * @return const char* The host network interface name (e.g., "eth0", "en0").
      */
-    const char* getLocalNetInterfaceName(uint32_t index) const {
-        ob_error *error = nullptr;
-        auto netItfName = ob_device_list_get_device_local_net_if_name(impl_, index, &error);
+    const char *getLocalNetInterfaceName(uint32_t index) const {
+        ob_error *error      = nullptr;
+        auto      netItfName = ob_device_list_get_device_local_net_if_name(impl_, index, &error);
         Error::handle(&error);
         return netItfName;
     }
@@ -1488,6 +1572,49 @@ public:
         return userName;
     }
 
+    /**
+     * @brief Query the current device access state without opening the device.
+     *
+     * @attention This is a non-invasive GVCP CCP query for supported Ethernet devices. It reports device-side CCP state, not the owner process or host.
+     * CONTROLLED means monitor access may still be available, while default/control access may still fail.
+     * This call is synchronous and blocks while waiting for the device's GVCP response over the network; querying an unreachable device blocks until the
+     * underlying retry logic gives up, so prefer calling it off the UI thread when querying multiple devices.
+     * The returned state reflects the device access state only at the moment of the query and does not guarantee that a subsequent access (such as creating
+     * or opening the device) will succeed, as another client may change the state in between.
+     *
+     * @param[in] index The index of the device.
+     *
+     * @return OBDeviceAccessState The current access state of the device.
+     */
+    OBDeviceAccessState queryDeviceAccessState(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      state = ob_device_list_query_device_access_state(impl_, index, &error);
+        Error::handle(&error);
+        return state;
+    }
+
+    /**
+     * @brief Query the current device access state by serial number without opening the device.
+     *
+     * @attention This is a non-invasive GVCP CCP query for supported Ethernet devices. It reports device-side CCP state, not the owner process or host.
+     * CONTROLLED means monitor access may still be available, while default/control access may still fail.
+     * This call is synchronous and blocks while waiting for the device's GVCP response over the network; querying an unreachable device blocks until the
+     * underlying retry logic gives up, so prefer calling it off the UI thread when querying multiple devices.
+     * The returned state reflects the device access state only at the moment of the query and does not guarantee that a subsequent access (such as creating
+     * or opening the device) will succeed, as another client may change the state in between.
+     * If no device in the list matches the given serial number, this throws an ob::Error.
+     *
+     * @param[in] serialNumber The serial number of the device.
+     *
+     * @return OBDeviceAccessState The current access state of the device.
+     */
+    OBDeviceAccessState queryDeviceAccessStateBySN(const char *serialNumber) const {
+        ob_error *error = nullptr;
+        auto      state = ob_device_list_query_device_access_state_by_serial_number(impl_, serialNumber, &error);
+        Error::handle(&error);
+        return state;
+    }
+
     /**
      * @brief Get the device object at the specified index
      *

orbbec_camera/SDK/include/libobsensor/hpp/Filter.hpp

@@ -22,6 +22,7 @@
 #include <typeinfo>
 #include <typeindex>
 #include <unordered_map>
+#include <vector>
 #include <cstring>
 
 namespace ob {
@@ -2081,6 +2082,175 @@ public:
     ~DisparityTransform() noexcept override = default;
 };
 
+/**
+ * @brief Enhanced depth filter that requires a device for activation.
+ *
+ * @note The constructor is a template so that Filter.hpp does not need to include Device.hpp.
+ *       The template is instantiated at the call site where the device type is complete.
+ */
+class EnhancedDepthFilter : public Filter {
+public:
+    /**
+     * @brief Construct an EnhancedDepthFilter and activate it for the given device.
+     *
+     * @param[in] device The device the filter is bound to.
+     * @param[in] modelPath Optional path to the inference model file used during activation. When empty, the
+     *            filter falls back to its default model file at extensions/filters/enhanced_depth_filter/model.sm4
+     *            (located next to the filter library).
+     */
+    template <typename T> explicit EnhancedDepthFilter(std::shared_ptr<T> device, const std::string &modelPath = "") {
+        if(!device) {
+            throw std::invalid_argument("device is null");
+        }
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter("EnhancedDepthFilter", "", &error);
+        Error::handle(&error);
+
+        // Only pass options when a model path is provided; otherwise hand down nullptr so the filter uses its default.
+        ob_priv_filter_activate_options  options{};
+        ob_priv_filter_activate_options *optionsPtr = nullptr;
+        if(!modelPath.empty()) {
+            options.struct_size = sizeof(options);
+            options.model_path  = modelPath.c_str();
+            optionsPtr          = &options;
+        }
+        ob_filter_activate_private_ex(impl, device->getImpl(), optionsPtr, &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    ~EnhancedDepthFilter() noexcept override = default;
+
+    /**
+     * @brief Get the resolutions supported by the enhanced depth filter for the constrained (aligned-to) stream.
+     *
+     * @return The list of supported {width, height} pairs. This is the single source of truth used by
+     *         @ref isSupportedResolution.
+     */
+    static const std::vector<std::pair<uint32_t, uint32_t>> &getSupportedResolutions() {
+        static const std::vector<std::pair<uint32_t, uint32_t>> supportedResolutions = {
+            { 640, 480 },
+            { 1280, 720 },
+            { 1280, 800 },
+        };
+        return supportedResolutions;
+    }
+
+    /**
+     * @brief Get the frame formats supported by the enhanced depth filter for a given stream type.
+     *
+     * @param[in] streamType The stream type. Only color and depth streams are supported.
+     *
+     * @return The list of supported formats (color: OB_FORMAT_RGB; depth: OB_FORMAT_Y10, OB_FORMAT_Y11,
+     *         OB_FORMAT_Y12, OB_FORMAT_Y14, OB_FORMAT_Y16, OB_FORMAT_Z16). Empty for unsupported stream types. This is the single
+     *         source of truth used by @ref isSupportedFormat.
+     */
+    static std::vector<OBFormat> getSupportedFormats(OBStreamType streamType) {
+        if(streamType == OB_STREAM_COLOR) {
+            return { OB_FORMAT_RGB };
+        }
+        if(streamType == OB_STREAM_DEPTH) {
+            return { OB_FORMAT_Y10, OB_FORMAT_Y11, OB_FORMAT_Y12, OB_FORMAT_Y14, OB_FORMAT_Y16, OB_FORMAT_Z16 };
+        }
+        return {};
+    }
+
+    /**
+     * @brief Check whether a resolution is supported by the enhanced depth filter for a given stream alignment pair.
+     *
+     * @param[in] sourceStreamType The source stream type that provides the input frames.
+     * @param[in] alignToStreamType The target stream type that the source stream is aligned to.
+     * @param[in] width The frame width to validate.
+     * @param[in] height The frame height to validate.
+     *
+     * @return true if the resolution is supported for the specified alignment combination, otherwise false.
+     */
+    static bool isSupportedResolution(OBStreamType sourceStreamType, OBStreamType alignToStreamType, uint32_t width, uint32_t height) {
+        if(sourceStreamType != alignToStreamType) {
+            // If the source and target stream types are different, any resolution is supported.
+            return true;
+        }
+
+        for(const auto &res: getSupportedResolutions()) {
+            if(res.first == width && res.second == height) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @brief Check whether a frame format is supported by the enhanced depth filter for a given stream type.
+     *
+     * @param[in] streamType The stream type to validate. Only color and depth streams are supported.
+     * @param[in] format The frame format to validate.
+     *
+     * @return true if the format is supported for the given stream type, otherwise false.
+     */
+    static bool isSupportedFormat(OBStreamType streamType, OBFormat format) {
+        for(const auto &supported: getSupportedFormats(streamType)) {
+            if(supported == format) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @brief Set the working resolution of the enhanced depth filter.
+     *
+     * @param[in] width The target frame width.
+     * @param[in] height The target frame height.
+     */
+    void setResolution(uint32_t width, uint32_t height) {
+        setConfigValue("width", static_cast<double>(width));
+        setConfigValue("height", static_cast<double>(height));
+    }
+
+    /**
+     * @brief Get the current configured frame width.
+     *
+     * @return uint32_t The current width.
+     */
+    uint32_t getCurrentWidth() const {
+        return static_cast<uint32_t>(getConfigValue("width"));
+    }
+
+    /**
+     * @brief Get the current configured frame height.
+     *
+     * @return uint32_t The current height.
+     */
+    uint32_t getCurrentHeight() const {
+        return static_cast<uint32_t>(getConfigValue("height"));
+    }
+
+    /**
+     * @brief Set the confidence threshold for depth values.
+     *
+     * @param value The confidence threshold.
+     */
+    void setConfidenceThreshold(uint32_t value) {
+        setConfigValue("confidence_threshold", static_cast<double>(value));
+    }
+
+    /**
+     * @brief Get the property range of the confidence threshold range.
+     */
+    OBIntPropertyRange getConfidenceThresholdRange() {
+        OBIntPropertyRange range{};
+        const auto        &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            const char *name = "confidence_threshold";
+            if(std::strcmp(item.name, name) == 0) {
+                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue(name));
+                break;
+            }
+        }
+        return range;
+    }
+};
+
 class OBFilterList {
 private:
     ob_filter_list_t *impl_;
@@ -2151,6 +2321,7 @@ inline const std::unordered_map<std::string, std::type_index> &getFilterTypeMap(
         { "MgcNoiseRemovalFilter", typeid(MgcNoiseRemovalFilter) },
         { "LutNoiseRemovalFilter", typeid(LutNoiseRemovalFilter) },
         { "UnDistortionFilter", typeid(UnDistortionFilter) },
+        { "EnhancedDepthFilter", typeid(EnhancedDepthFilter) },
     };
     return filterTypeMap;
 }

orbbec_camera/SDK/include/libobsensor/hpp/Frame.hpp

@@ -123,6 +123,32 @@ public:
         return index;
     }
 
+    /**
+     * @brief Get the auth token carried by the frame.
+     *
+     * @return uint64_t The auth token value.
+     */
+    uint64_t getToken() const {
+        ob_error *error = nullptr;
+        auto      token = ob_frame_get_token(impl_, &error);
+        Error::handle(&error);
+
+        return token;
+    }
+
+    /**
+     * @brief Set the auth token carried by the frame.
+     *
+     * @param token The auth token value.
+     */
+    void setToken(uint64_t token) {
+        ob_error *error       = nullptr;
+        auto      unConstImpl = const_cast<ob_frame *>(impl_);
+
+        ob_frame_set_token(unConstImpl, token, &error);
+        Error::handle(&error);
+    }
+
     /**
      * @brief Get frame data
      *

orbbec_camera/SDK/include/libobsensor/hpp/RecordPlayback.hpp

@@ -70,10 +70,19 @@ public:
 
 class PlaybackDevice : public Device {
 public:
-    explicit PlaybackDevice(const std::string &file) : Device(nullptr) {
+    /**
+     * @brief Constructs a PlaybackDevice for playing back recorded device data.
+     * @param[in] file Path to the playback file.
+     * @param[in] presetPath Path to a preset JSON file to load after device creation. If empty, no preset is loaded.
+     */
+    explicit PlaybackDevice(const std::string &file, const std::string &presetPath = "") : Device(nullptr) {
         ob_error *error = nullptr;
         impl_           = ob_create_playback_device(file.c_str(), &error);
         Error::handle(&error);
+
+        if(!presetPath.empty()) {
+            loadPresetFromJsonFile(presetPath.c_str());
+        }
     }
 
     virtual ~PlaybackDevice() noexcept override = default;