fix(quality): address Sonar findings

Signed-off-by: burnrazor <128198300+Dragon-kanji@users.noreply.github.com>

Author: Dragon-kanji

src/adaptive_bitrate.cpp

@@ -190,6 +190,153 @@ namespace stream::adaptive_bitrate {
       unrecovered_loss,
     };
 
+    /**
+     * @brief Timing and direction retained across encoder decisions.
+     */
+    struct decision_history_t {
+      decision_direction_e direction = decision_direction_e::none;  ///< Latest non-probe command direction.
+      std::optional<time_point_t> last_decision_at;  ///< Time of the last emitted encoder command.
+      std::optional<time_point_t> last_increase_at;  ///< Time of the last recovery increase.
+      std::optional<time_point_t> last_direction_reversal_at;  ///< Latest non-probe command direction reversal.
+    };
+
+    /**
+     * @brief Handle malformed or protocol-mismatched telemetry.
+     *
+     * @param snapshot Telemetry snapshot to inspect.
+     * @return `true` when the snapshot was handled and observation must stop.
+     */
+    bool handle_invalid_telemetry(const network_metrics::snapshot_t &snapshot);
+
+    /**
+     * @brief Hold adaptation after telemetry report limiting.
+     *
+     * @param snapshot Telemetry snapshot to inspect.
+     * @return `true` when rate limiting was observed and observation must stop.
+     */
+    bool handle_rate_limited_telemetry(const network_metrics::snapshot_t &snapshot);
+
+    /**
+     * @brief Record whether a snapshot carries actionable loss telemetry.
+     *
+     * @param snapshot Telemetry snapshot to inspect.
+     * @return `true` when the snapshot can update controller evidence.
+     */
+    bool accept_telemetry_signal(const network_metrics::snapshot_t &snapshot);
+
+    /**
+     * @brief Classify the strongest degradation present in one telemetry window.
+     *
+     * @param snapshot Telemetry snapshot to classify.
+     * @param unrecovered_ratio Ratio of unrecovered data shards.
+     * @param recovered_ratio Ratio of FEC-recovered data shards.
+     * @param high_latency Whether latency corroborates recovery pressure.
+     * @return Classified degradation, or `none` for a healthy window.
+     */
+    static degradation_e classify_degradation(
+      const network_metrics::snapshot_t &snapshot,
+      long double unrecovered_ratio,
+      long double recovered_ratio,
+      bool high_latency
+    );
+
+    /**
+     * @brief Accumulate one degraded telemetry window.
+     *
+     * @param degradation Degradation observed in the window.
+     * @param now Monotonic observation time.
+     */
+    void observe_degradation(degradation_e degradation, time_point_t now);
+
+    /**
+     * @brief Update recovery evidence from one non-degraded telemetry window.
+     *
+     * @param snapshot Telemetry snapshot to observe.
+     * @param recovered_ratio Ratio of FEC-recovered data shards.
+     * @param high_latency Whether latency remains elevated.
+     * @param now Monotonic observation time.
+     */
+    void observe_stability(
+      const network_metrics::snapshot_t &snapshot,
+      long double recovered_ratio,
+      bool high_latency,
+      time_point_t now
+    );
+
+    /**
+     * @brief Clear unconfirmed degraded-window evidence.
+     */
+    void reset_degradation_confirmation();
+
+    /**
+     * @brief Consume a fresh control-channel liveness sample.
+     *
+     * @param control_liveness_token Latest control-channel receive token.
+     * @return `true` when the token is valid and was not previously consumed.
+     */
+    bool consume_control_liveness(std::uint32_t control_liveness_token);
+
+    /**
+     * @brief Update the stable RTT floor from live control-channel telemetry.
+     *
+     * @param now Monotonic control-loop time.
+     * @param live_rtt_ms Current smoothed RTT.
+     * @param live_rtt_variance_ms Current RTT variance.
+     * @return `true` when live latency is materially elevated.
+     */
+    bool observe_live_latency(time_point_t now, std::uint32_t live_rtt_ms, std::uint32_t live_rtt_variance_ms);
+
+    /**
+     * @brief Check whether the encoder command spacing interval has elapsed.
+     *
+     * @param now Monotonic control-loop time.
+     * @return `true` when another decision may be emitted.
+     */
+    bool decision_is_allowed(time_point_t now) const;
+
+    /**
+     * @brief Record and return one encoder decision.
+     *
+     * @param target_kbps Requested encoder target.
+     * @param reason Stable diagnostic reason for the command.
+     * @param now Monotonic decision time.
+     * @return Recorded encoder decision.
+     */
+    decision_t emit_decision(std::uint32_t target_kbps, decision_reason_e reason, time_point_t now);
+
+    /**
+     * @brief Emit a decrease for confirmed degradation when possible.
+     *
+     * @param now Monotonic control-loop time.
+     * @param decision_allowed Whether command spacing permits a decision.
+     * @return A decrease command, or no value.
+     */
+    std::optional<decision_t> reduce_for_pending_degradation(time_point_t now, bool decision_allowed);
+
+    /**
+     * @brief Check all stable recovery prerequisites.
+     *
+     * @param now Monotonic control-loop time.
+     * @param live_latency_high Whether live latency remains elevated.
+     * @param fresh_control_liveness Whether a new reliable acknowledgement was observed.
+     * @param decision_allowed Whether command spacing permits a decision.
+     * @return `true` when recovery may increase the bitrate.
+     */
+    bool recovery_is_allowed(
+      time_point_t now,
+      bool live_latency_high,
+      bool fresh_control_liveness,
+      bool decision_allowed
+    ) const;
+
+    /**
+     * @brief Check whether an upward direction reversal remains in cooldown.
+     *
+     * @param now Monotonic control-loop time.
+     * @return `true` while another upward reversal is blocked.
+     */
+    bool upward_reversal_is_cooling_down(time_point_t now) const;
+
     state_e state_ = state_e::fixed_disabled;  ///< Current lifecycle state.
     std::uint32_t floor_kbps_ = 0;  ///< Session floor, capped by the client ceiling.
     std::uint32_t ceiling_kbps_ = 0;  ///< Immutable effective client ceiling.
@@ -205,11 +352,8 @@ namespace stream::adaptive_bitrate {
     bool telemetry_seen_ = false;  ///< Whether a valid FEC report has been observed.
     bool fallback_after_acknowledgement_ = false;  ///< Defer invalid-telemetry fallback while an encoder command is in flight.
     bool recovery_blocked_by_rate_limit_ = false;  ///< Require a valid stable FEC report after telemetry overload.
-    decision_direction_e last_decision_direction_ = decision_direction_e::none;  ///< Latest non-probe command direction.
     std::optional<time_point_t> first_bad_window_at_;  ///< Time of the first consecutive bad window.
     std::optional<time_point_t> stable_since_;  ///< Start of the current no-new-pressure period.
-    std::optional<time_point_t> last_decision_at_;  ///< Time of the last emitted encoder command.
-    std::optional<time_point_t> last_increase_at_;  ///< Time of the last recovery increase.
-    std::optional<time_point_t> last_direction_reversal_at_;  ///< Latest non-probe command direction reversal.
+    decision_history_t decision_history_;  ///< Timing and direction of prior encoder decisions.
   };
 }  // namespace stream::adaptive_bitrate

src/adaptive_bitrate.h

@@ -153,8 +153,9 @@ namespace stream::network_metrics {
     const auto missing_data_packets = status->total_data_packets > status->received_data_packets ?
                                         static_cast<std::uint64_t>(status->total_data_packets - status->received_data_packets) :
                                         0;
-    const auto received_shards = static_cast<std::uint32_t>(status->received_data_packets) + status->received_parity_packets;
-    if (received_shards >= status->total_data_packets) {
+    if (const auto received_shards =
+          static_cast<std::uint32_t>(status->received_data_packets) + status->received_parity_packets;
+        received_shards >= status->total_data_packets) {
       accumulator_.fec_recovered_data_packets += missing_data_packets;
     } else {
       accumulator_.unrecovered_data_packets += missing_data_packets;

src/network_metrics.cpp

@@ -80,15 +80,15 @@ namespace NVENC_NAMESPACE {
     next_config.rcParams.maxBitRate = target_bps;
     if (baseline_vbv_buffer_size_ != 0) {
       auto scaled_vbv = scaled_from_baseline(baseline_vbv_buffer_size_);
-      if (!scaled_vbv) {
+      if (!scaled_vbv.has_value()) {
         result.status = video::bitrate_reconfigure_status_e::invalid;
         return result;
       }
       next_config.rcParams.vbvBufferSize = *scaled_vbv;
     }
     if (baseline_vbv_initial_delay_ != 0) {
       auto scaled_delay = scaled_from_baseline(baseline_vbv_initial_delay_);
-      if (!scaled_delay) {
+      if (!scaled_delay.has_value()) {
         result.status = video::bitrate_reconfigure_status_e::invalid;
         return result;
       }

src/nvenc/nvenc_reconfigure.cpp

@@ -116,14 +116,16 @@ namespace stream {
    * @return Stable lower-case diagnostic label.
    */
   std::string_view adaptive_bitrate_reason_name(const adaptive_bitrate::decision_reason_e reason) {
+    using enum adaptive_bitrate::decision_reason_e;
+
     switch (reason) {
-      case adaptive_bitrate::decision_reason_e::capability_check:
+      case capability_check:
         return "capability_check"sv;
-      case adaptive_bitrate::decision_reason_e::unrecovered_loss:
+      case unrecovered_loss:
         return "unrecovered_loss"sv;
-      case adaptive_bitrate::decision_reason_e::fec_pressure:
+      case fec_pressure:
         return "fec_pressure"sv;
-      case adaptive_bitrate::decision_reason_e::stable_recovery:
+      case stable_recovery:
         return "stable_recovery"sv;
     }
 

src/stream.cpp

@@ -47,16 +47,18 @@ using namespace std::literals;
 namespace video {
 
   std::string_view bitrate_reconfigure_status_name(bitrate_reconfigure_status_e status) {
+    using enum bitrate_reconfigure_status_e;
+
     switch (status) {
-      case bitrate_reconfigure_status_e::applied:
+      case applied:
         return "applied";
-      case bitrate_reconfigure_status_e::unchanged:
+      case unchanged:
         return "unchanged";
-      case bitrate_reconfigure_status_e::invalid:
+      case invalid:
         return "invalid";
-      case bitrate_reconfigure_status_e::unsupported:
+      case unsupported:
         return "unsupported";
-      case bitrate_reconfigure_status_e::failed:
+      case failed:
         return "failed";
     }
 

src/video.cpp

@@ -19,16 +19,19 @@ namespace {
   using namespace std::chrono_literals;
   using stream::network_metrics::frame_fec_status_payload_size;
 
+  /** Fixed-size control payload used by the parser tests. */
+  using frame_fec_status_payload_t = std::array<char, frame_fec_status_payload_size>;
+
   /**
    * @brief Write a big-endian 16-bit integer into a test payload.
    *
    * @param payload Destination payload.
    * @param offset Byte offset to write.
    * @param value Host-endian value.
    */
-  void put_u16_be(std::array<std::uint8_t, frame_fec_status_payload_size> &payload, const std::size_t offset, const std::uint16_t value) {
-    payload[offset] = static_cast<std::uint8_t>(value >> 8);
-    payload[offset + 1] = static_cast<std::uint8_t>(value);
+  void put_u16_be(frame_fec_status_payload_t &payload, const std::size_t offset, const std::uint16_t value) {
+    payload[offset] = static_cast<char>(value >> 8);
+    payload[offset + 1] = static_cast<char>(value);
   }
 
   /**
@@ -38,11 +41,11 @@ namespace {
    * @param offset Byte offset to write.
    * @param value Host-endian value.
    */
-  void put_u32_be(std::array<std::uint8_t, frame_fec_status_payload_size> &payload, const std::size_t offset, const std::uint32_t value) {
-    payload[offset] = static_cast<std::uint8_t>(value >> 24);
-    payload[offset + 1] = static_cast<std::uint8_t>(value >> 16);
-    payload[offset + 2] = static_cast<std::uint8_t>(value >> 8);
-    payload[offset + 3] = static_cast<std::uint8_t>(value);
+  void put_u32_be(frame_fec_status_payload_t &payload, const std::size_t offset, const std::uint32_t value) {
+    payload[offset] = static_cast<char>(value >> 24);
+    payload[offset + 1] = static_cast<char>(value >> 16);
+    payload[offset + 2] = static_cast<char>(value >> 8);
+    payload[offset + 3] = static_cast<char>(value);
   }
 
   /**
@@ -56,15 +59,15 @@ namespace {
    * @param fec_percentage Sender FEC percentage encoded in the frame header.
    * @return Big-endian SS_FRAME_FEC_STATUS payload.
    */
-  std::array<std::uint8_t, frame_fec_status_payload_size> make_payload(
+  frame_fec_status_payload_t make_payload(
     const std::uint16_t total_data,
     const std::uint16_t total_parity,
     const std::uint16_t received_data,
     const std::uint16_t received_parity,
     const std::uint16_t missing,
     const std::uint8_t fec_percentage = 30
   ) {
-    std::array<std::uint8_t, frame_fec_status_payload_size> payload {};
+    frame_fec_status_payload_t payload {};
     put_u32_be(payload, 0, 42);
     put_u16_be(payload, 4, 120);
     put_u16_be(payload, 6, 115);
@@ -73,7 +76,7 @@ namespace {
     put_u16_be(payload, 12, total_parity);
     put_u16_be(payload, 14, received_data);
     put_u16_be(payload, 16, received_parity);
-    payload[18] = fec_percentage;
+    payload[18] = static_cast<char>(fec_percentage);
     payload[19] = 0;
     payload[20] = 1;
     return payload;
@@ -86,8 +89,8 @@ namespace {
    * @return String view spanning the payload bytes.
    */
   template<std::size_t Size>
-  std::string_view payload_view(const std::array<std::uint8_t, Size> &payload) {
-    return {reinterpret_cast<const char *>(payload.data()), payload.size()};
+  std::string_view payload_view(const std::array<char, Size> &payload) {
+    return {payload.data(), payload.size()};
   }
 }  // namespace
 
@@ -116,8 +119,8 @@ TEST(FrameFecStatusTests, ParsesCurrentBigEndianWireFormat) {
 }
 
 TEST(FrameFecStatusTests, RejectsPayloadWithWrongVersionSize) {
-  std::array<std::uint8_t, frame_fec_status_payload_size - 1> short_payload {};
-  std::array<std::uint8_t, frame_fec_status_payload_size + 1> long_payload {};
+  std::array<char, frame_fec_status_payload_size - 1> short_payload {};
+  std::array<char, frame_fec_status_payload_size + 1> long_payload {};
 
   EXPECT_FALSE(stream::network_metrics::parse_frame_fec_status(payload_view(short_payload)));
   EXPECT_FALSE(stream::network_metrics::parse_frame_fec_status(payload_view(long_payload)));
@@ -198,7 +201,7 @@ TEST(NetworkMetricsTrackerTests, RequiresAdvertisedFeature) {
 TEST(NetworkMetricsTrackerTests, CountsMalformedPayloads) {
   const auto start = stream::network_metrics::time_point_t {};
   stream::network_metrics::tracker_t tracker {start};
-  std::array<std::uint8_t, frame_fec_status_payload_size - 1> payload {};
+  std::array<char, frame_fec_status_payload_size - 1> payload {};
 
   EXPECT_EQ(
     tracker.ingest(payload_view(payload), true),